Given a nested list of integers, return the sum of all integers in the list weighted by their depth.

Each element is either an integer, or a list -- whose elements may also be integers or other lists.

* Method 1: Recursion

```Java

/**

class Solution {

private int sum = 0;

public int depthSum(List<NestedInteger> nestedList) {

if(nestedList == null || nestedList.size() == 0) return 0;

depthSum(nestedList, 1);

return this.sum;

}

private void depthSum(List<NestedInteger> nestedList, int depth){

List<NestedInteger> next = new ArrayList<>();

int sum = 0;

for(NestedInteger num : nestedList){

if(num.isInteger()) sum += num.getInteger();

else next.addAll(num.getList());

}

this.sum += depth * sum;

if(next.size() != 0) depthSum(next, depth + 1);

}

}

```

We are given a list schedule of employees, which represents the working time for each employee.

Each employee has a list of non-overlapping Intervals, and these intervals are in sorted order.

Return the list of finite intervals representing common, positive-length free time for all employees, also in sorted order.

(Even though we are representing Intervals in the form [x, y], the objects inside are Intervals, not lists or arrays. For example, schedule[0][0].start = 1, schedule[0][0].end = 2, and schedule[0][0][0] is not defined.)

Also, we wouldn't include intervals like [5, 5] in our answer, as they have zero length.

Note:

1. schedule and schedule[i] are lists with lengths in range [1, 50].

2. 0 <= schedule[i].start < schedule[i].end <= 10^8.

* Method 1: Sort

```Java

class Solution {

private static final Comparator<int[]> cmp = new Comparator<int[]>(){

@Override

public int compare(int[] a, int[] b){

return a[0] == b[0] ? (a[1] - b[1]): (a[0] - b[0]);

}

};

public int[][] employeeFreeTime(int[][][] schedule) {

List<int[]> list = new ArrayList<>();

for(int[][] person : schedule){ // O(N), N is the total number of intervals

for(int[] interval : person)

list.add(interval);

}

if(list.size() == 0) return new int[0][2];

Collections.sort(list, cmp); //O(NlgN)

List<int[]> res = new ArrayList<>();

int end = list.get(0)[1];

for(int i = 1; i < list.size(); i++){ // O(N)

int[] cur = list.get(i);

if(cur[0] > end){

res.add(new int[]{end, cur[0]});

}

end = Math.max(end, cur[1]);

}

return res.toArray(new int[0][2]);

}

}

```

Given a set of points in the xy-plane, determine the minimum area of a rectangle formed from these points, with sides parallel to the x and y axes.

If there isn't any rectangle, return 0.

Note:

1. 1 <= points.length <= 500

2. 0 <= points[i][0] <= 40000

3. 0 <= points[i][1] <= 40000

4. All points are distinct.

* Method 1: HashSet O(n^2)

```Java

class Solution {

public int minAreaRect(int[][] points) {

Set<Integer> set = new HashSet<>();

int len = points.length;

int res = Integer.MAX_VALUE;

for(int i = 0; i < len; i++){

int[] first = points[i];

set.add(first[0] * 40001 + first[1]);

for(int j = i + 1; j < len; j++){

int[] second = points[j];

set.add(second[0] * 40001 + second[1]);

if(first[0] == second[0] || first[1] == second[1]) continue;

int find1 = second[0] * 40001 + first[1], find2 = first[0] * 40001 + second[1];

if(set.contains(find1) && set.contains(find2))

res = Math.min(res, Math.abs(first[0] - second[0]) * Math.abs(first[1] - second[1]));

}

}

return res == Integer.MAX_VALUE ? 0: res;

}

}

```

* Method 2: TreeMap + HashMap

```Java

class Solution {

public int minAreaRect(int[][] points) {

Map<Integer, List<Integer>> map = new TreeMap<>();

for(int[] point: points){ //O(nlgn)

int x = point[0], y = point[1];

List<Integer> ys = map.getOrDefault(x, new ArrayList<>());

ys.add(y);

map.put(x, ys);

}

Map<Integer, Integer> last = new HashMap<>(); // key is y diff and x is row number

int res = Integer.MAX_VALUE;

for(Map.Entry<Integer, List<Integer>> entry : map.entrySet()){ //O(n)

List<Integer> list = entry.getValue();

Collections.sort(list); // O(lineNum lg lineNum)

for(int i = 0; i < list.size(); i++){

int first = list.get(i);

for(int j = i + 1; j < list.size(); j++){

int second = list.get(j);

int key = first * 40001 + second;

if(last.containsKey(key)){

res = Math.min(res, Math.abs(first - second) * Math.abs(entry.getKey() - last.get(key)));

}

last.put(key, entry.getKey());

}

}

}

return res == Integer.MAX_VALUE ? 0: res;

}

}

```

* Method 1: Sort head and tail sparately

* Method 2: Sort with head and tail together.

```Java

class Solution {

public int[][] intervalIntersection(int[][] A, int[][] B) {

int len = A.length + B.length;

if(len == 0) return new int[0][2];

int[][] arr = new int[len][2];

for(int i = 0; i < A.length; i++) arr[i] = A[i];

for(int i = A.length; i < len; i++) arr[i] = B[i - A.length];

Arrays.sort(arr, (a, b)->{

return a[0] == b[0] ? a[1] - b[1]: a[0] - b[0];

});

int end = arr[0][1];

List<int[]> res = new ArrayList<>();

for(int i = 1; i < len; i++){

if(arr[i][0] <= end){

res.add(new int[]{arr[i][0], Math.min(arr[i][1], end)});

}

if(end < arr[i][1])

end = arr[i][1];

}

int size = res.size();

int[][] result = new int[size][2];

for(int i = 0; i < size; i++) result[i] = res.get(i);

return result;

}

}

```