LeetCode

310. Minimum Height Trees

For a undirected graph with tree characteristics, we can choose any node as the root. The result graph is then a rooted tree. Among all possible rooted trees, those with minimum height are called minimum height trees (MHTs). Given such a graph, write a function to find all the MHTs and return a list of their root labels.

Format
The graph contains n nodes which are labeled from 0 to n - 1. You will be given the number n and a list of undirected edges (each edge is a pair of labels).

You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.

Example 1:

Given n = 4, edges = [[1, 0], [1, 2], [1, 3]]

        0
        |
        1
       / 
      2   3
return [1]

Example 2:

Given n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]

     0  1  2
       | /
        3
        |
        4
        |
        5
return [3, 4]

 思路：普通的暴力BFS会超时，即对每个节点用BFS统计以该节点为根的树高，然后排序输出结果。现从树的度入手，统计每个节点的度，然后度为1的入列（删除该节点），出列后将该节点的度置为0，对该节点的每个邻居节点，若邻居节点度为0，说明已经访问过，continue掉，否则度减1，如果度为1就入列，否则继续。注意当只有一个节点时的特殊情况，此时是图，所以结果是包含0的list而不是空list！

public class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> result = new ArrayList<>();
        //边数不等于顶点数 - 1不是图
        if (n <= 0 || edges.length != n - 1) {
            return result;
        }
        //特殊情况，只有一个孤立节点，是图。
        if (n == 1) {
            result.add(0);
            return result;
        }
        Map<Integer, List<Integer>> map = new HashMap<>();
        int[] inDegree = new int[n];
        for (int i = 0; i < n; i++) {
            map.put(i, new ArrayList<Integer>());
        }
        for (int i = 0; i < edges.length; i++) {
            map.get(edges[i][0]).add(edges[i][1]);
            map.get(edges[i][1]).add(edges[i][0]);
            inDegree[edges[i][0]]++;
            inDegree[edges[i][1]]++;
        }
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            //大于等于2个节点，只要有一个节点的度为0，说明不连通，不是图
            if (inDegree[i] == 0) {
                return result;
            }
            if (inDegree[i] == 1) {
                queue.offer(i);
            }
        }
        while (!queue.isEmpty()) {
            int size = queue.size();
            result = new ArrayList<Integer>();
            for (int i = 0; i < size; i++) {
                int num = queue.poll();
                result.add(num);
                inDegree[num]--;
                for (int temp : map.get(num)) {
                    if (inDegree[temp] == 0) {
                        continue;
                    }
                    inDegree[temp]--;
                    if (inDegree[temp] == 1) {
                        queue.offer(temp);
                    }
                }
            }
        }
        return result;
    }
}

524. Longest Word in Dictionary through Deleting

Given a string and a string dictionary, find the longest string in the dictionary that can be formed by deleting some characters of the given string. If there are more than one possible results, return the longest word with the smallest lexicographical order. If there is no possible result, return the empty string.

Example 1:
Input:
s = "abpcplea", d = ["ale","apple","monkey","plea"]

Output: 
"apple"
Example 2:
Input:
s = "abpcplea", d = ["a","b","c"]

Output: 
"a"
Note:
All the strings in the input will only contain lower-case letters.
The size of the dictionary won't exceed 1,000.
The length of all the strings in the input won't exceed 1,000.

注意此题比较一个单词是否能由另一个单词经过删掉一些字符来构造的算法思想！

思路I：先按题目要求排序，然后依次取出词典里的词，如果该词可以被构造出，则返回该词，介绍，可以在中间就可以结束而不必遍历词典里的所有词。

public class Solution {
    public String findLongestWord(String s, List<String> d) {
        if (s == null || s.length() == 0 || d == null || d.size() == 0) {
            return "";
        }
        Collections.sort(d, new Comparator<String>() {
            public int compare(String a, String b) {
                if (a.length() != b.length()) {
                    return b.length() - a.length();
                }
                return a.compareTo(b);
            }
        });
        for (String str : d) {
            int index = 0;
            for (int i = 0; i < s.length(); i++) {
                if (index < str.length() && s.charAt(i) == str.charAt(index)) {
                    index++;
                }
            }
            if (index == str.length()) {
                return str;
            }
        }
        return "";
    }
}

 思路II：不排序，依次取出词典里的词，如果该词可以被构造出，此时满足以下两种情况方可更新长度最长且按字典排序最小的词longest。1.该词长度大于longest 2.该词长度等于longest，但是该词按字典顺序排序的结果小于longest。

public class Solution {
    public String findLongestWord(String s, List<String> d) {
        if (s == null || s.length() == 0 || d == null || d.size() == 0) {
            return "";
        }
        String longest = "";
        for (String str : d) {
            int index = 0;
            for (int i = 0; i < s.length(); i++) {
                if (index < str.length() && s.charAt(i) == str.charAt(index)) {
                    index++;
                }
            }
            if (index == str.length() && str.length() >= longest.length()) {
                if (str.length() > longest.length()) {
                    longest = str;
                }
                if (str.compareTo(longest) < 0) {
                    longest = str;
                }
            }
        }
        return longest;
    }
}

31. Next Permutation

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place, do not allocate extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

思路：从后往前找一个数比后一个数小的位置，然后从后往前找到第一个大于该数的位置并与该数交换，然后翻转该数原来的索引到数组末尾的元素。如果找不到该数，说明元素已从大到小排好序，直接reverse即可。

public class Solution {
    public void nextPermutation(int[] nums) {
        if (nums == null || nums.length == 0) {
            return;
        }
        for (int i = nums.length - 2; i >= 0; i--) {
            if (nums[i] < nums[i + 1]) {
                for (int j = nums.length - 1; j > i; j--) {
                    if (nums[j] > nums[i]) {
                        swap(nums, i, j);
                        reverse(nums, i + 1, nums.length - 1);
                        return;
                    }
                }
            }
        }
        reverse(nums, 0, nums.length - 1);
        return;
    }
    public void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
    public void reverse(int[] nums, int start, int end) {
        int left = start;
        int right = end;
        while (left < right) {
            swap(nums, left, right);
            left++;
            right--;
        }
    }
}

297. Serialize and Deserialize Binary Tree

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.

For example, you may serialize the following tree

    1
   / 
  2   3
     / 
    4   5
as "[1,2,3,null,null,4,5]", just the same as how LeetCode OJ serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.
Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.

思路：序列化和反序列化都用List存放树节点。序列化要注意的就是去掉List尾部多余的null，这部分没必要不用序列化。反序列化要注意的是用leftChild来指示当前遍历的节点是父节点的左儿子还是右儿子，用index索引指示当前遍历的节点的父节点，只有遍历了右节点之后（leftChild指针为false）index才++，表示父节点为下一位。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if (root == null) {
            return "[]";
        }
        List<TreeNode> buffer = new ArrayList<>();
        buffer.add(root);
        for (int i = 0; i < buffer.size(); i++) {
            TreeNode node = buffer.get(i);
            if (node != null) {
                buffer.add(node.left);
                buffer.add(node.right);
            }
        }
        while (buffer.get(buffer.size() - 1) == null) {
            buffer.remove(buffer.size() - 1);
        }
        StringBuilder sb = new StringBuilder();
        sb.append("[").append(buffer.get(0).val);
        for (int i = 1; i < buffer.size(); i++) {
            if (buffer.get(i) != null) {
                sb.append(",").append(buffer.get(i).val);
            } else {
                sb.append(",").append("null");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data == null || data.length() <= 2) {
            return null;
        }
        String[] vals = data.substring(1, data.length() - 1).split(",");
        TreeNode root = new TreeNode(Integer.parseInt(vals[0]));
        List<TreeNode> buffer = new ArrayList<>();
        buffer.add(root);
        boolean leftChild = true;
        int index = 0;
        for (int i = 1; i < vals.length; i++) {
            if (!vals[i].equals("null")) {
                TreeNode node = new TreeNode(Integer.parseInt(vals[i]));
                if (leftChild) {
                    buffer.get(index).left = node;
                } else {
                    buffer.get(index).right = node;
                }
                buffer.add(node);
            }
            if (!leftChild) {
                index++;
            }
            leftChild = !leftChild;
        }
        return root;
    }
}

// Your Codec object will be instantiated and called as such:
// Codec codec = new Codec();
// codec.deserialize(codec.serialize(root));

55. Jump Game

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Determine if you are able to reach the last index.

For example:
A = [2,3,1,1,4], return true.

A = [3,2,1,0,4], return false.

思路：用一farthest索引表示能达到的最大索引是多少，最后只要判断farthest >= nums.length - 1即可。

public class Solution {
    public boolean canJump(int[] nums) {
        if (nums == null || nums.length == 0) {
            return true;
        }
        int farthest = 0;
        for (int i = 0; i < nums.length; i++) {
            if (i <= farthest && i + nums[i] > farthest) {
                farthest = i + nums[i];
            }
        }
        return farthest >= nums.length - 1;
    }
}

45. Jump Game II

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Your goal is to reach the last index in the minimum number of jumps.

For example:
Given array A = [2,3,1,1,4]

The minimum number of jumps to reach the last index is 2. (Jump 1 step from index 0 to 1, then 3 steps to the last index.)

思路：注意当数组只有一个元素即起点和终点相同时最小跳数是0，这种特殊情况不能在循环里面算，否则出错。每次都计算最远到哪里，然后从start到end依次遍历计算下一次最远到哪里。跳数++。

public class Solution {
    public int jump(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return 0;
        }
        int start = 0;
        int end = 0;
        int farthest = 0;
        int steps = 0;
        while (start <= end) {
            steps++;
            for (int i = start; i <= end; i++) {
                if (i +nums[i] > farthest) {
                    farthest = i + nums[i];
                }
            }
            if (farthest >= nums.length - 1) {
                return steps;
            }
            start = end + 1;
            end = farthest;
        }
        return -1;
    }
}

51. N-Queens

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.

Example
There exist two distinct solutions to the 4-queens puzzle:

[
  // Solution 1
  [".Q..",
   "...Q",
   "Q...",
   "..Q."
  ],
  // Solution 2
  ["..Q.",
   "Q...",
   "...Q",
   ".Q.."
  ]
]

思路：注意tempList存放的是每个皇后的索引，当tempList装满后再根据tempList中的索引画出棋盘加入到results中。

public class Solution {
    public List<List<String>> solveNQueens(int n) {
        List<List<String>> results = new ArrayList<>();
        if (n < 1) {
            return results;
        }
        dfsHelper(n, new ArrayList<Integer>(), results);
        return results;
    }
    public void dfsHelper(int n, List<Integer> tempList, List<List<String>> results) {
        if (tempList.size() == n) {
            results.add(drawChessBoard(tempList));
            return;
        }
        for (int i = 0; i < n; i++) {
            if (!valid(i, tempList)) {
                continue;
            }
            tempList.add(i);
            dfsHelper(n, tempList, results);
            tempList.remove(tempList.size() - 1);
        }
    }
    public boolean valid(int index, List<Integer> tempList) {
        int size = tempList.size();
        for (int i = 0; i < size; i++) {
            if (tempList.get(i) == index) {
                return false;
            }
            if (i - tempList.get(i) == size - index) {
                return false;
            }
            if (i + tempList.get(i) == size + index) {
                return false;
            }
        }
        return true;
    }
    public List<String> drawChessBoard(List<Integer> tempList) {
        List<String> result = new ArrayList<>();
        for (int i = 0; i < tempList.size(); i++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < tempList.size(); j++) {
                if (j == tempList.get(i)) {
                    sb.append("Q");
                } else {
                    sb.append(".");
                }
            }
            result.add(sb.toString());
        }
        return result;
    }
}

52. N-Queens II

Follow up for N-Queens problem.

Now, instead outputting board configurations, return the total number of distinct solutions.

思路：同N-Queens，只需要设置一个全局变量solutions来统计方案的个数即可，不用创建results了。

public class Solution {
    public int solutions = 0;
    public int totalNQueens(int n) {
        if (n < 1) {
            return 0;
        }
        dfsHelper(n, new ArrayList<Integer>());
        return solutions;
    }
    public void dfsHelper(int n, List<Integer> tempList) {
        if (tempList.size() == n) {
            solutions++;
            return;
        }
        for (int i = 0; i < n; i++) {
            if (!valid(i, tempList)) {
                continue;
            }
            tempList.add(i);
            dfsHelper(n, tempList);
            tempList.remove(tempList.size() - 1);
        }
    }
    public boolean valid(int index, List<Integer> tempList) {
        int size = tempList.size();
        for (int i = 0; i < size; i++) {
            if (tempList.get(i) == index) {
                return false;
            }
            if (i - tempList.get(i) == size - index) {
                return false;
            }
            if (i + tempList.get(i) == size + index) {
                return false;
            }
        }
        return true;
    }
}

232. Implement Queue using Stacks

Implement the following operations of a queue using stacks.

push(x) -- Push element x to the back of queue.
pop() -- Removes the element from in front of queue.
peek() -- Get the front element.
empty() -- Return whether the queue is empty.
Notes:
You must use only standard operations of a stack -- which means only push to top, peek/pop from top, size, and is empty operations are valid.
Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.
You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).

思路：用两个栈来实现队列。stack1用来push元素，stack2用来pop元素，stack2执行pop操作元素不够的时候将stack1里的元素倒入stack2即可。

public class MyQueue {
    Stack<Integer> stack1;
    Stack<Integer> stack2;
    
    /** Initialize your data structure here. */
    public MyQueue() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
        stack1.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        if (!stack2.isEmpty()) {
            return stack2.pop();
        }
        while (!stack1.isEmpty()) {
            stack2.push(stack1.pop());
        }
        if (!stack2.isEmpty()) {
            return stack2.pop();
        }
        return 0;
    }
    
    /** Get the front element. */
    public int peek() {
        if (!stack2.isEmpty()) {
            return stack2.peek();
        }
        while (!stack1.isEmpty()) {
            stack2.push(stack1.pop());
        }
        if (!stack2.isEmpty()) {
            return stack2.peek();
        }
        return 0;
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return stack1.isEmpty() && stack2.isEmpty();
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

225. Implement Stack using Queues

Implement the following operations of a stack using queues.

push(x) -- Push element x onto stack.
pop() -- Removes the element on top of the stack.
top() -- Get the top element.
empty() -- Return whether the stack is empty.
Notes:
You must use only standard operations of a queue -- which means only push to back, peek/pop from front, size, and is empty operations are valid.
Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).

思路：用两个队列实现栈。queue1用来执行所有操作，queue2作为辅助队列用来辅助pop和top操作，不需要把queue2里的元素出列然后入列给queue1，只需要交换两个队列即可。

public class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;
    /** Initialize your data structure here. */
    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        queue1.offer(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        if (queue1.size() == 0) {
            return 0;
        }
        int size = queue1.size();
        for (int i = 0; i < size - 1; i++) {
            queue2.offer(queue1.poll());
        }
        int result = queue1.poll();
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
        return result;
    }
    
    /** Get the top element. */
    public int top() {
        if (queue1.size() == 0) {
            return 0;
        }
        int size = queue1.size();
        for (int i = 0; i < size - 1; i++) {
            queue2.offer(queue1.poll());
        }
        int result = queue1.peek();
        queue2.offer(queue1.poll());
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
        return result;
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue1.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

155. Min Stack

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

push(x) -- Push element x onto stack.
pop() -- Removes the element on top of the stack.
top() -- Get the top element.
getMin() -- Retrieve the minimum element in the stack.
Example:
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> Returns -3.
minStack.pop();
minStack.top();      --> Returns 0.
minStack.getMin();   --> Returns -2.

思路：维护两个栈，一个普通stack，一个minStack用来存最小元素。每次操作都更新两个stack，两个栈的size时刻一样。

public class MinStack {
    Stack<Integer> stack;
    Stack<Integer> minStack;
    /** initialize your data structure here. */
    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
    
    public void push(int x) {
        stack.push(x);
        if (minStack.isEmpty()) {
            minStack.push(x);
        } else {
            if (x < minStack.peek()) {
                minStack.push(x);
            } else {
                minStack.push(minStack.peek());
            }
        }
    }
    
    public void pop() {
        stack.pop();
        minStack.pop();
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        if (minStack.isEmpty()) {
            return 0;
        }
        return minStack.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

341. Flatten Nested List Iterator

Given a nested list of integers, implement an iterator to flatten it.

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

Example 1:
Given the list [[1,1],2,[1,1]],

By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].

Example 2:
Given the list [1,[4,[6]]],

By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].

思路：用栈来保存，hasNext的时候记得把栈顶元素（如果栈顶元素不是Integer的话）flatten（即执行pushListToStack直到栈顶元素为Integer）。

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * public interface NestedInteger {
 *
 *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
 *     public boolean isInteger();
 *
 *     // @return the single integer that this NestedInteger holds, if it holds a single integer
 *     // Return null if this NestedInteger holds a nested list
 *     public Integer getInteger();
 *
 *     // @return the nested list that this NestedInteger holds, if it holds a nested list
 *     // Return null if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
public class NestedIterator implements Iterator<Integer> {
    Stack<NestedInteger> stack;
    public NestedIterator(List<NestedInteger> nestedList) {
        stack = new Stack<>();
        pushListToStack(nestedList);
    }
    public void pushListToStack(List<NestedInteger> nestedList) {
        Stack<NestedInteger> temp = new Stack<>();
        for (NestedInteger nested : nestedList) {
            temp.push(nested);
        }
        while (!temp.isEmpty()) {
            stack.push(temp.pop());
        }
    }

    @Override
    public Integer next() {
        if (!hasNext()) {
            return null;
        }
        return stack.pop().getInteger();
    }

    @Override
    public boolean hasNext() {
        while (!stack.isEmpty() && !stack.peek().isInteger()) {
            pushListToStack(stack.pop().getList());
        }
        return !stack.isEmpty();
    }
}

/**
 * Your NestedIterator object will be instantiated and called as such:
 * NestedIterator i = new NestedIterator(nestedList);
 * while (i.hasNext()) v[f()] = i.next();
 */

84. Largest Rectangle in Histogram

Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

For example,
Given heights = [2,1,5,6,2,3],
return 10.

思路：用栈来保存索引，在数组末尾插入0，只要遇到当前高度小于等于前一个高度，就计算前面能围成的矩形面积并更新max，注意计算矩形宽度的时候要根据栈是否为空来取值。

public class Solution {
    public int largestRectangleArea(int[] heights) {
        if (heights == null || heights.length == 0) {
            return 0;
        }
        Stack<Integer> stack = new Stack<>();
        int max = 0;
        for (int i = 0; i <= heights.length; i++) {
            int cur = i == heights.length ? 0 : heights[i];
            while (!stack.isEmpty() && cur <= heights[stack.peek()]) {
                int h = heights[stack.pop()];
                int w = stack.isEmpty() ? i : i - 1 - stack.peek();
                max = Math.max(max, h * w);
            }
            stack.push(i);
        }
        return max;
    }
}

215. Kth Largest Element in an Array

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

For example,
Given [3,2,1,5,6,4] and k = 2, return 5.

Note: 
You may assume k is always valid, 1 ≤ k ≤ array's length.

思路I：最小堆。时间复杂度O(nlgk)，空间复杂度O(k)

public class Solution {
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k < 1 || k > nums.length) {
            return 0;
        }
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int i = 0; i < nums.length; i++) {
            if (pq.size() < k) {
                pq.offer(nums[i]);
            } else {
                if (nums[i] > pq.peek()) {
                    pq.poll();
                    pq.offer(nums[i]);
                }
            }
        }
        return pq.peek();
    }
}

思路II：partition。求第K大因此要按从大到小partition，partition中不要有=号，只有">"和"<"。时间复杂度O(n)，空间复杂度O(1)。

Time Complexity: average = O(n); worst case O(n^2), O(1) space

Time Complexity O(n)来自于O(n) + O(n/2) + O(n/4) + ... ~ O(2n)，此时每次partition的pivot大约将区间对半分。

public class Solution {
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k < 1 || k > nums.length) {
            return 0;
        }
        return partition(nums, 0, nums.length - 1, k);
    }
    public int partition(int[] nums, int start, int end, int k) {
        if (start == end) {
            return nums[start];
        }
        int mid = nums[start + (end - start) / 2];
        int left = start;
        int right = end;
        while (left <= right) {
            while (left <= right && nums[left] > mid) {
                left++;
            }
            while (left <= right && nums[right] < mid) {
                right--;
            }
            if (left <= right) {
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
                right--;
            }
        }
        if (k <= right - start + 1) {
            return partition(nums, start, right, k);
        }
        if (k >= left - start + 1) {
            return partition(nums, left, end, k - (left - start));
        }
        return nums[left - 1];
    }
}

239. Sliding Window Maximum

Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.

For example,
Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.

Window position                Max
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7
Therefore, return the max sliding window as [3,3,5,5,6,7].

Note: 
You may assume k is always valid, ie: 1 ≤ k ≤ input array's size for non-empty array.

思路：双端队列Deque来存储可能的最大值，入列的时候把小于当前值的元素全部出列（这些元素不可能为最大值），出列时如果要出列的元素的值等于队列首元素的值（最大值），则把这个最大元素出列。

public class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k < 1 || k > nums.length) {
            return new int[0];
        }
        int[] result = new int[nums.length - k + 1];
        Deque<Integer> deque = new ArrayDeque<>();
        for (int i = 0; i < k - 1; i++) {
            inQueue(deque, nums[i]);
        }
        for (int i = k - 1; i < nums.length; i++) {
            inQueue(deque, nums[i]);
            result[i - k + 1] = deque.peekFirst();
            outQueue(deque, nums[i - k + 1]);
        }
        return result;
    }
    public void inQueue(Deque<Integer> deque, int num) {
        while (!deque.isEmpty() && num > deque.peekLast()) {
            deque.pollLast();
        }
        deque.offerLast(num);
    }
    public void outQueue(Deque<Integer> deque, int num) {
        if (num == deque.peekFirst()) {
            deque.pollFirst();
        }
    }
}

295. Find Median from Data Stream

Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.

Examples: 
[2,3,4] , the median is 3

[2,3], the median is (2 + 3) / 2 = 2.5

Design a data structure that supports the following two operations:

void addNum(int num) - Add a integer number from the data stream to the data structure.
double findMedian() - Return the median of all elements so far.
For example:

addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3) 
findMedian() -> 2

思路：维护一个大根堆和一个小根堆，待插入的元素小于等于大根堆堆顶元素值，就插入到大根堆，否则插入到小根堆。每插入一次就要调整堆使大根堆元素个数等于小根堆元素个数或者比小根堆元素个数多1个。调整分两种情况：（1）maxHeap.size() - minHeap.size() > 1 （2）minHeap.size() - maxHeap.size() > 0。

public class MedianFinder {
    PriorityQueue<Integer> maxHeap;
    PriorityQueue<Integer> minHeap;
    /** initialize your data structure here. */
    public MedianFinder() {
        maxHeap = new PriorityQueue<>(10, Collections.reverseOrder());
        minHeap = new PriorityQueue<>();
    }
    
    public void addNum(int num) {
        if (maxHeap.isEmpty() || num <= maxHeap.peek()) {
            maxHeap.offer(num);
        } else {
            minHeap.offer(num);
        }
        if (maxHeap.size() - minHeap.size() > 1) {
            minHeap.offer(maxHeap.poll());
        }
        if (minHeap.size() - maxHeap.size() > 0) {
            maxHeap.offer(minHeap.poll());
        }
    }
    
    public double findMedian() {
        int size = maxHeap.size() + minHeap.size();
        if (size == 0) {
            return 0;
        }
        if (size % 2 == 0) {
            return (maxHeap.peek() + minHeap.peek()) / 2.0;
        } else {
            return maxHeap.peek();
        }
    }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

403. Frog Jump

A frog is crossing a river. The river is divided into x units and at each unit there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.

Given a list of stones' positions (in units) in sorted ascending order, determine if the frog is able to cross the river by landing on the last stone. Initially, the frog is on the first stone and assume the first jump must be 1 unit.

If the frog's last jump was k units, then its next jump must be either k - 1, k, or k + 1 units. Note that the frog can only jump in the forward direction.

Note:

The number of stones is ≥ 2 and is < 1,100.
Each stone's position will be a non-negative integer < 231.
The first stone's position is always 0.
Example 1:

[0,1,3,5,6,8,12,17]

There are a total of 8 stones.
The first stone at the 0th unit, second stone at the 1st unit,
third stone at the 3rd unit, and so on...
The last stone at the 17th unit.

Return true. The frog can jump to the last stone by jumping 
1 unit to the 2nd stone, then 2 units to the 3rd stone, then 
2 units to the 4th stone, then 3 units to the 6th stone, 
4 units to the 7th stone, and 5 units to the 8th stone.
Example 2:

[0,1,2,3,4,8,9,11]

Return false. There is no way to jump to the last stone as 
the gap between the 5th and 6th stone is too large.

思路：见答案中注释。

public class Solution {
    public boolean canCross(int[] stones) {
        if (stones == null || stones.length == 0) {
            return true;
        }
        //1. 状态定义 dp的key表示第i的石头的索引，value表示跳到第i个石头的前一步的所有可能的跳数。
        Map<Integer, Set<Integer>> map = new HashMap<>();
        for (int i = 0; i < stones.length; i++) {
            map.put(stones[i], new HashSet<>());
        }
        //2. 初始化
        map.get(0).add(0);
        //3. 循环递归求解
        for (int i = 0; i < stones.length; i++) {
            int stone = stones[i];
            for (int steps : map.get(stone)) {
                if (steps > 1 && map.containsKey(stones[i] + steps - 1)) {
                    map.get(stones[i] + steps - 1).add(steps - 1);
                }
                if (steps > 0 && map.containsKey(stones[i] + steps)) {
                    map.get(stones[i] + steps).add(steps);
                }
                if (map.containsKey(stones[i] + steps + 1)) {
                    map.get(stones[i] + steps + 1).add(steps + 1);
                }
            }
        }
        //4. 返回结果
        return !map.get(stones[stones.length - 1]).isEmpty();
    }
}

263. Ugly Number

Write a program to check whether a given number is an ugly number.

Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. For example, 6, 8 are ugly while 14 is not ugly since it includes another prime factor 7.

Note that 1 is typically treated as an ugly number.

思路：很简单，判断一个数是否为丑数只要不断去掉该数的2、3和5因子，最后判断得到的数是否等于1即可。

public class Solution {
    public boolean isUgly(int num) {
        if (num < 1) {
            return false;
        }
        while (num % 2 == 0) {
            num /= 2;
        }
        while (num % 3 == 0) {
            num /= 3;
        }
        while (num % 5 == 0) {
            num /= 5;
        }
        return num == 1;
    }
}

264. Ugly Number II

Write a program to find the n-th ugly number.

Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. For example, 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 is the sequence of the first 10 ugly numbers.

Note that 1 is typically treated as an ugly number, and n does not exceed 1690.

思路I：最小堆。每取出一个丑数，将该丑数分别乘以2，3，5得到接下来的丑数，如果堆里面没有就加进去。注意这种方法入堆的丑数总个数大于要求的第n个丑数，因此数据会溢出，所以该用long型最后返回结果时再强制转换回来即可。每次从堆里取出一个最小的丑数，循环n次即可。时间复杂度O(nlogn)，空间复杂度O(n)。

public class Solution {
    public int nthUglyNumber(int n) {
        if (n < 1) {
            return 0;
        }
        int[] factors = {2, 3, 5};
        Queue<Long> queue = new PriorityQueue<>();
        queue.offer(1L);
        long number = 1L;
        for (int i = 0; i < n; i++) {
            number = queue.poll();
            for (int j = 0; j < 3; j++) {
                if (!queue.contains(number * factors[j])) {
                    queue.offer(number * factors[j]);
                }
            }
        }
        return (int) number;
    }
}

思路II：动态规划。新建3个指针分别指向2的倍数、3的倍数和5的倍数的位置，起始都从0开始。每次计算p2 *2, p3 * 3, p5 * 5的最小值作为当前的丑数，当前丑数如果是由p2 * 2得到，则p2++;由p3 * 3得到，则p3++;由p5* 5得到，则p5++。当list中元素个数等于n时停止循环，返回第n个数即可。时间复杂度O(n)，空间复杂度O(n)。

public class Solution {
    public int nthUglyNumber(int n) {
        if (n < 1) {
            return 0;
        }
        //动态规划
        List<Integer> result = new ArrayList<>();
        result.add(1);
        int p2 = 0;
        int p3 = 0;
        int p5 = 0;
        while (result.size() < n) {
            int ugly2 = result.get(p2) * 2;
            int ugly3 = result.get(p3) * 3;
            int ugly5 = result.get(p5) * 5;
            int min = Math.min(ugly2, Math.min(ugly3, ugly5));
            result.add(min);
            if (min == ugly2) {
                p2++;
            }
            if (min == ugly3) {
                p3++;
            }
            if (min == ugly5) {
                p5++;
            }
        }
        return result.get(n - 1);
    }
}

313. Super Ugly Number

Write a program to find the nth super ugly number.

Super ugly numbers are positive numbers whose all prime factors are in the given prime list primes of size k. For example, [1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32] is the sequence of the first 12 super ugly numbers given primes = [2, 7, 13, 19] of size 4.

Note:
(1) 1 is a super ugly number for any given primes.
(2) The given numbers in primes are in ascending order.
(3) 0 < k ≤ 100, 0 < n ≤ 106, 0 < primes[i] < 1000.
(4) The nth super ugly number is guaranteed to fit in a 32-bit signed integer.

思路：同Ugly Number II，但是用最小堆的方法会超时。只能用动态规划方法。注意该题实际上应该是primes数组中不能含有1这个因子，但是允许有重复因子。

public class Solution {
    public int nthSuperUglyNumber(int n, int[] primes) {
        if (n < 1 || primes == null || primes.length == 0) {
            return 0;
        }
        List<Integer> result = new ArrayList<>();
        result.add(1);
        int[] p = new int[primes.length];
        while (result.size() < n) {
            int min = Integer.MAX_VALUE;
            for (int i = 0; i < primes.length; i++) {
                min = Math.min(min, primes[i] * result.get(p[i]));
            }
            result.add(min);
            for (int i = 0; i < primes.length; i++) {
                if (min == primes[i] * result.get(p[i])) {
                    p[i]++;
                }
            }
        }
        return result.get(n - 1);
    }
}

373. Find K Pairs with Smallest Sums

You are given two integer arrays nums1 and nums2 sorted in ascending order and an integer k.

Define a pair (u,v) which consists of one element from the first array and one element from the second array.

Find the k pairs (u1,v1),(u2,v2) ...(uk,vk) with the smallest sums.

Example 1:
Given nums1 = [1,7,11], nums2 = [2,4,6],  k = 3

Return: [1,2],[1,4],[1,6]

The first 3 pairs are returned from the sequence:
[1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
Example 2:
Given nums1 = [1,1,2], nums2 = [1,2,3],  k = 2

Return: [1,1],[1,1]

The first 2 pairs are returned from the sequence:
[1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]
Example 3:
Given nums1 = [1,2], nums2 = [3],  k = 3 

Return: [1,3],[2,3]

All possible pairs are returned from the sequence:
[1,3],[2,3]

思路I：维护一个大根堆，容量为k。不需要对两个数组都遍历，只需要遍历两个数组的前k个元素。时间复杂度O(k^2)，空间复杂度O(k)。

public class Solution {
    public List<int[]> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        List<int[]> result = new ArrayList<>();
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return result;
        }
        if (k < 1) {
            return result;
        }
        Queue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
            public int compare(int[] a, int[] b) {
                return (b[0] + b[1]) - (a[0] + a[1]);
            }
        });
        for (int i = 0; i < nums1.length && i < k; i++) {
            for (int j = 0; j < nums2.length && j < k; j++) {
                if (queue.size() < k) {
                    queue.offer(new int[]{nums1[i], nums2[j]});
                } else {
                    int[] temp = queue.peek();
                    if (nums1[i] + nums2[j] < temp[0] + temp[1]) {
                        queue.poll();
                        queue.offer(new int[]{nums1[i], nums2[j]});
                    }
                }
            }
        }
        while (!queue.isEmpty()) {
            result.add(queue.poll());
        }
        return result;
    }
}

思路II：维护一个小根堆，先把第一个数组的所有可能与第二个数组中的第一个元素配对，然后每出一个最小值，就新加一对元素进来。时间复杂度O(klogk)，由于堆只需要保存nums1.length个数字对，因此空间复杂度为O(nums1.length)。

public class Solution {
    public List<int[]> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        List<int[]> result = new ArrayList<>();
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0 || k < 1) {
            return result;
        }
        Queue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                return (a[0] + a[1]) - (b[0] + b[1]);
            }
        });
        for (int i = 0; i < nums1.length; i++) {
            queue.offer(new int[]{nums1[i], nums2[0], 0});
        }
        while (k > 0 && !queue.isEmpty()) {
            int[] temp = queue.poll();
            result.add(new int[]{temp[0], temp[1]});
            if (temp[2] < nums2.length - 1) {
                queue.offer(new int[]{temp[0], nums2[temp[2] + 1], temp[2] + 1});
            }
            k--;
        }
        return result;
    }
}

385. Mini Parser

Given a nested list of integers represented as a string, implement a parser to deserialize it.

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

Note: You may assume that the string is well-formed:

String is non-empty.
String does not contain white spaces.
String contains only digits 0-9, [, - ,, ].
Example 1:

Given s = "324",

You should return a NestedInteger object which contains a single integer 324.
Example 2:

Given s = "[123,[456,[789]]]",

Return a NestedInteger object containing a nested list with 2 elements:

1. An integer containing value 123.
2. A nested list containing two elements:
    i.  An integer containing value 456.
    ii. A nested list with one element:
         a. An integer containing value 789.

思路：注意栈中元素类型和出入栈的时间节点。合并的次数为'['的个数减1，也就是说循环到字符串倒数第二位，处理完数字的时候索引i = j - 1而不是i！！！因为数字后面既可能是','也可能是']'。注意特殊情况"324"的处理（没有'['）。

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * public interface NestedInteger {
 *     // Constructor initializes an empty nested list.
 *     public NestedInteger();
 *
 *     // Constructor initializes a single integer.
 *     public NestedInteger(int value);
 *
 *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
 *     public boolean isInteger();
 *
 *     // @return the single integer that this NestedInteger holds, if it holds a single integer
 *     // Return null if this NestedInteger holds a nested list
 *     public Integer getInteger();
 *
 *     // Set this NestedInteger to hold a single integer.
 *     public void setInteger(int value);
 *
 *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 *     public void add(NestedInteger ni);
 *
 *     // @return the nested list that this NestedInteger holds, if it holds a nested list
 *     // Return null if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
public class Solution {
    public NestedInteger deserialize(String s) {
        if (s == null || s.length() == 0) {
            return null;
        }
        if (s.charAt(0) != '[') {
            return new NestedInteger(Integer.parseInt(s));
        }
        Stack<NestedInteger> stack = new Stack<>();
        for (int i = 0; i < s.length() - 1; i++) {
            char c = s.charAt(i);
            if (c == '[') {
                stack.push(new NestedInteger());
            } else if (c == ']') {
                NestedInteger ni = stack.pop();
                stack.peek().add(ni);
            } else if (Character.isDigit(c) || c == '-') {
                int j = i + 1;
                while (j < s.length() && Character.isDigit(s.charAt(j))) {
                    j++;
                }
                String str = s.substring(i, j);
                stack.peek().add(new NestedInteger(Integer.parseInt(str)));
                i = j - 1;
            }
        }
        return stack.peek();
    }
}

349. Intersection of Two Arrays

Given two arrays, write a function to compute their intersection.

Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].

Note:
Each element in the result must be unique.
The result can be in any order.

思路I：排序 + 双指针合并，一个指针指向nums1数组索引，一个指针指向nums2数组索引。

public class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        //sort + merge
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int i = 0;
        int j = 0;
        int[] temp = new int[nums1.length];
        int index = 0;
        while (i < nums1.length && j < nums2.length) {
            if (nums1[i] == nums2[j]) {
                if (index == 0 || temp[index - 1] != nums1[i]) {
                    temp[index++] = nums1[i];
                }
                i++;
                j++;
            } else if (nums1[i] < nums2[j]) {
                i++;
            } else {
                j++;
            }
        }
        int[] result = new int[index];
        for (int k = 0; k < index; k++) {
            result[k] = temp[k];
        }
        return result;
    }
}

思路II：Set + Set，一个set存nums1的元素，另一个set存nums2中在nums1里出现过的元素。

public class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // Set + Set
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }
        Set<Integer> set = new HashSet<>();
        Set<Integer> resultSet = new HashSet<>();
        for (int i = 0; i < nums1.length; i++) {
            set.add(nums1[i]);
        }
        for (int i = 0; i < nums2.length; i++) {
            if (set.contains(nums2[i]) && !resultSet.contains(nums2[i])) {
                resultSet.add(nums2[i]);
            }
        }
        int[] result = new int[resultSet.size()];
        int index = 0;
        for (int num : resultSet) {
            result[index++] = num;
        }
        return result;
    }
}

思路III：sort + Binary Search，先讲nums1数组排好序，然后依次便利nums2中的每个元素看是否在nums1中，只有在nums1中并且set中没有此元素才把该元素加入到set中。最后将set复制到新数组返回。

public class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // Set + Binary Search
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }
        Arrays.sort(nums1);
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < nums2.length; i++) {
            if (binarySearch(nums1, nums2[i]) && !set.contains(nums2[i])) {
                set.add(nums2[i]);
            }
        }
        int[] result = new int[set.size()];
        int index = 0;
        for (int num : set) {
            result[index++] = num;
        }
        return result;
    }
    public boolean binarySearch(int[] nums, int target) {
        int start = 0;
        int end = nums.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (nums[mid] == target) {
                return true;
            } else if (nums[mid] < target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (nums[start] == target) {
            return true;
        }
        if (nums[end] == target) {
            return true;
        }
        return false;
    }
}

4. Median of Two Sorted Arrays

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

Example 1:
nums1 = [1, 3]
nums2 = [2]

The median is 2.0
Example 2:
nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

思路：由于时间复杂度的要求，而且是排序数组，所以使用二分法。问题等价于找合并数组里的第k大的元素。每次从两个数组中取前k / 2个元素，设mid = k / 2,当nums1[mid - 1] < nums2[mid - 1]时，可以断定nums1的前mid个元素在合并数组中的前k个元素里，因此可以扔掉这k / 2个元素，再递归的求剩余两个数组中的第k - k / 2个元素。反之则扔掉nums2的前k / 2个元素。注意点：1. 递归终止条件有三点（1）nums1走到头（2）nums2走到头（3）k == 1。2. 取nums1[mid - 1]和nums2[mid - 1]时，如果发生索引越界，则将该值置为Integer.MAX_VALUE + 1，此时说明一定要扔掉另一个数组的前k / 2个元素。

public class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if (nums1 == null || nums1.length == 0) {
            if (nums2 == null || nums2.length == 0) {
                return 0;
            } else {
                int mid = nums2.length / 2;
                if (nums2.length % 2 == 0) {
                    return (nums2[mid - 1] + nums2[mid]) / 2.0;
                } else {
                    return nums2[mid];
                }
            }
        }
        if (nums2 == null || nums2.length == 0) {
            int mid = nums1.length / 2;
            if (nums1.length % 2 == 0) {
                return (nums1[mid - 1] + nums1[mid]) / 2.0;
            } else {
                return nums1[mid];
            }
        }
        int length = nums1.length + nums2.length;
        if (length % 2 == 0) {
            return (findKth(nums1, 0, nums2, 0, length / 2) + findKth(nums1, 0, nums2, 0, length / 2 + 1)) / 2.0;
        } else {
            return findKth(nums1, 0, nums2, 0, length / 2 + 1);
        }
    }
    public int findKth(int[] nums1, int nums1_start, int[] nums2, int nums2_start, int k) {
        if (nums1_start == nums1.length) {
            return nums2[nums2_start + k - 1];
        }
        if (nums2_start == nums2.length) {
            return nums1[nums1_start + k - 1];
        }
        if (k == 1) {
            return Math.min(nums1[nums1_start], nums2[nums2_start]);
        }
        long nums1_key = nums1_start + k / 2 - 1 < nums1.length ? nums1[nums1_start + k / 2 - 1] : (long) Integer.MAX_VALUE + 1;
        long nums2_key = nums2_start + k / 2 - 1 < nums2.length ? nums2[nums2_start + k / 2 - 1] : (long) Integer.MAX_VALUE + 1;
        if (nums1_key < nums2_key) {
            return findKth(nums1, nums1_start + k / 2, nums2, nums2_start, k - k / 2);
        } else {
            return findKth(nums1, nums1_start, nums2, nums2_start + k / 2, k - k / 2);
        }
    }
}

209. Minimum Size Subarray Sum

Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn't one, return 0 instead.

For example, given the array [2,3,1,2,4,3] and s = 7,
the subarray [4,3] has the minimal length under the problem constraint.

思路：两根指针，维持一个动态窗口。前面指针移动直到满足条件停止，然后后面指针向前移，前面指针接着进行下一次移动。

public class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int i = 0;
        int j = 0;
        int sum = 0;
        int min = Integer.MAX_VALUE;
        for (i = 0; i < nums.length; i++) {
            while (j < nums.length && sum < s) {
                sum += nums[j];
                j++;
            }
            if (sum >= s) {
                min = Math.min(min, j - i);
            }
            sum -= nums[i];
        }
        if (min == Integer.MAX_VALUE) {
            return 0;
        }
        return min;
    }
}

类似题 -- 

3. Longest Substring Without Repeating Characters

Given a string, find the length of the longest substring without repeating characters.

Examples:

Given "abcabcbb", the answer is "abc", which the length is 3.

Given "bbbbb", the answer is "b", with the length of 1.

Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

思路：两根指针，同时用Set存放不含重复元素的子串的字符。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        int i = 0;
        int j = 0;
        int max = Integer.MIN_VALUE;
        Set<Character> set = new HashSet<>();
        for (i = 0; i < s.length(); i++) {
            while (j < s.length() && !set.contains(s.charAt(j))) {
                set.add(s.charAt(j));
                j++;
            }
            max = Math.max(max, set.size());
            set.remove(s.charAt(i));
        }
        return max;
    }
}

类似题 --

76. Minimum Window Substring

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,
S = "ADOBECODEBANC"
T = "ABC"
Minimum window is "BANC".

Note:
If there is no such window in S that covers all characters in T, return the empty string "".

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

思路：两根指针，用长度为256的数组存放字符串中每个字符出现的次数，索引是字符的ASCII码。这样方面窗口滑动的时候进行是否包含字符串的比较和移除字符的操作。有个技巧：判断一个字符串是否包含有另一个字符串，可以将这两个字符串转换成为两个长度为256的数组，索引是字符的ASCII码（0 - 255），里面的值是字符出现的次数，然后对前面一个字符串依次遍历，只要碰到数组元素值小于另一个数组相对应的元素值返回false，遍历完也没有返回false就返回true。

public class Solution {
    public String minWindow(String s, String t) {
        if (s == null || s.length() == 0 || t == null || t.length() == 0) {
            return "";
        }
        int[] targetHash = initialize(t);
        int[] sourceHash = new int[256];
        int i = 0;
        int j = 0;
        int minLength = Integer.MAX_VALUE;
        String minString = "";
        for (i = 0; i < s.length(); i++) {
            while (j < s.length() && !valid(sourceHash, targetHash)) {
                sourceHash[s.charAt(j)]++;
                j++;
            }
            if (valid(sourceHash, targetHash)) {
                if (j - i < minLength) {
                    minLength = j - i;
                    minString = s.substring(i, j);
                }
            }
            sourceHash[s.charAt(i)]--;
        }
        return minString;
    }
    public int[] initialize(String t) {
        int[] targetHash = new int[256];
        for (int i = 0; i < t.length(); i++) {
            targetHash[t.charAt(i)]++;
        }
        return targetHash;
    }
    public boolean valid(int[] sourceHash, int[] targetHash) {
        for (int i = 0; i < sourceHash.length; i++) {
            if (sourceHash[i] < targetHash[i]) {
                return false;
            }
        }
        return true;
    }
}

类似题 -- Longest Substring with At Most K Distinct Characters

Given a string s, find the length of the longest substring T that contains at most k distinct characters.

Example
For example, Given s = "eceba", k = 3,

T is "eceb" which its length is 4.

思路：用Map存放每个字符出现的次数，不能用Set因为需要知道字符出现的次数以判断当前窗口中不同字符的个数。注意更新maxLength时对应的两种情况，（1）出while循环后map的size大于k，那么取j - i - 1;（2）出while循环后map的size小于等于k，说明此时走到头了，那么取j - i。

public class Solution {
    /**
     * @param s : A string
     * @return : The length of the longest substring
     *           that contains at most k distinct characters.
     */
    public int lengthOfLongestSubstringKDistinct(String s, int k) {
        // write your code here
        if (s == null || s.length() == 0 || k < 1) {
            return 0;
        }
        int i = 0;
        int j = 0;
        int maxLength = 0;
        Map<Character, Integer> map = new HashMap<>();
        for (i = 0; i < s.length(); i++) {
            while (j < s.length() && map.size() <= k) {
                char c = s.charAt(j);
                if (!map.containsKey(c)) {
                    map.put(c, 1);
                } else {
                    map.put(c, map.get(c) + 1);
                }
                j++;
            }
            if (map.size() > k) {
                maxLength = Math.max(maxLength, j - i - 1);
            } else {
                maxLength = Math.max(maxLength, j - i);
            }
            char temp = s.charAt(i);
            if (map.get(temp) > 1) {
                map.put(temp, map.get(temp) - 1);
            } else {
                map.remove(temp);
            }
        }
        return maxLength;
    }
}

378. Kth Smallest Element in a Sorted Matrix

Given a n x n matrix where each of the rows and columns are sorted in ascending order, find the kth smallest element in the matrix.

Note that it is the kth smallest element in the sorted order, not the kth distinct element.

Example:

matrix = [
   [ 1,  5,  9],
   [10, 11, 13],
   [12, 13, 15]
],
k = 8,

return 13.
Note: 
You may assume k is always valid, 1 ≤ k ≤ n2.

思路：维护一个最小堆，向右倾斜45度遍历元素入堆，遍历k - 1次出堆前k - 1小的元素，然后堆顶元素即为答案。

class Element {
    int x;
    int y;
    int val;
    public Element(int x, int y, int val) {
        this.x = x;
        this.y = y;
        this.val = val;
    }
}
public class Solution {
    public int kthSmallest(int[][] matrix, int k) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        int n = matrix.length;
        int m = matrix[0].length;
        if (k < 1 || k > n * m) {
            return 0;
        }
        PriorityQueue<Element> pq = new PriorityQueue<Element>(k, new Comparator<Element>() {
            public int compare(Element a, Element b) {
                return a.val - b.val;
            }
        });
        boolean[][] visited = new boolean[n][m];
        pq.offer(new Element(0, 0, matrix[0][0]));
        visited[0][0] = true;
        int[] deltaX = {1, 0};
        int[] deltaY = {0, 1};
        for (int i = 0; i < k - 1; i++) {
            Element element = pq.poll();
            for (int j = 0; j < 2; j++) {
                int next_x = element.x + deltaX[j];
                int next_y = element.y + deltaY[j];
                if (next_x < n && next_y < m && !visited[next_x][next_y]) {
                    pq.offer(new Element(next_x, next_y, matrix[next_x][next_y]));
                    visited[next_x][next_y] = true;
                }
            }
        }
        return pq.poll().val;
    }
}

Kth Largest in N Arrays

Find K-th largest element in N arrays.

You can swap elements in the array

Example
In n=2 arrays [[9,3,2,4,7],[1,2,3,4,8]], the 3rd largest element is 7.

In n=2 arrays [[9,3,2,4,8],[1,2,3,4,2]], the 1st largest element is 9, 2nd largest element is 8, 3rd largest element is 7 and etc.

思路：这道题细节地方很多，把二维数组每一行都从小到大排好序，然后把每一行的最后面一个元素入大根堆，接着依次出堆k - 1次，每次把取出的元素的前一个位置的元素[i, j - 1]入堆。最后返回堆顶元素即可。

class Node {
    int x;
    int y;
    int val;
    public Node(int x, int y, int val) {
        this.x = x;
        this.y = y;
        this.val = val;
    }
}
public class Solution {
    /**
     * @param arrays a list of array
     * @param k an integer
     * @return an integer, K-th largest element in N arrays
     */
    public int KthInArrays(int[][] arrays, int k) {
        // Write your code here
        if (arrays == null || arrays.length == 0) {
            return 0;
        }
        int n = arrays.length;
        if (k < 1) {
            return 0;
        }
        PriorityQueue<Node> pq = new PriorityQueue<>(k, new Comparator<Node>() {
            public int compare(Node a, Node b) {
                return b.val - a.val;
            }
        });
        int sum = 0;
        for (int i = 0; i < n; i++) {
            Arrays.sort(arrays[i]);
            int len = arrays[i].length;
            sum += len;
            if (len != 0) {
                pq.offer(new Node(i, len - 1, arrays[i][len - 1]));
            }
        }
        if (k > sum) {
            return 0;
        }
        for (int i = 0; i < k - 1; i++) {
            Node node = pq.poll();
            if (node.y - 1 >= 0) {
                pq.offer(new Node(node.x, node.y - 1,
                    arrays[node.x][node.y - 1]));
            }
        }
        return pq.poll().val;
    }
}

Kth Smallest Sum in Two Sorted Arrays

Given two integer arrays sorted in ascending order and an integer k. Define sum = a + b, where a is an element from the first array and b is an element from the second one. Find the kth smallest sum out of all possible sums.

Example
Given [1, 7, 11] and [2, 4, 6].

For k = 3, return 7.

For k = 4, return 9.

For k = 8, return 15.

思路：小根堆，每次只需要判断i+1,j和i,j+1这两个位置上（如果位置没超出限制的话）的元素是否需要加入堆，用一个visited数组避免相同元素重重复入堆的问题。

class Node {
    int index1;
    int index2;
    int sum;
    public Node(int index1, int index2, int sum) {
        this.index1 = index1;
        this.index2 = index2;
        this.sum = sum;
    }
}
public class Solution {
    /**
     * @param A an integer arrays sorted in ascending order
     * @param B an integer arrays sorted in ascending order
     * @param k an integer
     * @return an integer
     */
    public int kthSmallestSum(int[] A, int[] B, int k) {
        // Write your code here
        if (A == null || A.length == 0 || B == null || B.length == 0) {
            return 0;
        }
        Queue<Node> queue = new PriorityQueue<Node>(k, new Comparator<Node>() {
            public int compare(Node a, Node b) {
                return a.sum - b.sum;
            }
        });
        boolean[][] visited = new boolean[A.length][B.length];
        queue.offer(new Node(0, 0, A[0] + B[0]));
        visited[0][0] = true;
        for (int i = 0; i < k - 1; i++) {
            Node node = queue.poll();
            if (node.index1 + 1 < A.length
                && !visited[node.index1 + 1][node.index2]) {
                int sum = A[node.index1 + 1] + B[node.index2];
                queue.offer(new Node(node.index1 + 1, node.index2, sum));
                visited[node.index1 + 1][node.index2] = true;
            }
            if (node.index2 + 1 < B.length
                && !visited[node.index1][node.index2 + 1]) {
                int sum = A[node.index1] + B[node.index2 + 1];
                queue.offer(new Node(node.index1, node.index2 + 1, sum));
                visited[node.index1][node.index2 + 1] = true;
            }
        }
        return queue.peek().sum;
    }
}

128. Longest Consecutive Sequence

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

For example,
Given [100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.

Your algorithm should run in O(n) complexity.

思路：用一个set装入数组中不重复的元素，然后对数组中的每一个元素，在set找以该元素为中间节点，连续递减的元素个数和连续递增的元素个数，每找到一个就把该元素从set里面删除，以免后来重复遍历。最后取连续个数的最小值。

public class Solution {
    public int longestConsecutive(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            set.add(nums[i]);
        }
        int longest = 0;
        for (int i = 0; i < nums.length; i++) {
            set.remove(nums[i]);
            
            int down = nums[i] - 1;
            while (set.contains(down)) {
                set.remove(down);
                down--;
            }
            
            int up = nums[i] + 1;
            while (set.contains(up)) {
                set.remove(up);
                up++;
            }
            
            longest = Math.max(longest, up - down - 1);
        }
        return longest;
    }
}

421. Maximum XOR of Two Numbers in an Array

Given a non-empty array of numbers, a0, a1, a2, … , an-1, where 0 ≤ ai < 231.

Find the maximum result of ai XOR aj, where 0 ≤ i, j < n.

Could you do this in O(n) runtime?

Example:

Input: [3, 10, 5, 25, 2, 8]

Output: 28

Explanation: The maximum result is 5 ^ 25 = 28.

思路I：Bit Manipulation + HashSet

　　每次从高位开始，到某一位为止，所能获得的最大的数。设置变量mask用来表示能形成的值，每一次将mask和其他的num相与得到的值加入set，表示在当前这一位上，数组里有这么多prefix。

　　假定在某一位上的任意两数xor能得到的最大值是dummyMax,那么他一定满足a(xor)b = dummyMax,其中set.contains(a) && set.contains(b). 利用XOR的性质，a ^ b = c, 则有a ^ c = b，且b ^ c = a，我们只需要判断b(xor)tmp的结果是不是在当前这一位下的set内，就可以知道这个dummyMax能不能由这个set中的任意两个数组成。

public class Solution {
    public int findMaximumXOR(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return 0;
        }
        int mask = 0;
        int max = 0;
        for (int i = 31; i >= 0; i--) {
            mask = mask | (1 << i);
            Set<Integer> set = new HashSet<>();
            for (int num : nums) {
                set.add(mask & num);
            }
            // 假设当前异或结果所能达到的最大值为dummyMax
            int dummyMax = max | (1 << i);
            for (int prefix : set) {
                // 利用了XOR的性质，a ^ b = c, 则有a ^ c = b，且b ^ c = a
                if (set.contains(dummyMax ^ prefix)) {
                    max = dummyMax;
                    break;
                }
            }
        }
        return max;
    }
}

 思路II：Trie， 但是对于这道题有一个大样例过不了，不科学！

　　建立字典树，将数组中的每个数的二进制表示的每一位都存储到字典树中。然后对数组中的每个数，采用类似贪心的策略，从最高位开始，在字典树中找和它在这一位相反的数。如果有，那么和这个数异或就得到最大异或值，如果没有就依次往下一位找，直到找到相异的位。每遍历完一个数，就得到一个异或值，最后遍历完数组中所有的数就可以得到最大的异或值。

class TrieNode {
    Map<Integer, TrieNode> children;
    public TrieNode() {
        children = new HashMap<>();
    }
}
class Trie {
    TrieNode root;
    public Trie() {
        root = new TrieNode();
    }
    public void insert(int num) {
        TrieNode cur = root;
        for (int i = 31; i >= 0; i--) {
            int bit = (num >> i) & 1;
            if (!cur.children.containsKey(bit)) {
                cur.children.put(bit, new TrieNode());
            }
            cur = cur.children.get(bit);
        }
    }
} 
public class Solution {
    public int findMaximumXOR(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return 0;
        }
        Trie trie = new Trie();
        for (int num : nums) {
            trie.insert(num);
        }
        int max = 0;
        for (int num : nums) {
            int xor = 0;
            TrieNode cur = trie.root;
            for (int i = 31; i >= 0; i--) {
                int bit = (num >> i) & 1;
                if (cur.children.containsKey(1 - bit)) {
                    cur = cur.children.get(1 - bit);
                    xor += 1 << i;
                } else {
                    cur = cur.children.get(bit);
                }
                if (xor + (1 << i) - 1 <= max) {
                    break;
                }
            }
            max = Math.max(max, xor);
        }
        return max;
    }
}

5. Longest Palindromic Substring

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example:

Input: "babad"

Output: "bab"

Note: "aba" is also a valid answer.
Example:

Input: "cbbd"

Output: "bb"

思路：动态规划。dp[i][j]表示i ～ j子串是否是回文串。如果s.charAt(i) != s.charAt(j),dp[i][j] = false;如果s.charAt(i) == s.charAt(j)，dp[i][j] = dp[i + 1][j - 1]。

public class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() == 0) {
            return "";
        }
        if (s.length() == 1) {
            return s;
        }
        int maxLength = 1;
        int left = 0;
        int right = 0;
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
            if (i + 1 < n) {
                dp[i][i + 1] = s.charAt(i) == s.charAt(i + 1);
                if (dp[i][i + 1] && maxLength < 2) {
                    maxLength = 2;
                    left = i;
                    right = i + 1;
                }
            }
        }
        for (int len = n - 2; len >= 1; len--) {
            for (int i = 0, j = n - len; i < len; i++, j++) {
                if (s.charAt(i) != s.charAt(j)) {
                    dp[i][j] = false;
                } else {
                    dp[i][j] = dp[i + 1][j - 1];
                    if (dp[i][j] && j - i + 1 > maxLength) {
                        maxLength = j - i + 1;
                        left = i;
                        right = j;
                    }
                }
            }
        }
        return s.substring(left, right + 1);
    }
}

87. Scramble String

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

    great
   /    
  gr    eat
 /     /  
g   r  e   at
           / 
          a   t
To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

    rgeat
   /    
  rg    eat
 /     /  
r   g  e   at
           / 
          a   t
We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

    rgtae
   /    
  rg    tae
 /     /  
r   g  ta  e
       / 
      t   a
We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

思路I：DFS 简单的说，就是s1和s2是scramble的话，那么必然存在一个在s1上的长度l1，将s1分成s11和s12两段，同样有s21和s22.那么要么s11和s21是scramble的并且s12和s22是scramble的；要么s11和s22是scramble的并且s12和s21是scramble的

public class Solution {
    /**
     * @param s1 A string
     * @param s2 Another string
     * @return whether s2 is a scrambled string of s1
     */
    public boolean isScramble(String s1, String s2) {
        // Write your code here
        if (s1 == null && s2 == null) {
            return true;
        }
        if (s1 == null && s2 != null || s1 != null && s2 == null) {
            return false;
        }
        if (s1.length() != s2.length()) {
            return false;
        }
        if (s1.equals(s2)) {
            return true;
        }
        char[] str1 = s1.toCharArray();
        char[] str2 = s2.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        for (int i = 0; i < s1.length(); i++) {
            if (str1[i] != str2[i]) {
                return false;
            }
        }
        for (int i = 1; i < s1.length(); i++) {
            String s11 = s1.substring(0, i);
            String s12 = s1.substring(i, s1.length());
            String s21 = s2.substring(0, i);
            String s22 = s2.substring(i, s1.length());
            if (isScramble(s11, s21) && isScramble(s12, s22)) {
                return true;
            }
            s21 = s2.substring(s1.length() - i);
            s22 = s2.substring(0, s1.length() - i);
            if (isScramble(s11, s21) && isScramble(s12, s22)) {
                return true;
            }
        }
        return false;
    }
}

 思路II：DP 跟字符串有关的题十有八九可以用DP来做，那么难点就在于如何找出递推公式。这其实是一道三维动态规划的题目，我们提出维护量res[i][j][n]，其中i是s1的起始字符，j是s2的起始字符，而n是当前的字符串长度，res[i][j][len]表示的是以i和j分别为s1和s2起点的长度为len的字符串是不是互为scramble。
有了维护量我们接下来看看递推式，也就是怎么根据历史信息来得到res[i][j][len]。判断这个是不是满足，其实我们首先是把当前s1[i...i+len-1]字符串劈一刀分成两部分，然后分两种情况：第一种是左边和s2[j...j+len-1]左边部分是不是scramble，以及右边和s2[j...j+len-1]右边部分是不是scramble；第二种情况是左边和s2[j...j+len-1]右边部分是不是scramble，以及右边和s2[j...j+len-1]左边部分是不是scramble。如果以上两种情况有一种成立，说明s1[i...i+len-1]和s2[j...j+len-1]是scramble的。而对于判断这些左右部分是不是scramble我们是有历史信息的，因为长度小于n的所有情况我们都在前面求解过了（也就是长度是最外层循环）。
上面说的是劈一刀的情况，对于s1[i...i+len-1]我们有len-1种劈法，在这些劈法中只要有一种成立，那么两个串就是scramble的。
总结起来递推式是res[i][j][len] = || (res[i][j][k]&&res[i+k][j+k][len-k] || res[i][j+len-k][k]&&res[i+k][j][len-k]) 对于所有1<=k<len，也就是对于所有len-1种劈法的结果求或运算。因为信息都是计算过的，对于每种劈法只需要常量操作即可完成，因此求解递推式是需要O(len)（因为len-1种劈法）。
如此总时间复杂度因为是三维动态规划，需要三层循环，加上每一步需要线行时间求解递推式，所以是O(n^4)。虽然已经比较高了，但是至少不是指数量级的，动态规划还是有很大优势的，空间复杂度是O(n^3)。

public class Solution {
    /**
     * @param s1 A string
     * @param s2 Another string
     * @return whether s2 is a scrambled string of s1
     */
    public boolean isScramble(String s1, String s2) {
        // Write your code here
        if (s1 == null && s2 == null) {
            return true;
        }
        if (s1 == null && s2 != null || s1 != null && s2 == null) {
            return false;
        }
        if (s1.length() != s2.length()) {
            return false;
        }
        int n = s1.length();
        boolean[][][] dp = new boolean[n][n][n + 1];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                dp[i][j][1] = s1.charAt(i) == s2.charAt(j);
            }
        }
        for (int len = 2; len <= n; len++) {
            for (int i = 0; i <= n - len; i++) {
                for (int j = 0; j <= n - len; j++) {
                    for (int k = 1; k <= len - 1; k++) {
                        if (dp[i][j][k] && dp[i + k][j + k][len - k]
                            || dp[i][j + len - k][k] && dp[i + k][j][len - k]) {
                            dp[i][j][len] = true;
                        }
                    }
                }
            }
        }
        return dp[0][0][n];
    }
}

lintcode类似题

Longest Common Subsequence

Given two strings, find the longest common subsequence (LCS).

Your code should return the length of LCS.

Have you met this question in a real interview? Yes
Clarification
What's the definition of Longest Common Subsequence?

https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
http://baike.baidu.com/view/2020307.htm
Example
For "ABCD" and "EDCA", the LCS is "A" (or "D", "C"), return 1.

For "ABCD" and "EACB", the LCS is "AC", return 2.

思路：DP dp[i][j]表示A串的前i个字符与B串的前j个字符的LCS个数。如果A.charAt(i - 1) == B.charAt(j - 1), dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1] + 1)；如果A.charAt(i - 1) != B.charAt(j - 1)，dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])。返回dp[n][m]。

public class Solution {
    /**
     * @param A, B: Two strings.
     * @return: The length of longest common subsequence of A and B.
     */
    public int longestCommonSubsequence(String A, String B) {
        // write your code here
        if (A == null || B == null) {
            return 0;
        }
        int n = A.length();
        int m = B.length();
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (A.charAt(i - 1) == B.charAt(j - 1)) {
                    dp[i][j] = Math.max(Math.max(dp[i - 1][j],
                        dp[i][j - 1]), dp[i - 1][j - 1] + 1);
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[n][m];
    }
}

Longest Common Substring

Given two strings, find the longest common substring.

Return the length of it.

 Notice

The characters in substring should occur continuously in original string. This is different with subsequence.

Have you met this question in a real interview? Yes
Example
Given A = "ABCD", B = "CBCE", return 2.

思路：dp[i][j]表示以A串中第i个字符串结尾和以B串中第j个字符串结尾的LCS个数。如果A.charAt(i - 1) == B.charAt(j - 1)，dp[i][j] = dp[i - 1][j - 1] + 1；如果A.charAt(i - 1) ！= B.charAt(j - 1)，dp[i][j] = 1。返回dp[i][j]的最大值。

public class Solution {
    /**
     * @param A, B: Two string.
     * @return: the length of the longest common substring.
     */
    public int longestCommonSubstring(String A, String B) {
        // write your code here
        if (A == null || B == null) {
            return 0;
        }
        int n = A.length();
        int m = B.length();
        int[][] dp = new int[n + 1][m + 1];
        int max = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (A.charAt(i - 1) == B.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = 0;
                }
                max = Math.max(max, dp[i][j]);
            }
        }
        return max;
    }
}

475. Heaters

Winter is coming! Your first job during the contest is to design a standard heater with fixed warm radius to warm all the houses.

Now, you are given positions of houses and heaters on a horizontal line, find out minimum radius of heaters so that all houses could be covered by those heaters.

So, your input will be the positions of houses and heaters seperately, and your expected output will be the minimum radius standard of heaters.

Note:
Numbers of houses and heaters you are given are non-negative and will not exceed 25000.
Positions of houses and heaters you are given are non-negative and will not exceed 10^9.
As long as a house is in the heaters' warm radius range, it can be warmed.
All the heaters follow your radius standard and the warm radius will the same.
Example 1:
Input: [1,2,3],[2]
Output: 1
Explanation: The only heater was placed in the position 2, and if we use the radius 1 standard, then all the houses can be warmed.
Example 2:
Input: [1,2,3,4],[1,4]
Output: 1
Explanation: The two heater was placed in the position 1 and 4. We need to use radius 1 standard, then all the houses can be warmed.

思路：二分，对于每个房子的位置，在排好序的heaters中找到该房子的位置或者应该插入的位置（二分来做），然后求该位置与其左右最相邻的两个房子的距离的最小值（注意边界情况的处理，比如左边没有房子或者右边没有房子，相应的距离就置为Integer.MAX_VALUE），遍历每个房子的位置，找出这些每次得到的最小值中的最大值即为所求。

public class Solution {
    public int findRadius(int[] houses, int[] heaters) {
        if (houses == null || houses.length == 0 || heaters == null || heaters.length == 0) {
            return -1;
        }
        Arrays.sort(heaters);
        int result = 0;
        for (int house : houses) {
            int index = binarySearch(heaters, house);
            //System.out.println(index);
            int dist1 = index - 1 >= 0 ? house - heaters[index - 1] : Integer.MAX_VALUE;
            int dist2 = index < heaters.length ? heaters[index] - house : Integer.MAX_VALUE;
            result = Math.max(result, Math.min(dist1, dist2));
        }
        return result;
    }
    public int binarySearch(int[] heaters, int target) {
        int start = 0;
        int end = heaters.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (heaters[mid] <= target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (heaters[start] > target) {
            return start;
        }
        if (heaters[start] == target) {
            return start;
        }
        if (heaters[end] >= target) {
            return end;
        }
        return end + 1;
    }
}

287. Find the Duplicate Number

Given an array nums containing n + 1 integers where each integer is between 1 and n (inclusive), prove that at least one duplicate number must exist. Assume that there is only one duplicate number, find the duplicate one.

Note:
You must not modify the array (assume the array is read only).
You must use only constant, O(1) extra space.
Your runtime complexity should be less than O(n2).
There is only one duplicate number in the array, but it could be repeated more than once.

思路：二分答案，重复的数范围在1 ～ n之间。对于每一个二分的数，计算数组中小于等于这个二分数的个数，如果小于等于这个二分数，说明重复数字在右半区域；否则在左半区域。

public class Solution {
    public int findDuplicate(int[] nums) {
        if (nums == null || nums.length < 2) {
            return 0;
        }
        int start = 1;
        int end = nums.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (count(nums, mid) <= mid) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (count(nums, start) > start) {
            return start;
        }
        return end;
    }
    public int count(int[] nums, int value) {
        int result = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] <= value) {
                result++;
            }
        }
        return result;
    }
}

85. Maximal Rectangle

Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.

For example, given the following matrix:

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0
Return 6.

思路：单调栈  二维数组从上到下累计直方图的高度，每一行看作是直方图的宽度。然后转化为求每一行的直方图能构成的最大面积即转化成Largest Rectangle in Histogram问题。

public class Solution {
    public int maximalRectangle(char[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        int n = matrix.length;
        int m = matrix[0].length;
        int[][] height = new int[n][m];
        for (int i = 0; i < m; i++) {
            if (matrix[0][i] == '0') {
                height[0][i] = 0;
            } else {
                height[0][i] = 1;
            }
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (matrix[i][j] == '0') {
                    height[i][j] = 0;
                } else {
                    height[i][j] = height[i - 1][j] + 1;
                }
            }
        }
        int result = 0;
        for (int i = 0; i < n; i++) {
            Stack<Integer> stack = new Stack<>();
            for (int j = 0; j <= m; j++) {
                int cur = j == m ? 0 : height[i][j];
                while (!stack.isEmpty() && cur <= height[i][stack.peek()]) {
                    int h = height[i][stack.pop()];
                    int w = stack.isEmpty() ? j : j - stack.peek() - 1;
                    result = Math.max(result, h * w);
                }
                stack.push(j);
            }
        }
        return result;
    }
}

72. Edit Distance

Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

a) Insert a character
b) Delete a character
c) Replace a character

思路：1.状态　　dp[i][j]表示A的前i个字符最少要用几次编辑可以变成B的前j个字符

　　　2.方程　　A[i - 1] == B[j - 1]，dp[i][i] = dp[i - 1][j - 1]；A[i - 1] != B[j - 1]，dp[i][j] = 1 + Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), 　　　　　　　　dp[i - 1][j - 1])。

　　　3.初始化　dp[i][0] = i　　dp[0][j] = j

　　　4.答案　　dp[n][m]

　　　5. 可以用滚动数组优化空间复杂度

public class Solution {
    public int minDistance(String word1, String word2) {
        if (word1 == null || word2 == null) {
            return 0;
        }
        int n = word1.length();
        int m = word2.length();
        int[][] dp = new int[2][m + 1];
        for (int j = 0; j <= m; j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                if (j == 0) {
                    dp[i % 2][j] = i;
                    continue;
                }
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i % 2][j] = dp[(i - 1) % 2][j - 1];
                } else {
                    dp[i % 2][j] = Math.min(dp[(i - 1) % 2][j - 1], Math.min(dp[(i - 1) % 2][j], dp[i % 2][j - 1])) + 1;
                }
            }
        }
        return dp[n % 2][m];
    }
}

566. Reshape the Matrix

In MATLAB, there is a very useful function called 'reshape', which can reshape a matrix into a new one with different size but keep its original data.

You're given a matrix represented by a two-dimensional array, and two positive integers r and c representing the row number and column number of the wanted reshaped matrix, respectively.

The reshaped matrix need to be filled with all the elements of the original matrix in the same row-traversing order as they were.

If the 'reshape' operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.

Example 1:
Input: 
nums = 
[[1,2],
 [3,4]]
r = 1, c = 4
Output: 
[[1,2,3,4]]
Explanation:
The row-traversing of nums is [1,2,3,4]. The new reshaped matrix is a 1 * 4 matrix, fill it row by row by using the previous list.
Example 2:
Input: 
nums = 
[[1,2],
 [3,4]]
r = 2, c = 4
Output: 
[[1,2],
 [3,4]]
Explanation:
There is no way to reshape a 2 * 2 matrix to a 2 * 4 matrix. So output the original matrix.
Note:
The height and width of the given matrix is in range [1, 100].
The given r and c are all positive.

思路：简单题，依次复制就好，复制到最大列的时候把行数加1，列数置0即可。

public class Solution {
    public int[][] matrixReshape(int[][] nums, int r, int c) {
        if (nums == null || nums.length == 0 || nums[0].length == 0) {
            return new int[0][0];
        }
        int n = nums.length;
        int m = nums[0].length;
        if (r <= 0 || c <= 0 || n * m != r * c) {
            return nums;
        }
        int[][] result = new int[r][c];
        int row = 0;
        int column = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                result[row][column++] = nums[i][j];
                if (column == c) {
                    row++;
                    column = 0;
                }
            }
        }
        return result;
    }
}

561. Array Partition I

Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as possible.

Example 1:
Input: [1,4,3,2]

Output: 4
Explanation: n is 2, and the maximum sum of pairs is 4.
Note:
n is a positive integer, which is in the range of [1, 10000].
All the integers in the array will be in the range of [-10000, 10000].

思路：转化为数组先排序，然后取第1个数、第3个数、第5个数......的和。

public class Solution {
    public int arrayPairSum(int[] nums) {
        if (nums == null || nums.length == 0 || nums.length % 2 == 1) {
            return 0;
        }
        int result = 0;
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i = i + 2) {
            result += nums[i];
        }
        return result;
    }
}

485. Max Consecutive Ones

Given a binary array, find the maximum number of consecutive 1s in this array.

Example 1:
Input: [1,1,0,1,1,1]
Output: 3
Explanation: The first two digits or the last three digits are consecutive 1s.
    The maximum number of consecutive 1s is 3.
Note:

The input array will only contain 0 and 1.
The length of input array is a positive integer and will not exceed 10,000

思路：遍历一遍，统计。简单

public class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int result = 0;
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == 0) {
                count = 0;
                continue;
            } else {
                while (i < nums.length && nums[i] == 1) {
                    count++;
                    i++;
                }
                result = Math.max(result, count);
                count = 0;
            }
            
        }
        return result;
    }
}

560. Subarray Sum Equals K

Given an array of integers and an integer k, you need to find the total number of continuous subarrays whose sum equals to k.

Example 1:
Input:nums = [1,1,1], k = 2
Output: 2
Note:
The length of the array is in range [1, 20,000].
The range of numbers in the array is [-1000, 1000] and the range of the integer k is [-1e7, 1e7].

思路I：暴力法，前缀数组和与处理，然后计算所有子数组的和，统计子数组和等于k的个数，时间复杂度O(n^2)。

public class Solution {
    public int subarraySum(int[] nums, int k) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int n = nums.length;
        int[] sum = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            sum[i] = sum[i - 1] + nums[i - 1];
        }
        int count = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < i; j++) {
                if (sum[i] - sum[j] == k) {
                    count++;
                }
            }
        }
        return count;
    }
}

思路II：用HashMap来存储：子数组的和 --> 等于该和的子数组的个数。时间复杂度O(n)。

public class Solution {
    public int subarraySum(int[] nums, int k) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        HashMap<Integer, Integer> map = new HashMap<>();
        map.put(0, 1);
        int count = 0;
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            if (map.containsKey(sum - k)) {
                count += map.get(sum - k);
            }
            if (!map.containsKey(sum)) {
                map.put(sum, 1);
            } else {
                map.put(sum, map.get(sum) + 1);
            }
        }
        return count;
    }
}

495. Teemo Attacking

In LLP world, there is a hero called Teemo and his attacking can make his enemy Ashe be in poisoned condition. Now, given the Teemo's attacking ascending time series towards Ashe and the poisoning time duration per Teemo's attacking, you need to output the total time that Ashe is in poisoned condition.

You may assume that Teemo attacks at the very beginning of a specific time point, and makes Ashe be in poisoned condition immediately.

Example 1:
Input: [1,4], 2
Output: 4
Explanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned immediately. 
This poisoned status will last 2 seconds until the end of time point 2. 
And at time point 4, Teemo attacks Ashe again, and causes Ashe to be in poisoned status for another 2 seconds. 
So you finally need to output 4.
Example 2:
Input: [1,2], 2
Output: 3
Explanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned. 
This poisoned status will last 2 seconds until the end of time point 2. 
However, at the beginning of time point 2, Teemo attacks Ashe again who is already in poisoned status. 
Since the poisoned status won't add up together, though the second poisoning attack will still work at time point 2, it will stop at the end of time point 3. 
So you finally need to output 3.
Note:
You may assume the length of given time series array won't exceed 10000.
You may assume the numbers in the Teemo's attacking time series and his poisoning time duration per attacking are non-negative integers, which won't exceed 10,000,000.

思路：判断当前的开始点与之前延伸到的最大点是否有重叠，无重叠直接加上持续时间，有重叠就只加上除去重叠之外的持续时间。

public class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        if (timeSeries == null || timeSeries.length == 0 || duration <= 0) {
            return 0;
        }
        int max = 0;
        int total = 0;
        for (int i = 0; i < timeSeries.length; i++) {
            if (timeSeries[i] + duration <= max) {
                continue;
            }
            if (timeSeries[i] >= max) {
                total += duration;
            } else {
                total += timeSeries[i] + duration - max;
            }
            max = timeSeries[i] + duration;
        }
        return total;
    }
}

380. Insert Delete GetRandom O(1)

Design a data structure that supports all following operations in average O(1) time.

insert(val): Inserts an item val to the set if not already present.
remove(val): Removes an item val from the set if present.
getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.
Example:

// Init an empty set.
RandomizedSet randomSet = new RandomizedSet();

// Inserts 1 to the set. Returns true as 1 was inserted successfully.
randomSet.insert(1);

// Returns false as 2 does not exist in the set.
randomSet.remove(2);

// Inserts 2 to the set, returns true. Set now contains [1,2].
randomSet.insert(2);

// getRandom should return either 1 or 2 randomly.
randomSet.getRandom();

// Removes 1 from the set, returns true. Set now contains [2].
randomSet.remove(1);

// 2 was already in the set, so return false.
randomSet.insert(2);

// Since 2 is the only number in the set, getRandom always return 2.

思路：List存数据，Map存数据的索引，以方便remove操作O(1)时间内找到要删除元素的索引。等可能的返回List中的任一元素用Random函数在size范围内(0 ~ size - 1)等可能的取索引即可。

public class RandomizedSet {
    List<Integer> list;
    Map<Integer, Integer> map;
    Random random;
    /** Initialize your data structure here. */
    public RandomizedSet() {
        list = new ArrayList<>();
        map = new HashMap<>();
        random = new Random();
    }
    
    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
    public boolean insert(int val) {
        if (map.containsKey(val)) {
            return false;
        }
        list.add(val);
        map.put(val, list.size() - 1);
        return true;
    }
    
    /** Removes a value from the set. Returns true if the set contained the specified element. */
    public boolean remove(int val) {
        if (!map.containsKey(val)) {
            return false;
        }
        int index = map.get(val);
        if (index < list.size() - 1) {
            list.set(index, list.get(list.size() - 1));
            // 这段代码可有可无，反正是要删去的，可以不用修改。
            //list.set(list.size() - 1, val);
            map.put(list.get(index), index);
            // 这段代码可有可无，反正是要删去的，可以不用修改。
            //map.put(list.get(list.size() - 1), list.size() - 1);
        }
        list.remove(list.size() - 1);
        map.remove(val);
        return true;
    }
    
    /** Get a random element from the set. */
    public int getRandom() {
        return list.get(random.nextInt(list.size()));
    }
}

/**
 * Your RandomizedSet object will be instantiated and called as such:
 * RandomizedSet obj = new RandomizedSet();
 * boolean param_1 = obj.insert(val);
 * boolean param_2 = obj.remove(val);
 * int param_3 = obj.getRandom();
 */

493. Reverse Pairs

Given an array nums, we call (i, j) an important reverse pair if i < j and nums[i] > 2*nums[j].

You need to return the number of important reverse pairs in the given array.

Example1:

Input: [1,3,2,3,1]
Output: 2
Example2:

Input: [2,4,3,5,1]
Output: 3
Note:
The length of the given array will not exceed 50,000.
All the numbers in the input array are in the range of 32-bit integer.

思路：这道题就是在merge sort的过程中，加入一个计数的过程。对于分割的两部分，都是排好序的，对两个部分分别计两个索引i和j，固定i，在第二部分里找出满足nums[i] > 2 * nums[j]的个数，然后循环i就可以得到两部分之间有多少pairs。那么总的pairs就是前一部分的pairs(下一次的mergeSort要统计的)+后一部分的pairs(下一次的mergeSort要统计的)+两个部分之间的pairs。

public class Solution {
    public int reversePairs(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return 0;
        }
        int[] temp = new int[nums.length];
        return mergeSort(nums, 0, nums.length - 1, temp);
    }
    // mergeSort模版程序
    public int mergeSort(int[] nums, int start, int end, int[] temp) {
        if (start >= end) {
            return 0;
        }
        int mid = start + (end - start) / 2;
        int count = mergeSort(nums, start, mid, temp) + mergeSort(nums, mid + 1, end, temp);
        // 注意这里j = mid + 1要写在for里面，因为前一个i满足nums[i] / 2.0 > nums[j]的话，
        // 由于两部分都是排好序的，下一个i一定也满足nums[i] / 2.0 > nums[j],所以j不用再回退到
        // mid + 1这个起始位置，直接从当前位置开始判断。否则会超时，一定要注意。
        for (int i = start, j = mid + 1; i <= mid; i++) {
            // 这里nums[i] / 2.0 > nums[j]而不是写成nums[i] > 2 * nums[j]是为了避免2 * nums[j]溢出
            while (j <= end && nums[i] / 2.0 > nums[j]) {
                j++;
            }
            count += j - (mid + 1);
        }
        merge(nums, start, end, temp);
        return count;
    }
    public void merge(int[] nums, int start, int end, int[] temp) {
        int mid = start + (end - start) / 2;
        int leftIndex = start;
        int rightIndex = mid + 1;
        int index = start;
        while (leftIndex <= mid && rightIndex <= end) {
            if (nums[leftIndex] < nums[rightIndex]) {
                temp[index++] = nums[leftIndex++];
            } else {
                temp[index++] = nums[rightIndex++];
            }
        }
        while (leftIndex <= mid) {
            temp[index++] = nums[leftIndex++];
        }
        while (rightIndex <= end) {
            temp[index++] = nums[rightIndex++];
        }
        for (int i = start; i <= end; i++) {
            nums[i] = temp[i];
        }
    }
}

315. Count of Smaller Numbers After Self

You are given an integer array nums and you have to return a new counts array. The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].

Example:

Given nums = [5, 2, 6, 1]

To the right of 5 there are 2 smaller elements (2 and 1).
To the right of 2 there is only 1 smaller element (1).
To the right of 6 there is 1 smaller element (1).
To the right of 1 there is 0 smaller element.
Return the array [2, 1, 1, 0].

思路：为了方便统计nums中的每个数在它后面有多少个数比它小，对nums的索引而不是nums的元素值来merge sort，每次对排好序的前后两部分进行merge的过程中，对于第一部分的索引i，统计在第二部分中有多少个数小于i对应的元素值，然后将统计的个数加进count[indexes[i]]中，indexes[i]为nums数组中元素的索引。

public class Solution {
    // 定义为类变量，不用每次将其作为函数参数传递下去。
    int[] count;
    public List<Integer> countSmaller(int[] nums) {
        List<Integer> result = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            return result;
        }
        count = new int[nums.length];
        int[] temp = new int[nums.length];
        int[] indexes = new int[nums.length];
        // 为了方便统计nums中的每个数在它后面有多少个数比它小，对nums的索引而不是nums的元素值来merge sort，所以注意索引的初始化！不能掉！
        for (int i = 0; i < indexes.length; i++) {
            indexes[i] = i;
        }
        mergeSort(nums, indexes, 0, nums.length - 1, temp);
        for (int i = 0; i < count.length; i++) {
            result.add(count[i]);
        }
        return result;
    }
    // 归并排序模版程序，背下来。
    public void mergeSort(int[] nums, int[] indexes, int start, int end, int[] temp) {
        if (start >= end) {
            return;
        }
        int mid = start + (end - start) / 2;
        mergeSort(nums, indexes, start, mid, temp);
        mergeSort(nums, indexes, mid + 1, end, temp);
        merge(nums, indexes, start, end, temp);
    }
    public void merge(int[] nums, int[] indexes, int start, int end, int[] temp) {
        int mid = start + (end - start) / 2;
        int leftIndex = start;
        int rightIndex = mid + 1;
        int sortIndex = start;
        // pairs用来统计一次merge的过程中，对于第一部分的索引i，在第二部分中有多少个数小于i对应的元素值。
        int pairs = 0;
        while (leftIndex <= mid && rightIndex <= end) {
            if (nums[indexes[leftIndex]] > nums[indexes[rightIndex]]) {
                temp[sortIndex++] = indexes[rightIndex++];
                pairs++;
            } else {
                count[indexes[leftIndex]] += pairs;
                temp[sortIndex++] = indexes[leftIndex++];
            }
        }
        while (leftIndex <= mid) {
            count[indexes[leftIndex]] += pairs;
            temp[sortIndex++] = indexes[leftIndex++];
        }
        while (rightIndex <= end) {
            temp[sortIndex++] = indexes[rightIndex++];
        }
        for (int i = start; i <= end; i++) {
            indexes[i] = temp[i];
        }
    }
}

327. Count of Range Sum

Given an integer array nums, return the number of range sums that lie in [lower, upper] inclusive.
Range sum S(i, j) is defined as the sum of the elements in nums between indices i and j (i ≤ j), inclusive.

Note:
A naive algorithm of O(n2) is trivial. You MUST do better than that.

Example:
Given nums = [-2, 5, -1], lower = -2, upper = 2,
Return 3.
The three ranges are : [0, 0], [2, 2], [0, 2] and their respective sums are: -2, -1, 2.

思路：首先对给定的数组进行前缀和预处理，然后对前缀和数组进行merge sort，每次merge之前，对于前半部分固定的索引i，在后半部分中分别找出第一个满足prefixSum[k] - prefixSum[i] >= lower的索引k和prefixSum[j] - prefixSum[i] > upper的索引j，则j - k就是两部分之间满足条件的子区间个数，由于左右区间都是递增的，i向右移动时j和k也随之右移而不需要回溯到起始位置，所以在O(n)的复杂度内可以找出两部分之间的满足条件的子区间个数。总的满足条件的子区间个数 = 前一部分满足条件的子区间个数(下一次的mergeSort要统计的) + 后一部分满足条件的子区间个数(下一次的mergeSort要统计的) + 两个部分之间满足条件的子区间个数(j - k)。

public class Solution {
    public int countRangeSum(int[] nums, int lower, int upper) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        // 为了避免前缀和溢出，定义为long型数组。
        long[] prefixSum = new long[nums.length + 1];
        // 前缀和预处理，可以当成一个模版记下来，prefixSum[i]表示nums数组中前i个元素的和。
        for (int i = 1; i <= nums.length; i++) {
            prefixSum[i] = prefixSum[i - 1] + nums[i - 1];
        }
        long[] temp = new long[nums.length + 1];
        return mergeSort(prefixSum, 0, nums.length, lower, upper, temp);
    }
    public int mergeSort(long[] prefixSum, int start, int end, int lower, int upper, long[] temp) {
        if (start >= end) {
            return 0;
        }
        int mid = start + (end - start) / 2;
        int count = mergeSort(prefixSum, start, mid, lower, upper, temp)
                    + mergeSort(prefixSum, mid + 1, end, lower, upper, temp);
        int j = mid + 1;
        int k = mid + 1;
        for (int i = start; i <= mid; i++) {
            while (k <= end && prefixSum[k] - prefixSum[i] < lower) {
                k++;
            }
            while (j <= end && prefixSum[j] - prefixSum[i] <= upper) {
                j++;
            }
            count += j - k;
        }           
        merge(prefixSum, start, end, temp);
        return count;
    }
    public void merge(long[] prefixSum, int start, int end, long[] temp) {
        int mid = start + (end - start) / 2;
        int leftIndex = start;
        int rightIndex = mid + 1;
        int index = start;
        while (leftIndex <= mid && rightIndex <= end) {
            if (prefixSum[leftIndex] < prefixSum[rightIndex]) {
                temp[index++] = prefixSum[leftIndex++];
            } else {
                temp[index++] = prefixSum[rightIndex++];
            }
        }
        while (leftIndex <= mid) {
            temp[index++] = prefixSum[leftIndex++];
        }
        while (rightIndex <= end) {
            temp[index++] = prefixSum[rightIndex++];
        }
        for (int i = start; i <= end; i++) {
            prefixSum[i] = temp[i];
        }
    }
}

494. Target Sum

You are given a list of non-negative integers, a1, a2, ..., an, and a target, S. Now you have 2 symbols + and -. For each integer, you should choose one from + and - as its new symbol.

Find out how many ways to assign symbols to make sum of integers equal to target S.

Example 1:
Input: nums is [1, 1, 1, 1, 1], S is 3. 
Output: 5
Explanation: 

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

There are 5 ways to assign symbols to make the sum of nums be target 3.
Note:
The length of the given array is positive and will not exceed 20.
The sum of elements in the given array will not exceed 1000.
Your output answer is guaranteed to be fitted in a 32-bit integer.

思路：DFS + memorization 对于所有可能的情况用递归来实现，为了避免重复递归，用一个Map存储中间结果。

public class Solution {
    public int findTargetSumWays(int[] nums, int S) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        Map<String, Integer> map = new HashMap<>();
        return dfsHelper(nums, 0, 0, S, map);
    }
    public int dfsHelper(int[] nums, int index, int sum, int S, Map<String, Integer> map) {
        String key = index + " " + sum;
        if (map.containsKey(key)) {
            return map.get(key);
        }
        if (index == nums.length) {
            if (sum == S) {
                return 1;
            } else {
                return 0;
            }
        }
        int add = dfsHelper(nums, index + 1, sum + nums[index], S, map);
        int minus = dfsHelper(nums, index + 1, sum - nums[index], S, map);
        map.put(key, add + minus);
        return add + minus;
    }
}

491. Increasing Subsequences

Given an integer array, your task is to find all the different possible increasing subsequences of the given array, and the length of an increasing subsequence should be at least 2 .

Example:
Input: [4, 6, 7, 7]
Output: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]
Note:
The length of the given array will not exceed 15.
The range of integer in the given array is [-100,100].
The given array may contain duplicates, and two equal integers should also be considered as a special case of increasing sequence.

思路：DFS遍历所有情况，用一个tempList存储每次递归中的递增序列，如果遇到递减序列，即当前元素小于tempList中的最后一个元素，就结束当前递归。每次递归只要tempList的大小大于等于2就加入到set中，选set而不是list是为了在O(1)时间内去重，而用list的contains方法不能在O(1)时间内去重。最后将set中的元素加入到结果中。

public class Solution {
    public List<List<Integer>> findSubsequences(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        Set<List<Integer>> set = new HashSet<>();
        if (nums == null || nums.length <= 1) {
            return results;
        }
        dfsHelper(set, nums, 0, new ArrayList<Integer>());
        return new ArrayList<List<Integer>>(set);
    }
    public void dfsHelper(Set<List<Integer>> set, int[] nums, int startIndex, List<Integer> tempList) {
        if (tempList.size() >= 2) {
            set.add(new ArrayList<Integer>(tempList));
        }
        for (int i = startIndex; i < nums.length; i++) {
            if (tempList.size() == 0 || tempList.get(tempList.size() - 1) <= nums[i]) {
                tempList.add(nums[i]);
                dfsHelper(set, nums, i + 1, tempList);
                tempList.remove(tempList.size() - 1);
            }
        }
    }
}

417. Pacific Atlantic Water Flow

Given an m x n matrix of non-negative integers representing the height of each unit cell in a continent, the "Pacific ocean" touches the left and top edges of the matrix and the "Atlantic ocean" touches the right and bottom edges.

Water can only flow in four directions (up, down, left, or right) from a cell to another one with height equal or lower.

Find the list of grid coordinates where water can flow to both the Pacific and Atlantic ocean.

Note:
The order of returned grid coordinates does not matter.
Both m and n are less than 150.
Example:

Given the following 5x5 matrix:

  Pacific ~   ~   ~   ~   ~ 
       ~  1   2   2   3  (5) *
       ~  3   2   3  (4) (4) *
       ~  2   4  (5)  3   1  *
       ~ (6) (7)  1   4   5  *
       ~ (5)  1   1   2   4  *
          *   *   *   *   * Atlantic

Return:

[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).

思路：为了让水能够流进海洋里，从海洋边界出发，逆向找高度大于等于当前所在节点的高度，这是一个bfs的过程，这个过程中所访问到的节点就是能够到达海洋的节点。然后取所有那些水流能同时到达两个海洋的节点加入到结果中即可。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    int n;
    int m;
    public List<int[]> pacificAtlantic(int[][] matrix) {
        List<int[]> result = new ArrayList<>();
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }
        n = matrix.length;
        m = matrix[0].length;
        boolean[][] pacific = new boolean[n][m];
        boolean[][] atlantic = new boolean[n][m];
        for (int i = 0; i < n; i++) {
            if (!pacific[i][0]) {
                bfs(matrix, i, 0, pacific);
            }
        }
        for (int j = 1; j < m; j++) {
            if (!pacific[0][j]) {
                bfs(matrix, 0, j, pacific);
            }
        }
        for (int i = 0; i < n; i++) {
            if (!atlantic[i][m - 1]) {
                bfs(matrix, i, m - 1, atlantic);
            }
        }
        for (int j = 0; j < m - 1; j++) {
            if (!atlantic[n - 1][j]) {
                bfs(matrix, n - 1, j, atlantic);
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (pacific[i][j] && atlantic[i][j]) {
                    result.add(new int[]{i, j});
                }
            }
        }
        return result;
    }
    public void bfs(int[][] matrix, int x, int y, boolean[][] visited) {
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        Node node = new Node(x, y);
        Queue<Node> queue = new LinkedList<>();
        queue.offer(node);
        visited[node.x][node.y] = true;
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            for (int j = 0; j < 4; j++) {
                int nextX = cur.x + dx[j];
                int nextY = cur.y + dy[j];
                if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < m
                    && !visited[nextX][nextY] && matrix[nextX][nextY] >= matrix[cur.x][cur.y]) {
                    Node next = new Node(nextX, nextY);
                    queue.offer(next);
                    visited[next.x][next.y] = true;
                }
            }
        }
     }
}

542. 01 Matrix

Given a matrix consists of 0 and 1, find the distance of the nearest 0 for each cell.

The distance between two adjacent cells is 1.
Example 1: 
Input:

0 0 0
0 1 0
0 0 0
Output:
0 0 0
0 1 0
0 0 0
Example 2: 
Input:

0 0 0
0 1 0
1 1 1
Output:
0 0 0
0 1 0
1 2 1
Note:
The number of elements of the given matrix will not exceed 10,000.
There are at least one 0 in the given matrix.
The cells are adjacent in only four directions: up, down, left and right.

思路：这道题一开始的想法是对矩阵中的每一个1进行分层BFS找到离这个1距离最近的0，这样的话会出现重复BFS的问题，容易超时。可以从0开始出发，对于01二维数组，起始的时候做预处理：对于矩阵中的1置为Integer.MAX_VALUE，对于矩阵中的0就将当前位置节点加入到队列中。BFS过程中，新计算出的距离(1 + matrix[i][j])小于当前距离的话才更新节点距离，并且入列，否则跳过。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    public int[][] updateMatrix(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return new int[0][0];
        }
        int n = matrix.length;
        int m = matrix[0].length;
        Queue<Node> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (matrix[i][j] == 1) {
                    matrix[i][j] = Integer.MAX_VALUE;
                } else {
                    queue.offer(new Node(i, j));
                }
            }
        }
        int[] dx ={1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            for (int j = 0; j < 4; j++) {
                int nextX = cur.x + dx[j];
                int nextY = cur.y + dy[j];
                if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < m && 1 + matrix[cur.x][cur.y] < matrix[nextX][nextY]) {
                    matrix[nextX][nextY] = 1 + matrix[cur.x][cur.y];
                    Node next = new Node(nextX, nextY);
                    queue.offer(next);
                }
            }
        }
        return matrix;
    }
}

sort系列： 

56. Merge Intervals

Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

Subscribe to see which companies asked this question.

思路：先对list中的intervlas按照interval的start大小进行排序，注意没有必要再接着对interval的end排序，end是用来更新的。然后对于每一个interval，如果当前interval的start小于前一个interval的end，说明当前interval与前一个interval有重叠，那么更新前一个interval的end；否则说明没有重叠，直接将当前interval加入到结果集中。

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        List<Interval> result = new ArrayList<>();
        if (intervals == null || intervals.size() == 0) {
            return result;
        }
        Collections.sort(intervals, new Comparator<Interval>(){
            public int compare(Interval a, Interval b) {
                return a.start - b.start;
            }
        });
        for (Interval interval : intervals) {
            if (result.size() == 0 || interval.start > result.get(result.size() - 1).end) {
                result.add(interval);
            } else {
                Interval preInterval = result.get(result.size() - 1);
                //多余的代码
                //preInterval.start = Math.min(preInterval.start, interval.start);
                preInterval.end = Math.max(preInterval.end, interval.end);
            }
        }
        return result;
    }
}

179. Largest Number

Given a list of non negative integers, arrange them such that they form the largest number.

For example, given [3, 30, 34, 5, 9], the largest formed number is 9534330.

Note: The result may be very large, so you need to return a string instead of an integer.

思路：自定义比较函数来排序，对于两个字符串a和b，s1=a+b，s2=b+a，拼接串的比较可以直接使用库函数s2.compareTo(s1)来处理，要善于利用库函数，不要重复造轮子！同时注意边界情况：数组全为0，如[0, 0, 0, 0]，此时不应该返回"0000"，而应该返回"0"。

public class Solution {
    public String largestNumber(int[] nums) {
        if (nums == null || nums.length == 0) {
            return "";
        }
        String[] str = new String[nums.length];
        for (int i = 0; i < str.length; i++) {
            str[i] = String.valueOf(nums[i]);
        }
        Arrays.sort(str, new Comparator<String>() {
            public int compare(String a, String b) {
                String s1 = a + b;
                String s2 = b + a;
                return s2.compareTo(s1);
            }
        });
        // 边界情况：数组元素全为0，比如[0, 0, 0, 0]
        if (str[0].charAt(0) == '0') {
            return "0";
        }
        StringBuilder sb = new StringBuilder();
        for (String temp : str) {
            sb.append(temp);
        }
        return sb.toString();
    }
}

57. Insert Interval

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:
Given intervals [1,3],[6,9], insert and merge [2,5] in as [1,5],[6,9].

Example 2:
Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].

This is because the new interval [4,9] overlaps with [3,5],[6,7],[8,10].

思路：三步走。第一步：把非重叠的在newInterval前面的interval加入到结果集中。第二步：用与newInterval重叠的interval来更新newInterval的start和end。第三步：把非重叠的在newInterval后面的interval加入到结果集中。

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
        List<Interval> result = new ArrayList<>();
        int i = 0;
        while (i < intervals.size() && intervals.get(i).end < newInterval.start) {
            result.add(intervals.get(i));
            i++;
        }
        while (i < intervals.size() && intervals.get(i).start <= newInterval.end) {
            newInterval.start = Math.min(newInterval.start, intervals.get(i).start);
            newInterval.end = Math.max(newInterval.end, intervals.get(i).end);
            i++;
        }
        result.add(newInterval);
        while (i < intervals.size()) {
            result.add(intervals.get(i));
            i++;
        }
        return result;
    }
}

567. Permutation in String

Given two strings s1 and s2, write a function to return true if s2 contains the permutation of s1. In other words, one of the first string's permutations is the substring of the second string.

Example 1:
Input:s1 = "ab" s2 = "eidbaooo"
Output:True
Explanation: s2 contains one permutation of s1 ("ba").
Example 2:
Input:s1= "ab" s2 = "eidboaoo"
Output: False
Note:
The input strings only contain lower case letters.
The length of both given strings is in range [1, 10,000].

思路：

　　知识点1:如何判断s1是s2的全排列（两个字符串长度相等）？用map分别统计s1和s2的 字符 --> 该字符出现的次数。如果每个字符及其出现次数相等，那么s1就是s2的券排列。由于只有26个字符，也可以开一个长度为26的计数数组来统计判断。

　　知识点2:如何判断s2中含有s1的全排列，即如何判断s2是否含有子串是s1的全排列。由知识点1我们很自然地想到，用知识点1的办法解决知识点2。用一个与s1长度相等的滑动窗口对s2从开始移动到末尾，开始时遍历s1的每个字符，将字符的次数统计在map／计数数组中，滑动窗口每滑动到一个新地方，对滑入窗口的字符，在map／计数数组中将该字符对应的次数减1，对滑出窗口的字符，在map／计数数组中将该字符对应的次数加1，如果此时map的每个value／计数数组里的每个元素都为0，说明此时滑动窗口对应的子串是s1的全排列，返回true。如果窗口滑到末尾也没找到，返回false。

public class Solution {
    public boolean checkInclusion(String s1, String s2) {
        if (s1 == null) {
            return true;
        }
        if (s1 != null && s2 == null) {
            return false;
        }
        if (s1.length() > s2.length()) {
            return false;
        }
        int[] count = new int[26];
        for (int i = 0; i < s1.length(); i++) {
            count[s1.charAt(i) - 'a']++;
            count[s2.charAt(i) - 'a']--;
        }
        if (allZero(count)) {
            return true;
        }
        for (int i = s1.length(); i < s2.length(); i++) {
            count[s2.charAt(i) - 'a']--;
            count[s2.charAt(i - s1.length()) - 'a']++;
            if (allZero(count)) {
                return true;
            }
        }
        return false;
    }
    public boolean allZero(int[] count) {
        for (int i = 0; i < count.length; i++) {
            if (count[i] != 0) {
                return false;
            }
        }
        return true;
    }
}

11. Container With Most Water

Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.

Note: You may not slant the container and n is at least 2.

思路：双指针，左右指针分别指向最外面的两条线，然后以这两条线开始计算所能装的容积，找两个线的高度较短的一方，将相应的指针向中间靠拢，只有这样才可能得到比原来更大的容积。当两个指针相遇即结束，时间复杂度O(n)，空间复杂度O(1)。

public class Solution {
    public int maxArea(int[] height) {
        if (height == null || height.length <= 1) {
            return 0;
        }
        int start = 0;
        int end = height.length - 1;
        int maxArea = 0;
        while (start < end) {
            maxArea = Math.max(maxArea, Math.min(height[start], height[end]) * (end - start));
            if (height[start] < height[end]) {
                start++;
            } else {
                end--;
            }
        }
        return maxArea;
    }
}

搜索到满意滑动窗口类型（3道）

30. Substring with Concatenation of All Words

You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in words exactly once and without any intervening characters.

For example, given:
s: "barfoothefoobarman"
words: ["foo", "bar"]

You should return the indices: [0,9].
(order does not matter).

思路：固定起点i（外层循环），从起点开始搜索（内层循环），如果能搜索到一个窗口恰好满足该窗口内的子串是words中所有单词的结合，就将起点i加入到结果集中；否则终止内层循环，i移到下一个起点。

public class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> result = new ArrayList<>();
        if (s == null || s.length() == 0 || words == null || words.length == 0
            || s.length() < words[0].length() * words.length) {
            return result;
        }
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < words.length; i++) {
            if (!map.containsKey(words[i])) {
                map.put(words[i], 1);
            } else {
                map.put(words[i], map.get(words[i]) + 1);
            }
        }
        int wordLen = words[0].length();
        for (int i = 0; i <= s.length() - words.length * wordLen; i++) {
            Map<String, Integer> temp = new HashMap<>();
            int j = 0;
            for (j = 0; j < words.length; j++) {
                String word = s.substring(i + j * wordLen, i + (j + 1) * wordLen);
                if (!map.containsKey(word)) {
                    break;
                }
                if (!temp.containsKey(word)) {
                    temp.put(word, 1);
                } else {
                    temp.put(word, temp.get(word) + 1);
                }
                if (temp.get(word) > map.get(word)) {
                    break;
                }
            }
            if (j == words.length) {
                result.add(i);
            }
        }
        return result;
    }
}

76. Minimum Window Substring

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,
S = "ADOBECODEBANC"
T = "ABC"
Minimum window is "BANC".

Note:
If there is no such window in S that covers all characters in T, return the empty string "".

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

思路：固定起点i，从起点开始搜索，如果能搜索到一个窗口恰好满足该窗口内的子串含有t中所有字符，就用该窗口长度和窗口对应的子串更新最小长度和最小子串；否则移到下一个起点开始继续遍历。

public class Solution {
    public String minWindow(String s, String t) {
        if (s == null || s.length() == 0 || t == null || t.length() == 0) {
            return "";
        }
        int[] targetHash = initialize(t);
        int[] sourceHash = new int[256];
        int i = 0;
        int j = 0;
        int minLength = Integer.MAX_VALUE;
        String minString = "";
        for (i = 0; i < s.length(); i++) {
            while (j < s.length() && !valid(sourceHash, targetHash)) {
                sourceHash[s.charAt(j)]++;
                j++;
            }
            if (valid(sourceHash, targetHash)) {
                if (j - i < minLength) {
                    minLength = j - i;
                    minString = s.substring(i, j);
                }
            }
            sourceHash[s.charAt(i)]--;
        }
        return minString;
    }
    public int[] initialize(String t) {
        int[] targetHash = new int[256];
        for (int i = 0; i < t.length(); i++) {
            targetHash[t.charAt(i)]++;
        }
        return targetHash;
    }
    public boolean valid(int[] sourceHash, int[] targetHash) {
        for (int i = 0; i < sourceHash.length; i++) {
            if (sourceHash[i] < targetHash[i]) {
                return false;
            }
        }
        return true;
    }
}

3. Longest Substring Without Repeating Characters

Given a string, find the length of the longest substring without repeating characters.

Examples:

Given "abcabcbb", the answer is "abc", which the length is 3.

Given "bbbbb", the answer is "b", with the length of 1.

Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

思路：固定起点i，从起点开始搜索，如果能搜索到一个窗口恰好满足该窗口内没有重复的字符（set实现）且窗口长度最大，就用该窗口长度更新结果，遇到窗口内出现重复字符时停止向前扩大窗口，移动到下一个起点继续上述过程。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        int i = 0;
        int j = 0;
        int max = Integer.MIN_VALUE;
        Set<Character> set = new HashSet<>();
        for (i = 0; i < s.length(); i++) {
            while (j < s.length() && !set.contains(s.charAt(j))) {
                set.add(s.charAt(j));
                j++;
            }
            max = Math.max(max, set.size());
            set.remove(s.charAt(i));
        }
        return max;
    }
}

------------  我是分割线  -------------

从今天开始，6.5号，周一。每天跟着师兄按专题按AC率刷两道题，每晚交流今日刷的题目，扫荡式！要坚持下去，保持良好的习惯，fighting！做过的题，争取一遍AC，写完代码一定要检查一下corner case和有没有变量名、函数名敲错，这都是很容易犯的错误！！！ 

BFS专题：

513. Find Bottom Left Tree Value

Given a binary tree, find the leftmost value in the last row of the tree.

Example 1:
Input:

    2
   / 
  1   3

Output:
1
Example 2: 
Input:

        1
       / 
      2   3
     /   / 
    4   5   6
       /
      7

Output:
7
Note: You may assume the tree (i.e., the given root node) is not NULL.

题意：找出二叉树里，最后一层最左边的节点的值。

思路I：BFS，分层，用每一层的第一个节点更新leftmost，BFS结束之后leftmost就是所要找的最后一层最左边的节点，返回节点值即可。

　　　一次AC

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int findBottomLeftValue(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        TreeNode leftmost = null;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (i == 0) {
                    leftmost = node;
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return leftmost.val;
    }
}

 思路II：DFS，设置一个全局深度global_depth和一个全局值global_value（以根节点为深度0的话，初始化为-1而不是0），这道题就是在前序遍历过程中，每当遍历到叶节点就检查当前深度是否大于全局深度，如果大于，更新全局深度和全局值，否则，继续遍历。相同深度只用存储第一个，由于前序遍历（其他遍历均可），也就是最左边的也节点。

515. Find Largest Value in Each Tree Row

You need to find the largest value in each row of a binary tree.

Example:
Input: 

          1
         / 
        3   2
       /      
      5   3   9 

Output: [1, 3, 9]

题意：求二叉树每一层的最大值

思路I：BFS，分层，对于每层的节点统计出一个最大值加入到结果集中，最后返回结果集

　　　一次AC

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int max = Integer.MIN_VALUE;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.val > max) {
                    max = node.val;
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(max);
        }
        return result;
    }
}

思路II：DFS，前序遍历过程中，利用当前递归深度去扩展list的size，list索引为二叉树深度（从0开始），值为当前深度的最大值，遍历过程中更新每个深度的最大值即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        dfs(root, 0, result);
        return result;
    }
    public void dfs(TreeNode root, int depth, List<Integer> result) {
        if (root == null) {
            return;
        }
        if (depth == result.size()) {
            result.add(root.val);
        } else {
            result.set(depth, Math.max(result.get(depth), root.val));
        }
        dfs(root.left, depth + 1, result);
        dfs(root.right, depth + 1, result);
    }
}

323. Number of Connected Components in an Undirected Graph

Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), write a function to find the number of connected components in an undirected graph.

Example 1:
     0          3
     |          |
     1 --- 2    4
Given n = 5 and edges = [[0, 1], [1, 2], [3, 4]], return 2.

Example 2:
     0           4
     |           |
     1 --- 2 --- 3
Given n = 5 and edges = [[0, 1], [1, 2], [2, 3], [3, 4]], return 1.

Note:
You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.

题意：求连通快个数

思路I：BFS。最后看执行了多少次BFS操作。注意点已在代码中说明。

public class Solution {
    public int countComponents(int n, int[][] edges) {
        if (edges == null || edges.length == 0 || edges[0].length == 0) {
            return n;
        }
        Map<Integer, Set<Integer>> map = initialize(n, edges);
        boolean[] visited = new boolean[n];
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (visited[i]) {
                continue;
            }
            bfs(i, map, visited);
            count++;
        }
        return count;
    }
    public void bfs(int start, Map<Integer, Set<Integer>> map, boolean[] visited) {
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(start);
        visited[start] = true;
        while (!queue.isEmpty()) {
            int num = queue.poll();
            // 1.前提是每个节点的set域都非空才能遍历
            for (int neighbor : map.get(num)) {
                if (visited[neighbor]) {
                    continue;
                }
                queue.offer(neighbor);
                visited[neighbor] = true;
            }
        }
    }
    public Map<Integer, Set<Integer>> initialize(int n, int[][] edges) {
        Map<Integer, Set<Integer>> map = new HashMap<>();
        // 注意这里一定要把每个节点的set都要初始化，否则1处会报错
        for (int i = 0; i < n; i++) {
            map.put(i, new HashSet<Integer>());
        }
        for (int i = 0; i < edges.length; i++) {
            map.get(edges[i][0]).add(edges[i][1]);
            map.get(edges[i][1]).add(edges[i][0]);
        }
        return map;
    }
}

思路II：UnionFind。并查集结构中增设count用来统计连通块个数，初始化为节点个数n。

class UnionFind {
    private int count;
    private int[] father;
    public UnionFind(int n) {
        father = new int[n];
        for (int i = 0; i < n; i++) {
            father[i] = i;
        }
        count = n;
    }
    public void union(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            father[root_a] = root_b;
            count--;
        }
    }
    public int find(int x) {
        if (father[x] == x) {
            return x;
        }
        return father[x] = find(father[x]);
    }
    public int getCount() {
        return count;
    }
}
public class Solution {
    public int countComponents(int n, int[][] edges) {
        if (n <= 0) {
            return 0;
        }
        if (edges == null || edges.length == 0 || edges[0].length == 0) {
            return n;
        }
        UnionFind union_find = new UnionFind(n);
        for (int i = 0; i < edges.length; i++) {
            union_find.union(edges[i][0], edges[i][1]);
        }
        return union_find.getCount();
    }
}

529. Minesweeper

Let's play the minesweeper game (Wikipedia, online game)!

You are given a 2D char matrix representing the game board. 'M' represents an unrevealed mine, 'E' represents an unrevealed empty square, 'B' represents a revealed blank square that has no adjacent (above, below, left, right, and all 4 diagonals) mines, digit ('1' to '8') represents how many mines are adjacent to this revealed square, and finally 'X' represents a revealed mine.

Now given the next click position (row and column indices) among all the unrevealed squares ('M' or 'E'), return the board after revealing this position according to the following rules:

If a mine ('M') is revealed, then the game is over - change it to 'X'.
If an empty square ('E') with no adjacent mines is revealed, then change it to revealed blank ('B') and all of its adjacent unrevealed squares should be revealed recursively.
If an empty square ('E') with at least one adjacent mine is revealed, then change it to a digit ('1' to '8') representing the number of adjacent mines.
Return the board when no more squares will be revealed.
Example 1:
Input: 

[['E', 'E', 'E', 'E', 'E'],
 ['E', 'E', 'M', 'E', 'E'],
 ['E', 'E', 'E', 'E', 'E'],
 ['E', 'E', 'E', 'E', 'E']]

Click : [3,0]

Output: 

[['B', '1', 'E', '1', 'B'],
 ['B', '1', 'M', '1', 'B'],
 ['B', '1', '1', '1', 'B'],
 ['B', 'B', 'B', 'B', 'B']]

Explanation:

Example 2:
Input: 

[['B', '1', 'E', '1', 'B'],
 ['B', '1', 'M', '1', 'B'],
 ['B', '1', '1', '1', 'B'],
 ['B', 'B', 'B', 'B', 'B']]

Click : [1,2]

Output: 

[['B', '1', 'E', '1', 'B'],
 ['B', '1', 'X', '1', 'B'],
 ['B', '1', '1', '1', 'B'],
 ['B', 'B', 'B', 'B', 'B']]

Explanation:

Note:
The range of the input matrix's height and width is [1,50].
The click position will only be an unrevealed square ('M' or 'E'), which also means the input board contains at least one clickable square.
The input board won't be a stage when game is over (some mines have been revealed).
For simplicity, not mentioned rules should be ignored in this problem. For example, you don't need to reveal all the unrevealed mines when the game is over, consider any cases that you will win the game or flag any squares.

题意：扫雷游戏

思路：BFS，按照游戏规则来写思路即可，注意为了避免重复位置加入到队列中，可以有两种解决办法：1. 设置访问数组visited来记录哪些位置上的字符'E'被访问过  2. 每当加入一个'E'的位置到队列中时，修改字符'E'为字符'B'。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    int n;
    int m;
    public char[][] updateBoard(char[][] board, int[] click) {
        if (board == null || board.length == 0 || board[0].length == 0 || click == null || click.length == 0) {
            return board;
        }
        n = board.length;
        m = board[0].length;
        int x = click[0];
        int y = click[1];
        if (board[x][y] != 'M' && board[x][y] != 'E') {
            return board;
        }
        if (board[x][y] == 'M') {
            board[x][y] = 'X';
            return board;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.offer(new Node(x, y));
        // 方法1: 用一个访问数组记录那些位置的字符E被访问过了
        // boolean[][] visited = new boolean[n][m];
        // visited[x][y] = true;
        int[] dx = {1, 1, 0, -1, -1, -1, 0, 1};
        int[] dy = {0, 1, 1, 1, 0, -1, -1, -1};
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            int count = 0;
            List<Node> list = new ArrayList<>();
            for (int i = 0; i < 8; i++) {
                Node next = new Node(cur.x + dx[i], cur.y + dy[i]);
                if (next.x < 0 || next.x >= n || next.y < 0 || next.y >= m) {
                    continue;
                }
                if (board[next.x][next.y] == 'M') {
                    count++;
                }
                // if (!visited[next.x][next.y] && board[next.x][next.y] == 'E') {
                //     list.add(next);
                // }
                if (board[next.x][next.y] == 'E') {
                    list.add(next);
                }
            }
            if (count == 0) {
                board[cur.x][cur.y] = 'B';
                for (Node node : list) {
                    queue.offer(node);
                    // 方法2: 为了防止重复加入，当加入一个E时修改其字符为'B'
                    board[node.x][node.y] = 'B';
                    // visited[node.x][node.y] = true;
                }
            } else {
                board[cur.x][cur.y] = (char) ('0' + count);
            }
        }
        return board;
    }
}

286. Walls and Gates

You are given a m x n 2D grid initialized with these three possible values.

-1 - A wall or an obstacle.
0 - A gate.
INF - Infinity means an empty room. We use the value 231 - 1 = 2147483647 to represent INF as you may assume that the distance to a gate is less than 2147483647.
Fill each empty room with the distance to its nearest gate. If it is impossible to reach a gate, it should be filled with INF.

For example, given the 2D grid:
INF  -1  0  INF
INF INF INF  -1
INF  -1 INF  -1
  0  -1 INF INF
After running your function, the 2D grid should be:
  3  -1   0   1
  2   2   1  -1
  1  -1   2  -1
  0  -1   3   4

思路：BFS，分层，因为要统计最短路径，并且应该对二维矩阵中所有的0开始进行BFS遍历。时间复杂度O(knm)，k为0的个数。

　　　一刷的时候没AC是因为没有设置访问数组visited来避免元素重复入列，导致超时。

　　　二刷AC。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    int n;
    int m;
    public void wallsAndGates(int[][] rooms) {
        if (rooms == null || rooms.length == 0 || rooms[0].length == 0) {
            return;
        }
        n = rooms.length;
        m = rooms[0].length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (rooms[i][j] == 0) {
                    bfs(rooms, i, j, new boolean[n][m]);
                }
            }
        }
    }
    public void bfs(int[][] rooms, int x, int y, boolean[][] visited) {
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        Queue<Node> queue = new LinkedList<>();
        queue.offer(new Node(x, y));
        visited[x][y] = true;
        int steps = 0;
        while (!queue.isEmpty()) {
            steps++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                Node cur = queue.poll();
                for (int j = 0; j < 4; j++) {
                    Node next = new Node(cur.x + dx[j], cur.y + dy[j]);
                    if (inBound(next) && !visited[next.x][next.y]
                        && rooms[next.x][next.y] != 0 && rooms[next.x][next.y] != -1) {
                        queue.offer(next);
                        visited[next.x][next.y] = true;
                        rooms[next.x][next.y] = Math.min(rooms[next.x][next.y], steps);
                    }
                }
            }
        }
    }
    public boolean inBound(Node node) {
        if (node.x < 0 || node.x >= n) {
            return false;
        }
        if (node.y < 0 || node.y >= m) {
            return false;
        }
        return true;
    }
}

优化：事先将所有为0的节点入列，以这些节点为中心，作为第一层开始进行BFS遍历，并且不用visited访问数组，因为只会将INTEGER.MAX_VALUE入列，每个更新过的节点都是最短路径。时间复杂度O(nm)，空间复杂度O(1)。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    int n;
    int m;
    public void wallsAndGates(int[][] rooms) {
        if (rooms == null || rooms.length == 0 || rooms[0].length == 0) {
            return;
        }
        n = rooms.length;
        m = rooms[0].length;
        Queue<Node> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (rooms[i][j] == 0) {
                    queue.offer(new Node(i, j));
                }
            }
        }
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        int steps = 0;
        while (!queue.isEmpty()) {
            steps++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                Node cur = queue.poll();
                for (int j = 0; j < 4; j++) {
                    Node next = new Node(cur.x + dx[j], cur.y + dy[j]);
                    if (inBound(next) && rooms[next.x][next.y] == Integer.MAX_VALUE) {
                        queue.offer(next);
                        rooms[next.x][next.y] = steps;
                    }
                }
            }
        }
    }
    public boolean inBound(Node node) {
        if (node.x < 0 || node.x >= n) {
            return false;
        }
        if (node.y < 0 || node.y >= m) {
            return false;
        }
        return true;
    }
}

490. The Maze

There is a ball in a maze with empty spaces and walls. The ball can go through empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction.

Given the ball's start position, the destination and the maze, determine whether the ball could stop at the destination.

The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space. You may assume that the borders of the maze are all walls. The start and destination coordinates are represented by row and column indexes.

Example 1

Input 1: a maze represented by a 2D array

0 0 1 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 1 1
0 0 0 0 0

Input 2: start coordinate (rowStart, colStart) = (0, 4)
Input 3: destination coordinate (rowDest, colDest) = (4, 4)

Output: true
Explanation: One possible way is : left -> down -> left -> down -> right -> down -> right.

Example 2

Input 1: a maze represented by a 2D array

0 0 1 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 1 1
0 0 0 0 0

Input 2: start coordinate (rowStart, colStart) = (0, 4)
Input 3: destination coordinate (rowDest, colDest) = (3, 2)

Output: false
Explanation: There is no way for the ball to stop at the destination.

Note:
There is only one ball and one destination in the maze.
Both the ball and the destination exist on an empty space, and they will not be at the same position initially.
The given maze does not contain border (like the red rectangle in the example pictures), but you could assume the border of the maze are all walls.
The maze contains at least 2 empty spaces, and both the width and height of the maze won't exceed 100.

思路：BFS，只不过这道题中BFS的步长不再为1，而是由往某一个方向一直走知道撞墙才能确定步长也就是确定下一次BFS的点。同样的我们用访问数组visited来避免重复元素入列。时间复杂度O(nm)，空间复杂度O(nm)，n为行数，m为列数。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    public boolean hasPath(int[][] maze, int[] start, int[] destination) {
        if (maze == null || maze.length == 0 || maze[0].length == 0) {
            return true;
        }
        if (start[0] == destination[0] && start[1] == destination[1]) {
            return true;
        }
        int n = maze.length;
        int m = maze[0].length;
        Queue<Node> queue = new LinkedList<>();
        boolean[][] visited = new boolean[n][m];
        queue.offer(new Node(start[0], start[1]));
        visited[start[0]][start[1]] = true;
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            for (int i = 0; i < 4; i++) {
                // 这里的操作跟一般的BFS不同。
                // 一般情况下BFS的步长是1，这里BFS的步长是由向某个方向一直走直到撞墙才能确定。
                int next_x = cur.x;
                int next_y = cur.y;
                while (next_x >= 0 && next_x < n && next_y >= 0 && next_y < m
                       && maze[next_x][next_y] == 0) {
                    next_x += dx[i];
                    next_y += dy[i];
                }
                next_x -= dx[i];
                next_y -= dy[i];
                if (visited[next_x][next_y]) {
                    continue;
                }
                if (next_x == destination[0] && next_y == destination[1]) {
                    return true;
                }
                queue.offer(new Node(next_x, next_y));
                visited[next_x][next_y] = true;
            }
        }
        return false;
    }
}

505. The Maze II

There is a ball in a maze with empty spaces and walls. The ball can go through empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction.

Given the ball's start position, the destination and the maze, find the shortest distance for the ball to stop at the destination. The distance is defined by the number of empty spaces traveled by the ball from the start position (excluded) to the destination (included). If the ball cannot stop at the destination, return -1.

The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space. You may assume that the borders of the maze are all walls. The start and destination coordinates are represented by row and column indexes.

Example 1

Input 1: a maze represented by a 2D array

0 0 1 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 1 1
0 0 0 0 0

Input 2: start coordinate (rowStart, colStart) = (0, 4)
Input 3: destination coordinate (rowDest, colDest) = (4, 4)

Output: 12
Explanation: One shortest way is : left -> down -> left -> down -> right -> down -> right.
             The total distance is 1 + 1 + 3 + 1 + 2 + 2 + 2 = 12.

Example 2

Input 1: a maze represented by a 2D array

0 0 1 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 1 1
0 0 0 0 0

Input 2: start coordinate (rowStart, colStart) = (0, 4)
Input 3: destination coordinate (rowDest, colDest) = (3, 2)

Output: -1
Explanation: There is no way for the ball to stop at the destination.

Note:
There is only one ball and one destination in the maze.
Both the ball and the destination exist on an empty space, and they will not be at the same position initially.
The given maze does not contain border (like the red rectangle in the example pictures), but you could assume the border of the maze are all walls.
The maze contains at least 2 empty spaces, and both the width and height of the maze won't exceed 100.

题意：在I的基础上求最短路径，无路径返回-1。

思路：BFS。这道题相当于Dijkstra求最短路径。为了加快速度，使用PriorityQueue而不是普通的queue，每个节点三个属性：横坐标x，纵坐标y，到当前节点的路径长度l。再设置一个全局distance数组，distance[i][j]表示到(i,j)节点的最短路径。BFS结束后，返回distance[i][j](如果路径存在)，否则返回-1。

class Node {
    int x;
    int y;
    int l;
    public Node(int x, int y, int l) {
        this.x = x;
        this.y = y;
        this.l = l;
    }
}
public class Solution {
    public int shortestDistance(int[][] maze, int[] start, int[] destination) {
        if (maze == null || maze.length == 0 || maze[0].length == 0) {
            return 0;
        }
        if (start[0] == destination[0] && start[1] == destination[1]) {
            return 0;
        }
        int n = maze.length;
        int m = maze[0].length;
        PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>() {
            public int compare(Node a, Node b) {
                return a.l - b.l;
            }
        });
        int[][] distance = new int[n][m];
        pq.offer(new Node(start[0], start[1], 0));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                distance[i][j] = Integer.MAX_VALUE;
            }
        }
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        while (!pq.isEmpty()) {
            Node cur = pq.poll();
            if (cur.l >= distance[cur.x][cur.y]) {
                continue;
            }
            distance[cur.x][cur.y] = cur.l;
            for (int i = 0; i < 4; i++) {
                int next_x = cur.x;
                int next_y = cur.y;
                int l = cur.l;
                while (next_x >= 0 && next_x < n && next_y >= 0 && next_y < m
                       && maze[next_x][next_y] != 1) {
                    next_x += dx[i];
                    next_y += dy[i];
                    l++;
                }
                next_x -= dx[i];
                next_y -= dy[i];
                l--;
                pq.offer(new Node(next_x, next_y, l));
            }
        }
        if (distance[destination[0]][destination[1]] == Integer.MAX_VALUE) {
            return -1;
        }
        return distance[destination[0]][destination[1]];
    }
}

499. The Maze III

There is a ball in a maze with empty spaces and walls. The ball can go through empty spaces by rolling up (u), down (d), left (l) or right (r), but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction. There is also a hole in this maze. The ball will drop into the hole if it rolls on to the hole.

Given the ball position, the hole position and the maze, find out how the ball could drop into the hole by moving the shortest distance. The distance is defined by the number of empty spaces traveled by the ball from the start position (excluded) to the hole (included). Output the moving directions by using 'u', 'd', 'l' and 'r'. Since there could be several different shortest ways, you should output the lexicographically smallest way. If the ball cannot reach the hole, output "impossible".

The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space. You may assume that the borders of the maze are all walls. The ball and the hole coordinates are represented by row and column indexes.

Example 1

Input 1: a maze represented by a 2D array

0 0 0 0 0
1 1 0 0 1
0 0 0 0 0
0 1 0 0 1
0 1 0 0 0

Input 2: ball coordinate (rowBall, colBall) = (4, 3)
Input 3: hole coordinate (rowHole, colHole) = (0, 1)

Output: "lul"
Explanation: There are two shortest ways for the ball to drop into the hole.
The first way is left -> up -> left, represented by "lul".
The second way is up -> left, represented by 'ul'.
Both ways have shortest distance 6, but the first way is lexicographically smaller because 'l' < 'u'. So the output is "lul".

Example 2

Input 1: a maze represented by a 2D array

0 0 0 0 0
1 1 0 0 1
0 0 0 0 0
0 1 0 0 1
0 1 0 0 0

Input 2: ball coordinate (rowBall, colBall) = (4, 3)
Input 3: hole coordinate (rowHole, colHole) = (3, 0)
Output: "impossible"
Explanation: The ball cannot reach the hole.

Note:
There is only one ball and one hole in the maze.
Both the ball and hole exist on an empty space, and they will not be at the same position initially.
The given maze does not contain border (like the red rectangle in the example pictures), but you could assume the border of the maze are all walls.
The maze contains at least 2 empty spaces, and the width and the height of the maze won't exceed 30.

题意：球进洞的路径上的方向。

思路：类似II，多一个洞的位置的判断，比较的时候是距离l和字典顺序两个因素的比较。

class Node {
    int x;
    int y;
    int l;
    String s;
    public Node(int x, int y, int l, String s) {
        this.x = x;
        this.y = y;
        this.l = l;
        this.s = s;
    }
    public int compareTo(Node node) {
        if (l != node.l) {
            return l - node.l;
        } else {
            return s.compareTo(node.s);
        }
    }
}
public class Solution {
    public String findShortestWay(int[][] maze, int[] ball, int[] hole) {
        if (maze == null || maze.length == 0 || maze[0].length == 0) {
            return "";
        }
        if (ball[0] == hole[0] && ball[1] == hole[1]) {
            return "";
        }
        int n = maze.length;
        int m = maze[0].length;
        String[] directions = {"d","r","u","l"};
        Node[][] nodes = new Node[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                nodes[i][j] = new Node(i, j, Integer.MAX_VALUE, "");
            }
        }
        PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>() {
            public int compare(Node a, Node b) {
                if (a.l != b.l) {
                    return a.l - b.l;
                } else {
                    return a.s.compareTo(b.s);
                }
            }
        });
        pq.offer(new Node(ball[0], ball[1], 0, ""));
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        while (!pq.isEmpty()) {
            Node cur = pq.poll();
            if (nodes[cur.x][cur.y].compareTo(cur) <= 0) {
                continue;
            }
            // if (nodes[cur.x][cur.y].l < cur.l) {
            //     continue;
            // }
            // if (nodes[cur.x][cur.y].l == cur.l && nodes[cur.x][cur.y].s.compareTo(cur.s) <= 0) {
            //     continue;
            // }
            nodes[cur.x][cur.y] = cur;
            for (int i = 0; i < 4; i++) {
                int next_x = cur.x;
                int next_y = cur.y;
                int next_l = cur.l;
                while (next_x >= 0 && next_x < n && next_y >= 0 && next_y < m
                    && maze[next_x][next_y] == 0 && (next_x != hole[0] || next_y != hole[1])) {
                    next_x += dx[i];
                    next_y += dy[i];
                    next_l++;
                }
                if (next_x != hole[0] || next_y != hole[1]) {
                    next_x -= dx[i];
                    next_y -= dy[i];
                    next_l--;
                }
                pq.offer(new Node(next_x, next_y, next_l, cur.s + directions[i]));
            }
        }
        if (nodes[hole[0]][hole[1]].l == Integer.MAX_VALUE) {
            return "impossible";
        }
        return nodes[hole[0]][hole[1]].s;
    }
}

199. Binary Tree Right Side View

Given a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

For example:
Given the following binary tree,
   1            <---
 /   
2     3         <---
      
  5     4       <---
You should return [1, 3, 4].

题意：求二叉树从右看每一层的值

思路：BFS，分层，每一层中最后一个节点加入到结果集中。或者逆序二叉树层序遍历，每一层中第一个节点加入到结果集中。时间复杂度O(n),空间复杂度O(1),n为二叉树节点个数。

Given a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

For example:
Given the following binary tree,
   1            <---
 /   
2     3         <---
      
  5     4       <---
You should return [1, 3, 4].

107. Binary Tree Level Order Traversal II

Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree [3,9,20,null,null,15,7],
    3
   / 
  9  20
    /  
   15   7
return its bottom-up level order traversal as:
[
  [15,7],
  [9,20],
  [3]
]

题意：二叉树层序遍历，每一层元素顺序反转。

思路：BFS，分层，每一层的元素用tempList收集，不同的地方在于加入到结果集时用list.add(int index, List<Integer> tempList)来实现每层元素集合的反转。时间复杂度O(n),空间复杂度O(1),n为二叉树节点个数。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> tempList = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                tempList.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(0, tempList);
        }
        return result;
    }
}

102. Binary Tree Level Order Traversal

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],
    3
   / 
  9  20
    /  
   15   7
return its level order traversal as:
[
  [3],
  [9,20],
  [15,7]
]

题意：二叉树层序遍历

思路：BFS，分层，so easy，练好bug free。时间复杂度O(n)，空间复杂度O(n)，n为节点总个数。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> tempList = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                tempList.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(tempList);
        }
        return result;
    }
}

101. Symmetric Tree

Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree [1,2,2,3,4,4,3] is symmetric:

    1
   / 
  2   2
 /  / 
3  4 4  3
But the following [1,2,2,null,3,null,3] is not:
    1
   / 
  2   2
      
   3    3
Note:
Bonus points if you could solve it both recursively and iteratively.

题目：判断一棵二叉树是不是对称树

思路：DFS。对于一个节点，看以其两个子节点开始是否为对称树，有以下几种情况：

　　　　1. left==null && right == null 此时为对称树，返回true

　　　　2. left和right一个null一个非null 此时不为对称树，返回false

　　　　3. left非null && right非null，此时分两种情况：

　　　　　　（1）left节点值不等于right节点值，此时不为对称树，返回false

　　　　　　（2）left节点值不等于right节点值，此时再递归看left.left与right.right是否构成对称树

　　　　　　　　 以及left.right与right.left是否构成称树

　　　时间复杂度O(n)，n为节点总个数，空间复杂度O(lgn)，即递归深度。

　　  这道题是剑指offer 面试题59，事实上这道题就是比较二叉树前序遍历(遍历顺序是：中左右)和对称前序遍历(遍历顺序是：中右左)的序列是否相同，注意null节点也要考虑进来！理解了这个代码就不难理解，就是DFS同时进行前序遍历和对称前序遍历，比较当前两个节点的值(如果两个节点都非null)是否相同。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return helper(root.left, root.right);
    }
    public boolean helper(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        }
        if (left == null || right == null) {
            return false;
        }
        if (left.val != right.val) {
            return false;
        }
        return helper(left.left, right.right) && helper(left.right, right.left);
    }
}

261. Graph Valid Tree

Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), write a function to check whether these edges make up a valid tree.

For example:

Given n = 5 and edges = [[0, 1], [0, 2], [0, 3], [1, 4]], return true.

Given n = 5 and edges = [[0, 1], [1, 2], [2, 3], [1, 3], [1, 4]], return false.

Note: you can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.

题意：判断图是不是树

思路I：判断条件有两个：1. 顶点数=边数-1  2. 图中没有环路

　　　并查集。首先判断条件1，再看条件2，一旦出现一条边的两端节点的父亲节点相同，则说明图中有环路，返回false，边遍历结束都没有发现环路说明图是树，返回true。时间复杂度O(e)，e为图的边数，空间复杂度O(n)，n为节点个数。

class UnionFind {
    int[] father;
    public UnionFind(int n) {
        father = new int[n];
        for (int i = 0; i < n; i++) {
            father[i] = i;
        }
    }
    public int find(int x) {
        if (father[x] == x) {
            return x;
        }
        return father[x] = find(father[x]);
    }
    public void union(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            father[root_a] = root_b;
        }
    }
}
public class Solution {
    public boolean validTree(int n, int[][] edges) {
        if (edges == null) {
            if (n == 1) {
                return true;
            } else {
                return false;
            }
        }
        if (n - 1 != edges.length) {
            return false;
        }
        UnionFind uf = new UnionFind(n);
        for (int i = 0; i < edges.length; i++) {
            if (uf.find(edges[i][0]) == uf.find(edges[i][1])) {
                return false;
            }
            uf.union(edges[i][0], edges[i][1]);
        }
        return true;
    }
}

思路II：BFS。先判断条件1，再看从节点0（任一节点都可以）开始BFS遍历过的节点数是否等于节点总数n。时间复杂度O(e)，空间复杂度O(n)。

public class Solution {
    public boolean validTree(int n, int[][] edges) {
        if (edges == null) {
            if (n == 1) {
                return true;
            } else {
                return false;
            }
        }
        if (n - 1 != edges.length) {
            return false;
        }
        Map<Integer, Set<Integer>> graph = initializeGraph(n, edges);
        Queue<Integer> queue = new LinkedList<>();
        Set<Integer> set = new HashSet<>();
        queue.offer(0);
        set.add(0);
        while (!queue.isEmpty()) {
            int num = queue.poll();
            for (int neighbor : graph.get(num)) {
                if (!set.contains(neighbor)) {
                    queue.offer(neighbor);
                    set.add(neighbor);
                }
            }
        }
        return set.size() == n;
    }
    public Map<Integer, Set<Integer>> initializeGraph(int n, int[][] edges) {
        Map<Integer, Set<Integer>> graph = new HashMap<>();
        for (int i = 0; i < n; i++) {
            graph.put(i, new HashSet<Integer>());
        }
        for (int i = 0; i < edges.length; i++) {
            graph.get(edges[i][0]).add(edges[i][1]);
            graph.get(edges[i][1]).add(edges[i][0]);
        }
        return graph;
    }
}

42. Trapping Rain Water

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

For example, 
Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.

题意：一维矩阵能装水的容积

思路：双指针。并且定义左右两个边界高度leftMax和rightMax，当前位置能装水的体积 = Min(leftMax, rightMax) - 当前高度。

public class Solution {
    public int trap(int[] height) {
        if (height == null || height.length == 0) {
            return 0;
        }
        int left = 0;
        int right = height.length - 1;
        int leftMax = 0;
        int rightMax = 0;
        int sum = 0;
        while (left <= right) {
            if (height[left] <= height[right]) {
                if (height[left] >= leftMax) {
                    leftMax = height[left];
                } else {
                    sum += leftMax - height[left];
                }
                left++;
            } else {
                if (height[right] >= rightMax) {
                    rightMax = height[right];
                } else {
                    sum += rightMax - height[right];
                }
                right--;
            }
        }
        return sum;
    }
}

407. Trapping Rain Water II

Given an m x n matrix of positive integers representing the height of each unit cell in a 2D elevation map, compute the volume of water it is able to trap after raining.

Note:
Both m and n are less than 110. The height of each unit cell is greater than 0 and is less than 20,000.

Example:

Given the following 3x6 height map:
[
  [1,4,3,1,3,2],
  [3,2,1,3,2,4],
  [2,3,3,2,3,1]
]

Return 4.

题意：二维矩阵能装水的容积

思路：从二维矩阵边界开始，将节点加入到优先队列中，然后BFS遍历一遍二维矩阵。如果下一个节点高度小于当前节点高度，这个高度差就是当前积水体积，否则，没有积水。注意下一个节点的高度属性应该取当前节点的高度和下一个节点高度中的最大值，即边界高度始终是递增的，类似于Trapping Rain Water I中边界高度都是递增的。时间复杂度O(nm)，空间复杂度O(nm)，n为行数，m为列数。

class Node {
    int x;
    int y;
    int h;
    public Node(int x, int y, int h) {
        this.x = x;
        this.y = y;
        this.h = h;
    }
}
public class Solution {
    public int trapRainWater(int[][] heightMap) {
        if (heightMap == null || heightMap.length == 0 || heightMap[0].length == 0) {
            return 0;
        }
        int n = heightMap.length;
        int m = heightMap[0].length;
        PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>() {
            public int compare(Node a, Node b) {
                return a.h - b.h;
            }
        });
        boolean[][] visited = new boolean[n][m];
        for (int i = 0; i < n; i++) {
            pq.offer(new Node(i, 0, heightMap[i][0]));
            visited[i][0] = true;
            pq.offer(new Node(i, m - 1, heightMap[i][m - 1]));
            visited[i][m - 1] = true;
        }
        for (int i = 0; i < m; i++) {
            pq.offer(new Node(0, i, heightMap[0][i]));
            visited[0][i] = true;
            pq.offer(new Node(n - 1, i, heightMap[n - 1][i]));
            visited[n - 1][i] = true;
        }
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        int sum = 0;
        while (!pq.isEmpty()) {
            Node cur = pq.poll();
            for (int i = 0; i < 4; i++) {
                int next_x = cur.x + dx[i];
                int next_y = cur.y + dy[i];
                if (next_x >= 0 && next_x < n && next_y >= 0 && next_y < m && !visited[next_x][next_y]){
                    Node next = new Node(next_x, next_y, heightMap[next_x][next_y]);
                    if (next.h < cur.h) {
                        sum += cur.h - next.h;
                        next.h = cur.h;
                    }
                    pq.offer(next);
                    visited[next.x][next.y] = true;
                }
            }
        }
        return sum;
    }
}

279. Perfect Squares

Given a positive integer n, find the least number of perfect square numbers (for example, 1, 4, 9, 16, ...) which sum to n.

For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.

题意：n由完全平方数求和得到的最少完全平方数的个数

思路：DP。

　　1. 状态定义  dp[n]表示由完全平方数求和为n的最少完全平方数的个数

　　2. 初始化  dp[i*i] = 1, 其他dp[j] = Integer.MAX_VALUE

　　3. 状态方程  for i: 0 ~ n

　　　　　　　　　　for j: 0 ~ i + j * j <= n

　　　　　　　　　　　　dp[i + j * j] =Math.min(dp[i + j * j], dp[i] + 1)

　　4. 返回结果 dp[n]

时间复杂度O(nlgn)，空间复杂度O(n)。

public class Solution {
    public int numSquares(int n) {
        if (n <= 0) {
            return 0;
        }
        // 1 状态定义
        int[] dp = new int[n + 1];
        // 2 初始化
        Arrays.fill(dp, Integer.MAX_VALUE);
        for (int i = 0; i * i <= n; i++) {
            dp[i * i] = 1;
        }
        // 3 循环递归求解
        for (int i = 0; i <= n; i++) {
            for (int j = 0; i + j * j <= n; j++) {
                dp[i + j * j] = Math.min(dp[i + j * j], dp[i] + 1);
            }
        }
        // 4 返回结果
        return dp[n];
    }
}

301. Remove Invalid Parentheses

Remove the minimum number of invalid parentheses in order to make the input string valid. Return all possible results.

Note: The input string may contain letters other than the parentheses ( and ).

Examples:
"()())()" -> ["()()()", "(())()"]
"(a)())()" -> ["(a)()()", "(a())()"]
")(" -> [""]

题意：去掉无效括号，求所有可能结果。

思路：DFS。先去掉多余的')'，再反转s去掉多余的'('，此时可以重用代码，只需将()变成)(就可以重用。

对于一个字符串，在任何时候如果')'的个数多于左括号，则说明从开始到现在位置必然可以删除一个')'．而这段子串可能包含多个')'，删除哪一个呢？当然删除任何一个都可以．例如对于()())()，从开头到s[4]位置构成的子串多了一个右括号，因此我们需要删掉一个，而这个子串有三个右括号，但是只会产生２个结果，也就是会有一个重复值．所以在删除括号的时候，为保证不会产生重复值，需要记录一个最后删除的位置，这样可以使得在接下来删除的时候只删除这个位置之后的值．这样我们可以使得当前这一段子串不再包含多余的右括号了．这样我们可以删除了一个右括号之后合法的子串与后面还没有检查过的子串组成一个新的字符串重新开始检查．直到不再含有非法的右括号．

但是还有一种情况是包含了多余的左括号，一种直观的方法是从右向左再按照上面的方法处理一遍左括号．但是将数组逆置之后就可以重用上面的算法了．

所以总的思路就是先对字符串进行处理使得其不再含有非法右括号，然后将其翻转以后再检查是否含有非法的左括号．最后左右括号都检查完之后都合法就是我们要的答案了．

时间复杂度应该是O(nk)，n为字符串长度，k为答案个数。每次递归只会产生正确的结果。

public class Solution {
    public List<String> removeInvalidParentheses(String s) {
        List<String> result = new ArrayList<>();
        remove(s, 0, 0, new char[]{'(', ')'}, result);
        return result;
    }
    public void remove(String s, int last_i, int last_j, char[] par, List<String> result) {
        int count = 0;
        for (int i = last_i; i < s.length(); i++) {
            if (s.charAt(i) == par[0]) {
                count++;
            }
            if (s.charAt(i) == par[1]) {
                count--;
            }
            if (count >= 0) {
                continue;
            }
            for (int j = last_j; j <= i; j++) {
                if (s.charAt(j) == par[1] && (j == last_j || s.charAt(j - 1) != par[1])) {
                    remove(s.substring(0, j) + s.substring(j + 1, s.length()), i, j, par, result);
                }
            }
            return;
        }
        String reversed = new StringBuilder(s).reverse().toString();
        if (par[0] == '(') {
            remove(reversed, 0, 0, new char[]{')', '('}, result);
        } else {
            result.add(reversed);
        }
    }
}

200. Number of Islands

Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

11110
11010
11000
00000
Answer: 1

Example 2:

11000
11000
00100
00011
Answer: 3

思路I：并查集

class UnionFind {
    private int[] father;
    private int count;
    public UnionFind(int n, int count) {
        father = new int[n];
        for (int i = 0; i < n; i++) {
            father[i] = i;
        }
        this.count = count;
    }
    public int find(int x) {
        if (father[x] == x) {
            return x;
        }
        return father[x] = find(father[x]);
    }
    public void union(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            father[root_a] = root_b;
            count--;
        }
    }
    public int query() {
        return count;
    }
}
public class Solution {
    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        int n = grid.length;
        int m = grid[0].length;
        int count = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == '1') {
                    count++;
                }
            }
        }
        UnionFind uf = new UnionFind(n * m, count);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == '1') {
                    if (i > 0 && grid[i - 1][j] == '1') {
                        uf.union((i - 1) * m + j, i * m + j);
                    }
                    if (j > 0 && grid[i][j - 1] == '1') {
                        uf.union(i * m + j - 1, i * m + j);
                    }
                    if (j < m - 1 && grid[i][j + 1] == '1') {
                        uf.union(i * m + j + 1, i * m + j);
                    }
                    if (i < n - 1 && grid[i + 1][j] == '1') {
                        uf.union((i + 1) * m + j, i * m + j);
                    }
                }
            }
        }
        return uf.query();
    }
}

思路II：BFS

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    int n;
    int m;
    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        n = grid.length;
        m = grid[0].length;
        int islands = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == '1') {
                    bfs(grid, i, j);
                    islands++;
                }
            }
        }
        return islands;
    }
    public void bfs(char[][] grid, int x, int y) {
        Queue<Node> queue = new LinkedList<>();
        queue.offer(new Node(x, y));
        grid[x][y] = '0';
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            for (int i = 0; i < 4; i++) {
                int next_x = cur.x + dx[i];
                int next_y = cur.y + dy[i];
                if (next_x >= 0 && next_x < n && next_y >= 0 && next_y < m
                    && grid[next_x][next_y] == '1') {
                    queue.offer(new Node(next_x, next_y));
                    grid[next_x][next_y] = '0';
                }
            }
        }
    }
}

103. Binary Tree Zigzag Level Order Traversal

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],
    3
   / 
  9  20
    /  
   15   7
return its zigzag level order traversal as:
[
  [3],
  [20,9],
  [15,7]
]

思路：BFS。用一个flag记录当前层是奇数层还是偶数层即可，比如flag=0代表第1、3、5...层，flag=1代表第2、4、6层。时间复杂度O(n)，空间复杂度O(n)。一次AC

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int flag = 0;
        while (!queue.isEmpty()) {
            List<Integer> tempList = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (flag == 0) {
                    tempList.add(node.val);
                } else {
                    tempList.add(0, node.val);
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(tempList);
            flag = 1 - flag;
        }
        return result;
    }
}

417. Pacific Atlantic Water Flow

Given an m x n matrix of non-negative integers representing the height of each unit cell in a continent, the "Pacific ocean" touches the left and top edges of the matrix and the "Atlantic ocean" touches the right and bottom edges.

Water can only flow in four directions (up, down, left, or right) from a cell to another one with height equal or lower.

Find the list of grid coordinates where water can flow to both the Pacific and Atlantic ocean.

Note:
The order of returned grid coordinates does not matter.
Both m and n are less than 150.
Example:

Given the following 5x5 matrix:

  Pacific ~   ~   ~   ~   ~ 
       ~  1   2   2   3  (5) *
       ~  3   2   3  (4) (4) *
       ~  2   4  (5)  3   1  *
       ~ (6) (7)  1   4   5  *
       ~ (5)  1   1   2   4  *
          *   *   *   *   * Atlantic

Return:

[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).

思路：从海洋边界出发，逆向BFS，这个过程所访问到的节点就是能够到达海洋的节点。两次BFS过后，取能同时到达两个海洋的节点加入到结果中。时间复杂度O(nm)，空间复杂度O(nm)，n为行数，m为列数。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    int n;
    int m;
    public List<int[]> pacificAtlantic(int[][] matrix) {
        List<int[]> result = new ArrayList<>();
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }
        n = matrix.length;
        m = matrix[0].length;
        Queue<Node> queue = new LinkedList<>();
        boolean[][] pacific = new boolean[n][m];
        for (int i = 0; i < n; i++) {
            queue.offer(new Node(i, 0));
            pacific[i][0] = true;
        }
        for (int i = 1; i < m; i++) {
            queue.offer(new Node(0, i));
            pacific[0][i] = true;
        }
        bfs(matrix, queue, pacific);
        boolean[][] atlantic = new boolean[n][m];
        for (int i = 0; i < n; i++) {
            queue.offer(new Node(i, m - 1));
            atlantic[i][m - 1] = true;
        }
        for (int i = 0; i < m - 1; i++) {
            queue.offer(new Node(n - 1, i));
            atlantic[n - 1][i] = true;
        }
        bfs(matrix, queue, atlantic);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (pacific[i][j] && atlantic[i][j]) {
                    result.add(new int[]{i, j});
                }
            }
        }
        return result;
    }
    public void bfs(int[][] matrix, Queue<Node> queue, boolean[][] visited) {
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            for (int i = 0; i < 4; i++) {
                int next_x = cur.x + dx[i];
                int next_y = cur.y + dy[i];
                if (next_x >= 0 && next_x < n && next_y >= 0 && next_y < m
                    && !visited[next_x][next_y] && matrix[next_x][next_y] >= matrix[cur.x][cur.y]) {
                    queue.offer(new Node(next_x, next_y));
                    visited[next_x][next_y] = true;
                }
            }
        }
    }
}

111. Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

思路I：DFS。DFS过程要记录当前递归深度，遍历到叶节点返回，每次遇到叶节点，用当前深度更新minimum。时间复杂度O(n)，空间复杂度O(lgn)，n为节点个数。一次AC

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    int minimum = Integer.MAX_VALUE;
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        dfs(root, 1);
        return minimum;
    }
    public void dfs(TreeNode root, int depth) {
        if (root.left == null && root.right == null) {
            minimum = Math.min(minimum, depth);
            return;
        }
        if (root.left != null) {
            dfs(root.left, depth + 1);
        }
        if (root.right != null) {
            dfs(root.right, depth + 1);
        }
    }
}

 思路II：Divide Conquer。注意当当前节点的左右子节点有一个为null的情况，这个时候深度的计算有所不同。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = minDepth(root.left);
        int right = minDepth(root.right);
        if (left == 0 || right == 0) {
            return 1 + left + right;
        } else {
            return 1 + Math.min(left, right);
        }
    }
}

542. 01 Matrix

Given a matrix consists of 0 and 1, find the distance of the nearest 0 for each cell.

The distance between two adjacent cells is 1.
Example 1: 
Input:

0 0 0
0 1 0
0 0 0
Output:
0 0 0
0 1 0
0 0 0
Example 2: 
Input:

0 0 0
0 1 0
1 1 1
Output:
0 0 0
0 1 0
1 2 1
Note:
The number of elements of the given matrix will not exceed 10,000.
There are at least one 0 in the given matrix.
The cells are adjacent in only four directions: up, down, left and right.

思路：BFS。相当于从0开始一层层往里面遍历，下一个节点的距离最近0的距离就是当前节点的距离+1。这道题BFS分层不分层都可以。时间复杂度O(nm),空间复杂度O(nm)，n为行数，m为列数。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    public int[][] updateMatrix(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return matrix;
        }
        int n = matrix.length;
        int m = matrix[0].length;
        Queue<Node> queue = new LinkedList<>();
        boolean[][] visited = new boolean[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (matrix[i][j] == 0) {
                    queue.offer(new Node(i, j));
                    visited[i][j] = true;
                }
            }
        }
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        while (!queue.isEmpty()) {
            // 这道题分层不分层都可以
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                Node cur = queue.poll();
                for (int j = 0; j < 4; j++) {
                    int next_x = cur.x + dx[j];
                    int next_y = cur.y + dy[j];
                    if (next_x >= 0 && next_x < n && next_y >= 0 && next_y < m 
                        && !visited[next_x][next_y]) {
                        queue.offer(new Node(next_x, next_y));
                        matrix[next_x][next_y] = matrix[cur.x][cur.y] + 1;
                        visited[next_x][next_y] = true;
                    }
                }
            }
        }
        return matrix;
    }
}

317. Shortest Distance from All Buildings

You want to build a house on an empty land which reaches all buildings in the shortest amount of distance. You can only move up, down, left and right. You are given a 2D grid of values 0, 1 or 2, where:

Each 0 marks an empty land which you can pass by freely.
Each 1 marks a building which you cannot pass through.
Each 2 marks an obstacle which you cannot pass through.
For example, given three buildings at (0,0), (0,4), (2,2), and an obstacle at (0,2):

1 - 0 - 2 - 0 - 1
|   |   |   |   |
0 - 0 - 0 - 0 - 0
|   |   |   |   |
0 - 0 - 1 - 0 - 0
The point (1,2) is an ideal empty land to build a house, as the total travel distance of 3+3+1=7 is minimal. So return 7.

Note:
There will be at least one building. If it is not possible to build such house according to the above rules, return -1.

思路：BFS。对每一个1开始进行分层BFS，所得的到每一个值为0的点的距离累加，到值为0的1的个数累加。BFS结束后，得到两个二维矩阵，distance[i][j]表示该位置到所有能到达的建筑物的距离之和，reach[i][j]表示该位置能够到达的建筑物的个数，只有当reach[i][j]==建筑物总数时，distance[i][j]才能表示该位置到达所有建筑物的距离之和，用这个值更新全局最短距离shortest。时间复杂度O(n^2*m^2)，空间复杂度O(nm)，n为行数，m为列数。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    int n;
    int m;
    public int shortestDistance(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        n = grid.length;
        m = grid[0].length;
        int buildings = 0;
        Queue<Node> queue = new LinkedList<>();
        int[][] distance = new int[n][m];
        int[][] reach = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) {
                    buildings++;
                    boolean[][] visited = new boolean[n][m];
                    bfs(grid, i, j, queue, visited, distance, reach);
                }
            }
        }
        int shortest = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 0) {
                    if (reach[i][j] == buildings && distance[i][j] < shortest) {
                        shortest = distance[i][j];
                    }
                }
            }
        }
        if (shortest == Integer.MAX_VALUE) {
            return -1;
        }
        return shortest;
    }
    public void bfs(int[][] grid, int x, int y, Queue<Node> queue, boolean[][] visited,
                    int[][] distance, int[][] reach) {
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        queue.offer(new Node(x, y));
        visited[x][y] = true;
        int steps = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                Node cur = queue.poll();
                for (int j = 0; j < 4; j++) {
                    int next_x = cur.x + dx[j];
                    int next_y = cur.y + dy[j];
                    if (next_x >= 0 && next_x < n && next_y >= 0 && next_y < m
                        && !visited[next_x][next_y] && grid[next_x][next_y] == 0) {
                        distance[next_x][next_y] += steps;
                        reach[next_x][next_y]++;
                        queue.offer(new Node(next_x, next_y));
                        visited[next_x][next_y] = true;
                    }
                }
            }
            steps++;
        }
    }
}

207. Course Schedule

There are a total of n courses you have to take, labeled from 0 to n - 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

For example:

2, [[1,0]]
There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

2, [[1,0],[0,1]]
There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
You may assume that there are no duplicate edges in the input prerequisites.

思路：拓扑排序。建立一个inDegree数组存储每个节点的度数，建立一个edges数组存储每个节点的邻居节点。最后判断统计的度为0的节点个数是否为n。时间复杂度O(n)，空间复杂度O(n^2)，n为节点个数。

public class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        if (numCourses < 1) {
            return true;
        }
        int[] inDegree = new int[numCourses];
        List[] edges = new ArrayList[numCourses];
        for (int i = 0; i < numCourses; i++) {
            edges[i] = new ArrayList<Integer>();
        }
        for (int i = 0; i < prerequisites.length; i++) {
            inDegree[prerequisites[i][0]]++;
            edges[prerequisites[i][1]].add(prerequisites[i][0]);
        }
        Queue<Integer> queue = new LinkedList<>();
        int count = 0;
        for (int i = 0; i < numCourses; i++) {
            if (inDegree[i] == 0) {
                queue.offer(i);
                count++;
            }
        }
        while (!queue.isEmpty()) {
            int num = queue.poll();
            int size = edges[num].size();
            for (int i = 0; i < size; i++) {
                int neighbor = (int) edges[num].get(i);
                inDegree[neighbor]--;
                if (inDegree[neighbor] == 0) {
                    queue.offer(neighbor);
                    count++;
                }
            }
        }
        return count == numCourses;
    }
}

210. Course Schedule II

There are a total of n courses you have to take, labeled from 0 to n - 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, return the ordering of courses you should take to finish all courses.

There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.

For example:

2, [[1,0]]
There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1]

4, [[1,0],[2,0],[3,1],[3,2]]
There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].

Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
You may assume that there are no duplicate edges in the input prerequisites.

思路：与I类似，在BFS过程中就记录访问入度为0的节点的顺序。

310. Minimum Height Trees

For a undirected graph with tree characteristics, we can choose any node as the root. The result graph is then a rooted tree. Among all possible rooted trees, those with minimum height are called minimum height trees (MHTs). Given such a graph, write a function to find all the MHTs and return a list of their root labels.

Format
The graph contains n nodes which are labeled from 0 to n - 1. You will be given the number n and a list of undirected edges (each edge is a pair of labels).

You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.

Example 1:

Given n = 4, edges = [[1, 0], [1, 2], [1, 3]]

        0
        |
        1
       / 
      2   3
return [1]

Example 2:

Given n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]

     0  1  2
       | /
        3
        |
        4
        |
        5
return [3, 4]

Note:

(1) According to the definition of tree on Wikipedia: “a tree is an undirected graph in which any two vertices are connected by exactly one path. In other words, any connected graph without simple cycles is a tree.”

(2) The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.

思路：从度为1的叶节点(用一个degree数组记录每个节点的度数)开始，BFS遍历，不需要visited数组标记，当节点的度为0时continue掉即可，最后一次加入到队列中的叶节点即为所求。注意这道题的corner case：只有一个节点，此时结果集是[0]而不是[]，切记！时间复杂度O(n)，空间复杂度O(n)，n为节点个数。

public class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> result = new ArrayList<>();
        if (n < 1 || edges.length != n - 1) {
            return result;
        }
        if (n == 1) {
            result.add(0);
            return result;
        }
        Map<Integer, Set<Integer>> graph = initializeGraph(n, edges);
        int[] degree = new int[n];
        for (int i = 0; i < edges.length; i++) {
            degree[edges[i][0]]++;
            degree[edges[i][1]]++;
        }
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            if (degree[i] == 0) {
                return result;
            }
            if (degree[i] == 1) {
                queue.offer(i);
            }
        }
        while (!queue.isEmpty()) {
            result = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int num = queue.poll();
                result.add(num);
                degree[num]--;
                for (int neighbor : graph.get(num)) {
                    if (degree[neighbor] == 0) {
                        continue;
                    }
                    degree[neighbor]--;
                    if (degree[neighbor] == 1) {
                        queue.add(neighbor);
                    }
                }
            }
        }
        return result;
    }
    public Map<Integer, Set<Integer>> initializeGraph(int n, int[][] edges) {
        Map<Integer, Set<Integer>> graph = new HashMap<>();
        for (int i = 0; i < n; i++) {
            graph.put(i, new HashSet<Integer>());
        }
        for (int i = 0; i < edges.length; i++) {
            graph.get(edges[i][0]).add(edges[i][1]);
            graph.get(edges[i][1]).add(edges[i][0]);
        }
        return graph;
    }
}

133. Clone Graph

Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.


OJ's undirected graph serialization:
Nodes are labeled uniquely.

We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.
As an example, consider the serialized graph {0,1,2#1,2#2,2}.

The graph has a total of three nodes, and therefore contains three parts as separated by #.

First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
Second node is labeled as 1. Connect node 1 to node 2.
Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.
Visually, the graph looks like the following:

       1
      / 
     /   
    0 --- 2
         / 
         \_/

思路：两步。1. 复制节点 2. 复制边，这个过程一定要注意当前节点的邻居节点是新的邻居节点而不是老的邻居节点，否则邻居节点就是老的邻居节点的引用，这里很容易犯错误。  预先要BFS得出老节点，这样才能操作1和2。时间复杂度O(n)，空间复杂度O(n)，n为节点个数。

/**
 * Definition for undirected graph.
 * class UndirectedGraphNode {
 *     int label;
 *     List<UndirectedGraphNode> neighbors;
 *     UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
 * };
 */
public class Solution {
    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        if (node == null) {
            return null;
        }
        Map<UndirectedGraphNode, UndirectedGraphNode> map = new HashMap<>();
        Set<UndirectedGraphNode> nodes = getNodes(node);
        // copy node
        for (UndirectedGraphNode n : nodes) {
            map.put(n, new UndirectedGraphNode(n.label));
        }
        // copy neighbor
        for (UndirectedGraphNode n : nodes) {
            UndirectedGraphNode newNode = map.get(n);
            for (UndirectedGraphNode neighbor : n.neighbors) {
                UndirectedGraphNode newNeighbor = map.get(neighbor);
                newNode.neighbors.add(newNeighbor);
            }
        }
        return map.get(node);
    }
    public Set<UndirectedGraphNode> getNodes(UndirectedGraphNode node) {
        Set<UndirectedGraphNode> set = new HashSet<>();
        Queue<UndirectedGraphNode> queue = new LinkedList<>();
        queue.offer(node);
        set.add(node);
        while (!queue.isEmpty()) {
            UndirectedGraphNode cur = queue.poll();
            for (UndirectedGraphNode neighbor : cur.neighbors) {
                if (set.contains(neighbor)) {
                    continue;
                }
                queue.offer(neighbor);
                set.add(neighbor);
            }
        }
        return set;
    }
}

130. Surrounded Regions

Given a 2D board containing 'X' and 'O' (the letter O), capture all regions surrounded by 'X'.

A region is captured by flipping all 'O's into 'X's in that surrounded region.

For example,
X X X X
X O O X
X X O X
X O X X
After running your function, the board should be:

X X X X
X X X X
X X X X
X O X X

思路I：BFS。一次AC，时间复杂度O(nm)，空间复杂度O(nm)。从二维矩阵四周的'O'开始BFS遍历，将遍历到的'O'设置为'Y'。最后遍历一遍二维矩阵，将'O'设置成'X'，表示这些'O'是被捕捉到的；将'Y'设置回'O'，表示这些'O'没有捕捉到，恢复。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    public void solve(char[][] board) {
        if (board == null || board.length == 0 || board[0].length == 0) {
            return;
        }
        int n = board.length;
        int m = board[0].length;
        Queue<Node> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            if (board[i][0] == 'O') {
                queue.offer(new Node(i, 0));
                board[i][0] = 'Y';
            }
            if (board[i][m - 1] == 'O') {
                queue.offer(new Node(i, m - 1));
                board[i][m - 1] = 'Y';
            }
        }
        for (int i = 1; i < m - 1; i++) {
            if (board[0][i] == 'O') {
                queue.offer(new Node(0, i));
                board[0][i] = 'Y';
            }
            if (board[n - 1][i] == 'O') {
                queue.offer(new Node(n - 1, i));
                board[n - 1][i] = 'Y';
            }
        }
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            for (int i = 0; i < 4; i++) {
                int next_x = cur.x + dx[i];
                int next_y = cur.y + dy[i];
                if (next_x >= 0 && next_x < n && next_y >= 0 && next_y < m && board[next_x][next_y] == 'O') {
                    queue.offer(new Node(next_x, next_y));
                    board[next_x][next_y] = 'Y';
                }
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                } else if (board[i][j] == 'Y') {
                    board[i][j] = 'O';
                }
            }
        }
    }
}

 思路II：并查集。并查集 建立一个n * m的dummy node，遍历二维数组，边上的为字符O的直接合并到dummy node, 在里面的字符为O的根据情况合并，如果该字符与相邻字符O的parent一样就不合并，如果不一样分两种情况，如果该字符的parent为dummy node就将相邻字符O合并到该字符的parent，否则将该字符的parent合并到相邻字符O的parent。最后再遍历一次二维数组，字符为O并且该字符的parent不是dummy node就将该字符置为字符X。也就是说，不能被包围的字符O的parent都是dummy node，能被包围的字符O的parent都不是dummy node。时间复杂度O(nm)，空间复杂度O(nm)。

127. Word Ladder 

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

Only one letter can be changed at a time.
Each transformed word must exist in the word list. Note that beginWord is not a transformed word.
For example,

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log","cog"]
As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Note:
Return 0 if there is no such transformation sequence.
All words have the same length.
All words contain only lowercase alphabetic characters.
You may assume no duplicates in the word list.
You may assume beginWord and endWord are non-empty and are not the same.
UPDATE (2017/1/20):
The wordList parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

思路：bfs，注意获取下一个单词的方法的写法，是遍历单词的每一个位置，然后对每一个位置用'a' - 'z'替换（当然不能等于该位置上的字符），然后组装成新的串，再看这个串是否在单词集合中。

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if (beginWord.equals(endWord)) {
            return 1;
        }
        Set<String> set = new HashSet<>();
        for (String s : wordList) {
            set.add(s);
        }
        Queue<String> queue = new LinkedList<>();
        Set<String> visited = new HashSet<>();
        queue.offer(beginWord);
        visited.add(beginWord);
        int length = 0;
        while (!queue.isEmpty()) {
            length++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String word = queue.poll();
                if (word.equals(endWord)) {
                    return length;
                }
                List<String> nextWords = getNextWords(set, word);
                for (String nextWord : nextWords) {
                    if (visited.contains(nextWord)) {
                        continue;
                    }
                    queue.offer(nextWord);
                    visited.add(nextWord);
                }
            }
        }
        return 0;
    }
    private List<String> getNextWords(Set<String> set, String word) {
        List<String> result = new ArrayList<>();
        for (int i = 0; i < word.length(); i++) {
            for (char c = 'a'; c <= 'z'; c++) {
                if (c == word.charAt(i)) {
                    continue;
                }
                char[] chars = word.toCharArray();
                chars[i] = c;
                String nextWord = new String(chars);
                if (set.contains(nextWord)) {
                    result.add(nextWord);
                }
            }
        }
        return result;
    }
}

126. Word Ladder II

Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) from beginWord to endWord, such that:

Only one letter can be changed at a time
Each transformed word must exist in the word list. Note that beginWord is not a transformed word.
For example,

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log","cog"]
Return
  [
    ["hit","hot","dot","dog","cog"],
    ["hit","hot","lot","log","cog"]
  ]
Note:
Return an empty list if there is no such transformation sequence.
All words have the same length.
All words contain only lowercase alphabetic characters.
You may assume no duplicates in the word list.
You may assume beginWord and endWord are non-empty and are not the same.
UPDATE (2017/1/20):
The wordList parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

思路：BFS+DFS。首先BFS求出当前节点离起始节点的距离，然后从起始节点开始DFS求出起点到终点的所有最短路径上的单词序列。注意：血的教训！！！题目给定的单词集合不管是List还是Set，统统转化成Set，因为后面求当前节点单词在的下一个出现在单词集合中的单词时，会出现判断新单词是否在单词集合中，也就是会调用contains方法！！！而List的contains方法不是O(1)时间复杂度，所以要用Set作为单词集合！！！

无优化：

public class Solution {
    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        List<List<String>> result = new ArrayList<>();
        if (beginWord.equals(endWord)) {
            List<String> tempList = new ArrayList<>();
            tempList.add(beginWord);
            result.add(tempList);
            return result;
        }
        Set<String> dict = new HashSet<>(wordList);
        dict.add(beginWord);
        Map<String, Integer> distance = new HashMap<>();
        bfs(dict, beginWord, distance);
        dfs(dict, beginWord, endWord, distance, new ArrayList<String>(), result);
        return result;
    }
    public void bfs(Set<String> dict,
                    String beginWord,
                    Map<String, Integer> distance) {
        
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);
        distance.put(beginWord, 0);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String word = queue.poll();
                List<String> nextWords = getNextWords(word, dict);
                for (String nextWord : nextWords) {
                    if (!distance.containsKey(nextWord)) {
                        queue.offer(nextWord);
                        distance.put(nextWord, distance.get(word) + 1);
                    }
                }
            }
        }
    }
    public void dfs(Set<String> dict,
                    String word,
                    String endWord,
                    Map<String, Integer> distance,
                    List<String> path,
                    List<List<String>> result) {
        path.add(word);
        if (word.equals(endWord)) {
            result.add(new ArrayList<String>(path));
        } else {
            List<String> nextWords = getNextWords(word, dict);
            for (String nextWord : nextWords) {
                if (distance.get(nextWord) == distance.get(word) + 1) {
                    dfs(dict, nextWord, endWord, distance, path, result);
                }
            }
        }
        path.remove(path.size() - 1);
    }
    public List<String> getNextWords(String word, Set<String> dict) {
        List<String> nextWords = new ArrayList<>();
        char[] wordArray = word.toCharArray();
        for (int i = 0; i < wordArray.length; i++) {
            for (char c = 'a'; c <= 'z'; c++) {
                if (wordArray[i] != c) {
                    char temp = wordArray[i];
                    wordArray[i] = c;
                    String nextWord = new String(wordArray);
                    if (dict.contains(nextWord)) {
                        nextWords.add(nextWord);
                    }
                    wordArray[i] = temp;
                }
            }
        }
        return nextWords;
    }
}

优化I：bfs过程将每个单词的下一个单词集合记录下来，在dfs中使用的时候就不用重复求。

public class Solution {
    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        List<List<String>> result = new ArrayList<>();
        if (beginWord.equals(endWord)) {
            List<String> tempList = new ArrayList<>();
            tempList.add(beginWord);
            result.add(tempList);
            return result;
        }
        Set<String> dict = new HashSet<>(wordList);
        dict.add(beginWord);
        Map<String, Integer> distance = new HashMap<>();
        Map<String, List<String>> nodeNeighbors = new HashMap<>();
        bfs(dict, beginWord, nodeNeighbors, distance);
        dfs(dict, beginWord, endWord, nodeNeighbors, distance, new ArrayList<String>(), result);
        return result;
    }
    public void bfs(Set<String> dict,
                    String beginWord,
                    Map<String, List<String>> nodeNeighbors,
                    Map<String, Integer> distance) {
        
        for (String word : dict) {
            nodeNeighbors.put(word, new ArrayList<String>());
        }
        
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);
        distance.put(beginWord, 0);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String word = queue.poll();
                List<String> nextWords = getNextWords(word, dict);
                for (String nextWord : nextWords) {
                    nodeNeighbors.get(word).add(nextWord);
                    if (!distance.containsKey(nextWord)) {
                        queue.offer(nextWord);
                        distance.put(nextWord, distance.get(word) + 1);
                    }
                }
            }
        }
    }
    public void dfs(Set<String> dict,
                    String word,
                    String endWord,
                    Map<String, List<String>> nodeNeighbors,
                    Map<String, Integer> distance,
                    List<String> path,
                    List<List<String>> result) {
        path.add(word);
        if (word.equals(endWord)) {
            result.add(new ArrayList<String>(path));
        } else {
            for (String nextWord : nodeNeighbors.get(word)) {
                if (distance.get(nextWord) == distance.get(word) + 1) {
                    dfs(dict, nextWord, endWord, nodeNeighbors, distance, path, result);
                }
            }
        }
        path.remove(path.size() - 1);
    }
    public List<String> getNextWords(String word, Set<String> dict) {
        List<String> nextWords = new ArrayList<>();
        char[] wordArray = word.toCharArray();
        for (int i = 0; i < wordArray.length; i++) {
            for (char c = 'a'; c <= 'z'; c++) {
                if (wordArray[i] != c) {
                    char temp = wordArray[i];
                    wordArray[i] = c;
                    String nextWord = new String(wordArray);
                    if (dict.contains(nextWord)) {
                        nextWords.add(nextWord);
                    }
                    wordArray[i] = temp;
                }
            }
        }
        return nextWords;
    }
}

优化II：在I的基础上，bfs过程设置一个foundEnd标记，代表是否遍历到了末尾单词。bfs过程只需遍历到末尾单词即可，因为我们只关心从起点到终点的路径。

public class Solution {
    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        List<List<String>> result = new ArrayList<>();
        if (beginWord.equals(endWord)) {
            List<String> tempList = new ArrayList<>();
            tempList.add(beginWord);
            result.add(tempList);
            return result;
        }
        Set<String> dict = new HashSet<>(wordList);
        dict.add(beginWord);
        Map<String, Integer> distance = new HashMap<>();
        Map<String, List<String>> nodeNeighbors = new HashMap<>();
        bfs(dict, beginWord, endWord, nodeNeighbors, distance);
        dfs(dict, beginWord, endWord, nodeNeighbors, distance, new ArrayList<String>(), result);
        return result;
    }
    public void bfs(Set<String> dict,
                    String beginWord,
                    String endWord,
                    Map<String, List<String>> nodeNeighbors,
                    Map<String, Integer> distance) {
        
        for (String word : dict) {
            nodeNeighbors.put(word, new ArrayList<String>());
        }
        
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);
        distance.put(beginWord, 0);
        while (!queue.isEmpty()) {
            boolean foundEnd = false;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String word = queue.poll();
                List<String> nextWords = getNextWords(word, dict);
                for (String nextWord : nextWords) {
                    nodeNeighbors.get(word).add(nextWord);
                    if (!distance.containsKey(nextWord)) {
                        if (nextWord.equals(endWord)) {
                            foundEnd = true;
                        } else {
                            queue.offer(nextWord);   
                        }
                        distance.put(nextWord, distance.get(word) + 1);
                    }
                }
            }
            if (foundEnd) {
                break;
            }
        }
    }
    public void dfs(Set<String> dict,
                    String word,
                    String endWord,
                    Map<String, List<String>> nodeNeighbors,
                    Map<String, Integer> distance,
                    List<String> path,
                    List<List<String>> result) {
        path.add(word);
        if (word.equals(endWord)) {
            result.add(new ArrayList<String>(path));
        } else {
            for (String nextWord : nodeNeighbors.get(word)) {
                if (distance.get(nextWord) == distance.get(word) + 1) {
                    dfs(dict, nextWord, endWord, nodeNeighbors, distance, path, result);
                }
            }
        }
        path.remove(path.size() - 1);
    }
    public List<String> getNextWords(String word, Set<String> dict) {
        List<String> nextWords = new ArrayList<>();
        char[] wordArray = word.toCharArray();
        for (int i = 0; i < wordArray.length; i++) {
            for (char c = 'a'; c <= 'z'; c++) {
                if (wordArray[i] != c) {
                    char temp = wordArray[i];
                    wordArray[i] = c;
                    String nextWord = new String(wordArray);
                    if (dict.contains(nextWord)) {
                        nextWords.add(nextWord);
                    }
                    wordArray[i] = temp;
                }
            }
        }
        return nextWords;
    }
}

339. Nested List Weight Sum

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.

Example 1:
Given the list [[1,1],2,[1,1]], return 10. (four 1's at depth 2, one 2 at depth 1)

Example 2:
Given the list [1,[4,[6]]], return 27. (one 1 at depth 1, one 4 at depth 2, and one 6 at depth 3; 1 + 4*2 + 6*3 = 27)

思路：DFS。递归过程中分两种情况：1. 是Integer，那么就叠加进结果中。2. 是List，那么就递归，深度+1. 

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * public interface NestedInteger {
 *
 *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
 *     public boolean isInteger();
 *
 *     // @return the single integer that this NestedInteger holds, if it holds a single integer
 *     // Return null if this NestedInteger holds a nested list
 *     public Integer getInteger();
 *
 *     // @return the nested list that this NestedInteger holds, if it holds a nested list
 *     // Return null if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
public class Solution {
    private int sum = 0;
    public int depthSum(List<NestedInteger> nestedList) {
        dfs(nestedList, 1);
        return sum;
    }
    public void dfs(List<NestedInteger> nestedList, int depth) {
        for (NestedInteger nest : nestedList) {
            if (nest.isInteger()) {
                sum += depth * nest.getInteger();
            } else {
                dfs(nest.getList(), depth + 1);
            }
        }
    }
}

366. Find Leaves of Binary Tree

Given a binary tree, collect a tree's nodes as if you were doing this: Collect and remove all leaves, repeat until the tree is empty.

Example:
Given binary tree 
          1
         / 
        2   3
       /      
      4   5    
Returns [4, 5, 3], [2], [1].

Explanation:
1. Removing the leaves [4, 5, 3] would result in this tree:

          1
         / 
        2          
2. Now removing the leaf [2] would result in this tree:

          1          
3. Now removing the leaf [1] would result in the empty tree:

          []         
Returns [4, 5, 3], [2], [1].

思路I：DFS，模拟操作即可。每一次的DFS存储当前tree的叶节点，然后将叶节点的父亲节点与该叶节点的指针关系移除，这个过程需要记录当前节点的父亲节点以及父亲节点与当前节点的左右儿子关系，用boolean left来表示，为true表示的是左儿子，否则是右儿子。基于这个过程，需要预处理：建立一个dummy代表根节点root的父亲节点，并且明确左右儿子关系，比如dummy.left = root。注意！！！：循环结束的条件是dummy.left != null 而不是root != null，因为root始终不为null，要根据指向关系来判断。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> findLeaves(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        TreeNode dummy = new TreeNode(0);
        dummy.left = root;
        while (dummy.left != null) {
            List<Integer> leaves = new ArrayList<>();
            dfs(root, dummy, leaves, true);
            result.add(leaves);
        }
        return result;
    }
    public void dfs(TreeNode cur, TreeNode father, List<Integer> leaves, boolean left) {
        if (cur.left == null && cur.right == null) {
            if (left) {
                father.left = null;
            } else {
                father.right = null;
            }
            leaves.add(cur.val);
            return;
        }
        if (cur.left != null) {
            dfs(cur.left, cur, leaves, true);
        }
        if (cur.right != null) {
            dfs(cur.right, cur, leaves, false);
        }
    }
}

思路II：BFS + 拓扑排序。BFS分层，先入出度为0的节点，对于当前节点，只要不是根节点root，就将该节点的父节点的出度减1，若出度为0，就入列。基于这个过程，需要两个Map，一个存储节点与该节点的度数的映射，另一个节点存储该节点的父亲节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> findLeaves(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Map<TreeNode, Integer> outDegree = new HashMap<>();
        Map<TreeNode, TreeNode> father = new HashMap<>();
        load(root, outDegree, father);
        Queue<TreeNode> queue = new LinkedList<>();
        for (TreeNode node : outDegree.keySet()) {
            if (outDegree.get(node) == 0) {
                queue.offer(node);
            }
        }
        while (!queue.isEmpty()) {
            List<Integer> leaves = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode cur = queue.poll();
                leaves.add(cur.val);
                if (cur != root) {
                    TreeNode pre = father.get(cur);
                    outDegree.put(pre, outDegree.get(pre) - 1);
                    if (outDegree.get(pre) == 0) {
                        queue.offer(pre);
                    }
                }
            }
            result.add(leaves);
        }
        return result;
    }
    public void load(TreeNode root, Map<TreeNode, Integer> outDegree, Map<TreeNode, TreeNode> father) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null) {
            outDegree.put(root, 0);
            return;
        }
        int degree = 0;
        if (root.left != null) {
            degree++;
            father.put(root.left, root);
        }
        if (root.right != null) {
            degree++;
            father.put(root.right, root);
        }
        outDegree.put(root, degree);
        load(root.left, outDegree, father);
        load(root.right, outDegree, father);
    }
}

617. Merge Two Binary Trees

Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not.

You need to merge them into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of new tree.

Example 1:
Input: 
    Tree 1                     Tree 2                  
          1                         2                             
         /                        /                             
        3   2                     1   3                        
       /                                                    
      5                             4   7                  
Output: 
Merged tree:
         3
        / 
       4   5
      /     
     5   4   7
Note: The merging process must start from the root nodes of both trees.

思路：DFS，只要有一边为null，返回另一边，不需要再往下。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        TreeNode root = null;
        if (t1 != null && t2 != null) {
            root = new TreeNode(t1.val + t2.val);
            root.left = mergeTrees(t1.left, t2.left);
            root.right = mergeTrees(t1.right, t2.right);
        } else if (t1 != null) {
            return t1;
        } else {
            return t2;
        }
        return root;
    }
}

538. Convert BST to Greater Tree

Given a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus sum of all keys greater than the original key in BST.

Example:

Input: The root of a Binary Search Tree like this:
              5
            /   
           2     13

Output: The root of a Greater Tree like this:
             18
            /   
          20     13

思路：逆向中序遍历，即按节点值从大到小遍历节点，递归过程中记录遍历过的所有节点的和。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private int sum = 0;
    public TreeNode convertBST(TreeNode root) {
        dfs(root);
        return root;
    }
    public void dfs(TreeNode root) {
        if (root == null) {
            return;
        }
        dfs(root.right);
        root.val += sum;
        sum = root.val;
        dfs(root.left);
    }
}

HashTable专题

1. Two Sum

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:
Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

思路I：建议节点类，存储数组元素的索引和索引对应的值。然后按照双指针的做法(要排序)写就可以了。时间复杂度O(nlgn)，空间复杂度O(n)。

class Node {
    int index;
    int value;
    public Node(int index, int value) {
        this.index = index;
        this.value = value;
    }
}
public class Solution {
    public int[] twoSum(int[] nums, int target) {
        if (nums == null || nums.length <= 1) {
            return new int[0];
        }
        Node[] nodes = new Node[nums.length];
        for (int i = 0; i < nums.length; i++) {
            nodes[i] = new Node(i, nums[i]);
        }
        Arrays.sort(nodes, new Comparator<Node>() {
            public int compare(Node a, Node b) {
                return a.value - b.value;
            }
        });
        int start = 0;
        int end = nums.length - 1;
        while (start < end) {
            int sum = nodes[start].value + nodes[end].value;
            if (sum == target) {
                int index1 = nodes[start].index;
                int index2 = nodes[end].index;
                if (index1 <= index2) {
                    return new int[]{index1, index2};
                }
                return new int[]{index2, index1};
            } else if (sum < target) {
                start++;
            } else {
                end--;
            }
        }
        return new int[0];
    }
}

思路II：建立一个Map，存储target - nums[i]和i的映射关系。如果Map包含当前元素值，就找到了；如果不包含，就将target - nums[i]和i的映射放入到Map中。时间复杂度O(n)，空间复杂度O(n)。

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        if (nums == null || nums.length <= 1) {
            return new int[0];
        }
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                return new int[]{map.get(nums[i]), i};
            }
            map.put(target - nums[i], i);
        }
        return new int[0];
    }
}

136. Single Number

Given an array of integers, every element appears twice except for one. Find that single one.

Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

思路：利用异或^运算的性质：0 ^ a = a；a ^ a = 0。时间复杂度O(n)，空间复杂度O(n)。

public class Solution {
    public int singleNumber(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int result = 0;
        for (int i = 0; i < nums.length; i++) {
            result = result ^ nums[i];
        }
        return result;
    }
}

3. Longest Substring Without Repeating Characters

Given a string, find the length of the longest substring without repeating characters.

Examples:

Given "abcabcbb", the answer is "abc", which the length is 3.

Given "bbbbb", the answer is "b", with the length of 1.

Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

思路：Map存储非重复字符和其索引的映射，双指针i，j分别指向非重复子串的结束位置和开始位置，遍历i，如果当前字符不在Map中，更新Map，求子串长度来更新最大子串长度；如果当前字符在Map中，更新j的位置( max(j, map.get(c) + 1) )，更新Map，求子串长度来更新最大子串长度。时间复杂度O(n)，空间复杂度O(n)。

public class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        while (n != 1) {
            if (set.contains(n)) {
                return false;
            }
            set.add(n);
            n = getNextHappyNumber(n);
        }
        return true;
    }
    public int getNextHappyNumber(int n) {
        int sum = 0;
        while (n != 0) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
}

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        Map<Character, Integer> map = new HashMap<>();
        int max = 0;
        for (int i = 0, j = 0; i < s.length(); i++) {
            if (map.containsKey(s.charAt(i))) {
                j = Math.max(j, map.get(s.charAt(i)) + 1);
            }
            map.put(s.charAt(i), i);
            max = Math.max(max, i - j + 1);
        }
        return max;
    }
}

217. Contains Duplicate

Given an array of integers, find if the array contains any duplicates. Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

思路：用Set判断即可。时间复杂度O(n)，空间复杂度O(n)。

public class Solution {
    public boolean containsDuplicate(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return false;
        }
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            if (set.contains(nums[i])) {
                return true;
            }
            set.add(nums[i]);
        }
        return false;
    }
}

202. Happy Number

Write an algorithm to determine if a number is "happy".

A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers.

Example: 19 is a happy number

12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

思路I：Set存储不重复的快乐数，一旦当前快乐数等于1，返回true。否则，如果当前快乐数载Set中出现，则死循环，返回false；如果没出现就加入到Set中。然后根据当前快乐数求的下一个快乐数再进行下一轮判断。

public class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        while (n != 1) {
            if (set.contains(n)) {
                return false;
            }
            set.add(n);
            n = getNextHappyNumber(n);
        }
        return true;
    }
    public int getNextHappyNumber(int n) {
        int sum = 0;
        while (n != 0) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
}

思路II：实际上就是判断链表有无环的问题，当有环的时候看环值是否为1。

public class Solution {
    public boolean isHappy(int n) {
        int slow = n;
        int fast = getNextHappyNumber(n);
        while (slow != fast) {
            slow = getNextHappyNumber(slow);
            fast = getNextHappyNumber(fast);
            fast = getNextHappyNumber(fast);
        }
        return slow == 1;
    }
    public int getNextHappyNumber(int n) {
        int sum = 0;
        while (n != 0) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
}

149. Max Points on a Line

Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.

思路：对于每一个固定的点，计算最多有多少个节点与该点在一条直线上。然后对每一个点都执行该操作，就可以求出在一条直线上的最多的点个数。注意点如下：1. 当前节点只需要和该节点没有检测过在一条直线上的点相比，不需要与检测过的点相比。 2. 用Map<Integer, Map<Integer>>存储斜率x， y， 和斜率为（x, y）的点的个数(不包含基准点本身)，只有这样斜率的比较才精确，求斜率(x, y)的过程中要注意化到最简，涉及到求最大公约数然后x和y均除以最大公约数，注意最大公约数的求解代码，辗转相除法。用double判断斜率是否相等不精确。3. 重复的基准点单独另外计数。时间复杂度O(n^2)，空间复杂度O(n^2)。

/**
 * Definition for a point.
 * class Point {
 *     int x;
 *     int y;
 *     Point() { x = 0; y = 0; }
 *     Point(int a, int b) { x = a; y = b; }
 * }
 */
public class Solution {
    public int maxPoints(Point[] points) {
        if (points == null || points.length == 0) {
            return 0;
        }
        if (points.length <= 2) {
            return points.length;
        }
        int result = 0;
        Map<Integer, Map<Integer, Integer>> map = new HashMap<>();
        for (int i = 0; i < points.length; i++) {
            map.clear();
            int local_max = 0;
            int overlaps = 0;
            for (int j = i + 1; j < points.length; j++) {
                int x = points[j].x - points[i].x;
                int y = points[j].y - points[i].y;
                if (x == 0 && y == 0) {
                    overlaps++;
                    continue;
                }
                int gcd = getGcd(x, y);
                x /= gcd;
                y /= gcd;
                if (map.containsKey(x)) {
                    if (map.get(x).containsKey(y)) {
                        map.get(x).put(y, map.get(x).get(y) + 1);
                    } else {
                        map.get(x).put(y, 1);
                    }
                } else {
                    Map<Integer, Integer> tempMap = new HashMap<>();
                    tempMap.put(y, 1);
                    map.put(x, tempMap);
                }
                local_max = Math.max(local_max, map.get(x).get(y));
            }
            result = Math.max(result, local_max + overlaps + 1);
        }
        return result;
    }
    public int getGcd(int x, int y) {
        if (y == 0) {
            return x;
        }
        return getGcd(y, x % y);
    }
}

242. Valid Anagram

Given two strings s and t, write a function to determine if t is an anagram of s.

For example,
s = "anagram", t = "nagaram", return true.
s = "rat", t = "car", return false.

Note:
You may assume the string contains only lowercase alphabets.

Follow up:
What if the inputs contain unicode characters? How would you adapt your solution to such case?

思路：用数组！不要用Map！我也不知道为啥用Map过不了，Map内部结构问题吧。时间复杂度O(len)，空间复杂度O(1)。

public class Solution {
    public boolean isAnagram(String s, String t) {
        if (s == null && t == null) {
            return true;
        }
        if (s == null || t == null) {
            return false;
        }
        if (s.length() != t.length()) {
            return false;
        }
        int[] count = new int[26];
        for (int i = 0; i < s.length(); i++) {
            count[s.charAt(i) - 'a']++;
            count[t.charAt(i) - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (count[i] != 0) {
                return false;
            }
        }
        return true;
    }
}

49. Group Anagrams

Given an array of strings, group anagrams together.

For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"], 
Return:

[
  ["ate", "eat","tea"],
  ["nat","tan"],
  ["bat"]
]
Note: All inputs will be in lower-case.

思路：比较巧妙，用一个Map存储基准String和该串对应的所有anagram的集合List<String>，这个基准串就是将当前串排按字母顺序排序，然后将当前串加入到该串的基准串所对应的集合中。时间复杂度O(n*len*lglen)，len为字符串平均长度。空间复杂度O(n)。

public class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> result = new ArrayList<>();
        if (strs == null || strs.length == 0) {
            return result;
        }
        Map<String, List<String>> map = new HashMap<>();
        for (int i = 0; i < strs.length; i++) {
            char[] chars = strs[i].toCharArray();
            Arrays.sort(chars);
            String key = String.valueOf(chars);
            if (!map.containsKey(key)) {
                map.put(key, new ArrayList<String>());
            }
            map.get(key).add(strs[i]);
        }
        for (String key : map.keySet()) {
            result.add(map.get(key));
        }
        return result;
    }
}

85. Maximal Rectangle

Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.

For example, given the following matrix:

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0
Return 6.

思路：二维最大矩阵问题用单调栈。时间复杂度O(nm)，空间复杂度O(nm)。

public class Solution {
    public int maximalRectangle(char[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        int n = matrix.length;
        int m = matrix[0].length;
        int[][] height = new int[n][m];
        for (int i = 0; i < m; i++) {
            height[0][i] = matrix[0][i] - '0';
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (matrix[i][j] == '0') {
                    height[i][j] = 0;
                } else {
                    height[i][j] = height[i - 1][j] + 1;
                }
            }
        }
        int max = 0;
        for (int i = 0; i < n; i++) {
            Stack<Integer> stack = new Stack<>();
            for (int j = 0; j <= m; j++) {
                int cur = j == m ? 0 : height[i][j];
                while (!stack.isEmpty() && cur <= height[i][stack.peek()]) {
                    int h = height[i][stack.pop()];
                    int w = stack.isEmpty() ? j : j - stack.peek() - 1;
                    max = Math.max(max, h * w);
                }
                stack.push(j);
            }
        }
        return max;
    }
}

DP专题

55. Jump Game

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Determine if you are able to reach the last index.

For example:
A = [2,3,1,1,4], return true.

A = [3,2,1,0,4], return false.

思路I：DP，最后一个testcase会超时，但要掌握。

public class Solution {
    public boolean canJump(int[] nums) {
        if (nums == null || nums.length == 0) {
            return false;
        }
        boolean[] f = new boolean[nums.length];
        f[0] = true;
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if (f[j] && j + nums[j] >= i) {
                    f[i] = true;
                    break;
                }
            }
        }
        return f[nums.length - 1];
    }
}

思路II：贪心。设置一个farthest代表最远能走多远，当当前位置i能到达（i <= farthest）并且i+nums[i] > farthest时就更新farthest。最后判断farthest >= nums.length - 1即可。

public class Solution {
    public boolean canJump(int[] nums) {
        if (nums == null || nums.length == 0) {
            return false;
        }
        int farthest = 0;
        for (int i = 0; i < nums.length; i++) {
            if (i <= farthest && i + nums[i] > farthest) {
                farthest = i + nums[i];
            }
        }
        return farthest >= nums.length - 1;
    }
}

322. Coin Change

You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.

Example 1:
coins = [1, 2, 5], amount = 11
return 3 (11 = 5 + 5 + 1)

Example 2:
coins = [2], amount = 3
return -1.

Note:
You may assume that you have an infinite number of each kind of coin.

思路：DP。按照DP的四个状态分析就好。

public class Solution {
    public int coinChange(int[] coins, int amount) {
        if (amount < 0 || coins == null || coins.length == 0) {
            return -1;
        }
        int[] f = new int[amount + 1];
        f[0] = 0;
        for (int i = 1; i <= amount; i++) {
            f[i] = Integer.MAX_VALUE;
            for (int j = 0; j < coins.length; j++) {
                if (i - coins[j] >= 0 && f[i - coins[j]] != Integer.MAX_VALUE && f[i - coins[j]] + 1 < f[i]) {
                    f[i] = f[i - coins[j]] + 1;
                }
            }
        }
        if (f[amount] == Integer.MAX_VALUE) {
            return -1;
        }
        return f[amount];
    }
}

62. Unique Paths

A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

How many possible unique paths are there?

思路：DP。滚动数组优化空间复杂度。

public class Solution {
    public int uniquePaths(int m, int n) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        int[][] dp = new int[2][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 || j == 0) {
                    dp[i % 2][j] = 1;
                } else {
                    dp[i % 2][j] = dp[(i - 1) % 2][j] + dp[i % 2][j - 1];
                }
            }
        }
        return dp[(m - 1) % 2][n - 1];
    }
}

138. Copy List with Random Pointer

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return a deep copy of the list.

思路：类似clone graph，先copy nodes，再copy pointers。时间复杂度O(n)，空间复杂度O(n)。

/**
 * Definition for singly-linked list with a random pointer.
 * class RandomListNode {
 *     int label;
 *     RandomListNode next, random;
 *     RandomListNode(int x) { this.label = x; }
 * };
 */
public class Solution {
    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null) {
            return null;
        }
        Map<RandomListNode, RandomListNode> map = new HashMap<>();
        RandomListNode cur = head;
        // copy node
        while (cur != null) {
            map.put(cur, new RandomListNode(cur.label));
            cur = cur.next;
        }
        cur = head;
        // copy pointers
        while (cur != null) {
            if (cur.next != null) {
                map.get(cur).next = map.get(cur.next);
            }
            if (cur.random != null) {
                map.get(cur).random = map.get(cur.random);
            }
            cur = cur.next;
        }
        return map.get(head);
    }
}

 思路：第一遍扫的时候巧妙运用next指针， 开始数组是1->2->3。 然后扫描过程中 先建立copy节点 1->1`->2->2`->3->3`, 然后第二遍copy的时候去建立边的copy， 拆分节点, 一边扫描一边拆成两个链。第一个链表变回 1->2->3 , 然后第二变成 1`->2`->3。时间复杂度O（n)，空间复杂度O(1)。

/**
 * Definition for singly-linked list with a random pointer.
 * class RandomListNode {
 *     int label;
 *     RandomListNode next, random;
 *     RandomListNode(int x) { this.label = x; }
 * };
 */
public class Solution {
    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null) {
            return null;
        }
        copyNext(head);
        copyRandom(head);
        return split(head);
    }
    public void copyNext(RandomListNode head) {
        while (head != null) {
            RandomListNode newNode = new RandomListNode(head.label);
            newNode.next = head.next;
            head.next = newNode;
            head = head.next.next;
        }
    }
    public void copyRandom(RandomListNode head) {
        while (head != null) {
            if (head.random != null) {
                head.next.random = head.random.next;
            }
            head = head.next.next;
        }
    }
    public RandomListNode split(RandomListNode head) {
        RandomListNode newHead = head.next;
        while (head != null) {
            RandomListNode cur = head.next;
            head.next = head.next.next;
            if (cur.next != null) {
                cur.next = cur.next.next;
            }
            head = head.next;
        }
        return newHead;
    }
}

217. Contains Duplicate

Given an array of integers, find if the array contains any duplicates. Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

思路：用Set判断重复元素。

public class Solution {
    public boolean containsDuplicate(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return false;
        }
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            if (!set.contains(nums[i])) {
                set.add(nums[i]);
            } else {
                return true;
            }
        }
        return false;
    }
}

219. Contains Duplicate II

Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.

思路：用Map存储元素 -> 索引的映射，来判断重复元素的索引的绝对距离是否小于等于k，如果是返回true，否则更新该重复元素的索引。

public class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k <= 0) {
            return false;
        }
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (!map.containsKey(nums[i])) {
                map.put(nums[i], i);
            } else {
                if (i - map.get(nums[i]) <= k) {
                    return true;
                } else {
                    map.put(nums[i], i);
                }
            }
        }
        return false;
    }
}

36. Valid Sudoku

Determine if a Sudoku is valid, according to: Sudoku Puzzles - The Rules.

The Sudoku board could be partially filled, where empty cells are filled with the character '.'.


A partially filled sudoku which is valid.

Note:
A valid Sudoku board (partially filled) is not necessarily solvable. Only the filled cells need to be validated.

思路：先检测行和列是否有重复元素，再检测每个3*3块是否有重复元素即可。时间复杂度O(n^2)，空间复杂度O(n)。

public class Solution {
    private int n;
    private int m;
    public boolean isValidSudoku(char[][] board) {
        if (board == null || board.length == 0 || board[0].length == 0) {
            return false;
        }
        n = board.length;
        m = board[0].length;
        if (n != m || n % 3 != 0) {
            return false;
        }
        for (int i = 0; i < n; i++) {
            if (detectLine(board, i, true)) {
                return false;
            } 
        }
        for (int i = 0; i < m; i++) {
            if (detectLine(board, i, false)) {
                return false;
            }
        }
        for (int i = 0; i < n; i += 3) {
            for (int j = 0; j < m; j += 3) {
                if (detectBlock(board, i, j)) {
                    return false;
                }
            }
        }
        return true;
    }
    public boolean detectLine(char[][] board, int x, boolean flag) {
        Set<Character> set = new HashSet<>();
        if (flag) {
            for (int i = 0; i < m; i++) {
                if (board[x][i] == '.') {
                    continue;
                }
                if (set.contains(board[x][i])) {
                    return true;
                } else {
                    set.add(board[x][i]);
                }
            }
        } else {
            for (int i = 0; i < n; i++) {
                if (board[i][x] == '.') {
                    continue;
                }
                if (set.contains(board[i][x])) {
                    return true;
                } else {
                    set.add(board[i][x]);
                }
            }
        }
        return false;
    }
    public boolean detectBlock(char[][] board, int x, int y) {
        Set<Character> set = new HashSet<>();
        for (int i = x; i < x + 3; i++) {
            for (int j = y; j < y + 3; j++) {
                if (board[i][j] == '.') {
                    continue;
                }
                if (set.contains(board[i][j])) {
                    return true;
                } else {
                    set.add(board[i][j]);
                }
            }
        }
        return false;
    }
}

187. Repeated DNA Sequences

All DNA is composed of a series of nucleotides abbreviated as A, C, G, and T, for example: "ACGAATTCCG". When studying DNA, it is sometimes useful to identify repeated sequences within the DNA.

Write a function to find all the 10-letter-long sequences (substrings) that occur more than once in a DNA molecule.

For example,

Given s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT",

Return:
["AAAAACCCCC", "CCCCCAAAAA"].

思路：形成所有长度为10的子串，加入到Set中，如果Set中包含子串，说明重复，就把该串加入到临时Set中，否则，加入该子串到Set。采用临时子串是为了处理如"AAAAAAAAAAAA"(长度为12)，当出现大于2个的重复子串出现时，如果用List就会将该子串重复加入到List中，而且用List的contains方法去重的话不是O（1）的时间复杂度，故用临时Set来存储，最后将临时Set中的元素复制到List中返回即可。时间复杂度O(len)，空间复杂度O(len)。

public class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        List<String> result = new ArrayList<>();
        if (s == null || s.length() < 10) {
            return result;
        }
        Set<String> set = new HashSet<>();
        Set<String> temp = new HashSet<>();
        for (int i = 0; i <= s.length() - 10; i++) {
            String str = s.substring(i, i + 10);
            if (!set.contains(str)) {
                set.add(str);
            } else {
                temp.add(str);
            }
        }
        return new ArrayList<>(temp);
    }
}

349. Intersection of Two Arrays

Given two arrays, write a function to compute their intersection.

Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].

Note:
Each element in the result must be unique.
The result can be in any order.

题意：求两个数组的不重复的公共元素

思路：对第一个数组，将其所有元素加入到第一个Set中去重，对于第二个数组的每个元素，如果第一个Set中含有这个元素，说明该元素是公共元素，将该公共元素加入到第二个Set中（公共元素去重），否则继续下一个元素的检测。时间复杂度O(len)，空间复杂度O(len)。

public class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }
        Set<Integer> set = new HashSet<>();
        Set<Integer> result = new HashSet<>();
        for (int num : nums1) {
            set.add(num);
        }
        for (int num : nums2) {
            if (set.contains(num)) {
                result.add(num);
            }
        }
        int[] array = new int[result.size()];
        int index = 0;
        for (int num : result) {
            array[index++] = num;
        }
        return array;
    }
}

336. Palindrome Pairs

Given a list of unique words, find all pairs of distinct indices (i, j) in the given list, so that the concatenation of the two words, i.e. words[i] + words[j] is a palindrome.

Example 1:
Given words = ["bat", "tab", "cat"]
Return [[0, 1], [1, 0]]
The palindromes are ["battab", "tabbat"]
Example 2:
Given words = ["abcd", "dcba", "lls", "s", "sssll"]
Return [[0, 1], [1, 0], [3, 2], [2, 4]]
The palindromes are ["dcbaabcd", "abcddcba", "slls", "llssssll"]

题意：求字符串数组中任意两个单词能组成回文串的所有索引对数。

思路：对于每个单词，从左到右遍历一遍，对于任意一个位置，如果它的左边是回文串且右边的逆序在字典中出现，那么就存在这么一种组合，同理，如果它的右边是回文串且左边的逆序在字典中出现，那么也存在这么一种组合。

　　　考虑空串如 ["a", ""]这种情况，j <= words[i].length，即j要取到words[i].length。为了去重，使用Set<List<Integer>>来存储结果，最后再复制给List<List<Integer>>。时间复杂度O(n*len*len)，len为字符串平均长度。

　　　 ["a", ""]    对于单词"a"　　""  "a"    add  (0, 1)    "a"  ""  add (1, 0)

　　　　　　　　 对于单词""　　   ""  ""      没有add

　　　["abcd", "dcba"]　　对于单词"abcd"的其中一种情况　　""  "abcd"    add  (1, 0)    "abcd"  ""  add (0, 1)

　　　　　　　　 　　　　对于单词"dcba"的其中一种情况　　""  "dcba"     add (0, 1)　  "dcba"  ""  add (1, 0)

public class Solution {
    public List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> result = new ArrayList<>();
        if (words == null || words.length <= 1) {
            return result;
        }
        Set<List<Integer>> set = new HashSet<>();
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < words.length; i++) {
            map.put(words[i], i);
        }
        for (int i = 0; i < words.length; i++) {
            for (int j = 0; j <= words[i].length(); j++) {
                String str1 = words[i].substring(0, j);
                String str2 = words[i].substring(j);
                if (isPalindrome(str1)) {
                    String str2_reverse = new StringBuilder(str2).reverse().toString();
                    if (map.containsKey(str2_reverse) && map.get(str2_reverse) != i) {
                        List<Integer> tempList = new ArrayList<>();
                        tempList.add(map.get(str2_reverse));
                        tempList.add(i);
                        set.add(tempList);
                    }
                }
                if (isPalindrome(str2)) {
                    String str1_reverse = new StringBuilder(str1).reverse().toString();
                    if (map.containsKey(str1_reverse) && map.get(str1_reverse) != i) {
                        List<Integer> tempList = new ArrayList<>();
                        tempList.add(i);
                        tempList.add(map.get(str1_reverse));
                        set.add(tempList);
                    }
                }
            }
        }
        return new ArrayList<List<Integer>>(set);
    }
    public boolean isPalindrome(String s) {
        int start = 0;
        int end = s.length() - 1;
        while (start < end) {
            if (s.charAt(start) != s.charAt(end)) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
}

347. Top K Frequent Elements

Given a non-empty array of integers, return the k most frequent elements.

For example,
Given [1,1,1,2,2,3] and k = 2, return [1,2].

Note: 
You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
Your algorithm's time complexity must be better than O(n log n), where n is the array's size.

题意：求前k高频的整数。

思路：这道题要求时间复杂度比O(nlgn)更快，就不能用堆来做。首先Map存储整数 -> 该整数出现的次数 的映射关系，然后用一个List数组将该Map映射翻转过来，索引为整数的次数，索引对应的List装该整数，这样就把出现次数相同的整数放到一个索引所对应的List中。最后从数组的最后往前遍历，将元素加入到结果集中，注意：只要结果集的size大于等于k就退出，返回结果集。时间复杂度O(n)，空间复杂度O(n)。

public class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        List<Integer> result = new ArrayList<>();
        if (nums == null || nums.length == 0 || k <= 0) {
            return result;
        }
        Map<Integer, Integer> frequency = new HashMap<>();
        List<Integer>[] bucket = new List[nums.length + 1];
        for (int num : nums) {
            if (!frequency.containsKey(num)) {
                frequency.put(num, 1);
            } else {
                frequency.put(num, frequency.get(num) + 1);
            }
        }
        for (int num : frequency.keySet()) {
            if (bucket[frequency.get(num)] == null) {
                bucket[frequency.get(num)] = new ArrayList<Integer>();
            }
            bucket[frequency.get(num)].add(num);
        }
        for (int i = nums.length; i >= 0 && result.size() < k; i--) {
            if (bucket[i] != null) {
                result.addAll(bucket[i]);
            }
        }
        return result;
    }
}

204. Count Primes

Description:

Count the number of prime numbers less than a non-negative number, n.

题意：求比n小的所有素数个数。

思路：素数：大于1的只能被1和自身整除的数。建一个长度为n的boolean数组，初始化均为false表示均为素数，然后从2开始统计素数个数，对于每一个素数i，将其整数倍(从i倍开始)的元素置为true，表示非素数，如果当前遍历的是非素数就跳过。注意i * j < n这句当n很大时i * j会溢出，所以比较的时候要提升至long型来比较，写成：（long) i * j < n。

public class Solution {
    public int countPrimes(int n) {
        if (n <= 1) {
            return 0;
        }
        boolean[] notPrime = new boolean[n];
        int count = 0;
        for (int i = 2; i < n; i++) {
            if (notPrime[i] == false) {
                count++;
                for (int j = i; (long) i * j < n; j++) {
                    notPrime[i * j] = true;
                }
            }
        }
        return count;
    }
}

205. Isomorphic Strings

Given two strings s and t, determine if they are isomorphic.

Two strings are isomorphic if the characters in s can be replaced to get t.

All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character but a character may map to itself.

For example,
Given "egg", "add", return true.

Given "foo", "bar", return false.

Given "paper", "title", return true.

Note:
You may assume both s and t have the same length.

题意：判断两个长度相同的字符串的模式是否相同

思路：两个字符串的每个字符的映射是一一映射。不存在多对一和一对多的情况。这道题的解法可以学到：Map中不仅有containsKey方法，还有containsValue方法。时间复杂度O(len)。空间复杂度O(len)。

public class Solution {
    public boolean isIsomorphic(String s, String t) {
        if (s == null && t == null) {
            return true;
        }
        if (s == null || t == null) {
            return false;
        }
        if (s.length() != t.length()) {
            return false;
        }
        Map<Character, Character> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char a = s.charAt(i);
            char b = t.charAt(i);
            if (!map.containsKey(a)) {
                if (!map.containsValue(b)) {
                    map.put(a, b);
                } else {
                    return false;
                }
            } else {
                if (map.get(a).equals(b)) {
                    continue;
                } else {
                    return false;
                }
            }
        }
        return true;
    }
   
}

299. Bulls and Cows

You are playing the following Bulls and Cows game with your friend: You write down a number and ask your friend to guess what the number is. Each time your friend makes a guess, you provide a hint that indicates how many digits in said guess match your secret number exactly in both digit and position (called "bulls") and how many digits match the secret number but locate in the wrong position (called "cows"). Your friend will use successive guesses and hints to eventually derive the secret number.

For example:

Secret number:  "1807"
Friend's guess: "7810"
Hint: 1 bull and 3 cows. (The bull is 8, the cows are 0, 1 and 7.)
Write a function to return a hint according to the secret number and friend's guess, use A to indicate the bulls and B to indicate the cows. In the above example, your function should return "1A3B".

Please note that both secret number and friend's guess may contain duplicate digits, for example:

Secret number:  "1123"
Friend's guess: "0111"
In this case, the 1st 1 in friend's guess is a bull, the 2nd or 3rd 1 is a cow, and your function should return "1A1B".
You may assume that the secret number and your friend's guess only contain digits, and their lengths are always equal.

思路：对于bulls直接看两个串的相同位置上的字符是否相同来统计，对于cows则用一个数组来统计字符出现的次数，细节见代码。时间复杂度O(n)，空间复杂度O(1)。

public class Solution {
    public String getHint(String secret, String guess) {
        if (secret == null || secret.length() == 0 || guess == null || guess.length() == 0) {
            return "";
        }
        int[] count = new int[10];
        int bulls = 0;
        int cows = 0;
        for (int i = 0; i < secret.length(); i++) {
            char s = secret.charAt(i);
            char g = guess.charAt(i);
            if (s == g) {
                bulls++;
            } else {
                if (count[s - '0'] < 0) {
                    cows++;
                }
                if (count[g - '0'] > 0) {
                    cows++;
                }
                count[s - '0']++;
                count[g - '0']--;
            }
        }
        return bulls + "A" + cows + "B";
    }
}

76. Minimum Window Substring

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,
S = "ADOBECODEBANC"
T = "ABC"
Minimum window is "BANC".

Note:
If there is no such window in S that covers all characters in T, return the empty string "".

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

题意：求s中的包含有t中所有字符的最小长度子串。

思路：建立两个hash，sourceHash和targetHash（长度均为256）分别存储s中子串的每个字符出现的次数和t中每个字符出现的次数。然后对于s中每一个开始的位置i，从该位置开始搜寻其后的一段子串使该子串满足包含t中所有字符，对所有的i都进行这样的操作，取满足条件的长度最小的子串即位结果。注意在遍历的过程中，位置j负责从i开始搜寻满足条件的子串，j指针一直往前走，不会回头，当前[i, j)子串满足条件后，下一次遍历，i往后挪一位，j从上次遍历的最后的位置开始继续向前走，因此时间复杂度为O(n)，空间复杂度O(1)。

public class Solution {
    public String minWindow(String s, String t) {
        if (s == null || s.length() == 0 || t == null || t.length() == 0) {
            return "";
        }
        int[] targetHash = init(t);
        int[] sourceHash = new int[256];
        int min_length = Integer.MAX_VALUE;
        String min_str = "";
        for (int i = 0, j = 0; i < s.length(); i++) {
            while (j < s.length() && !valid(sourceHash, targetHash)) {
                sourceHash[s.charAt(j)]++;
                j++;
            }
            if (valid(sourceHash, targetHash)) {
                if (j - i < min_length) {
                    min_length = j - i;
                    min_str = s.substring(i, j);
                }
            }
            sourceHash[s.charAt(i)]--;
        }
        return min_str;
    }
    public int[] init(String t) {
        int[] targetHash = new int[256];
        for (int i = 0; i < t.length(); i++) {
            targetHash[t.charAt(i)]++;
        }
        return targetHash;
    }
    public boolean valid(int[] sourceHash, int[] targetHash) {
        for (int i = 0; i < 256; i++) {
            if (sourceHash[i] < targetHash[i]) {
                return false;
            }
        }
        return true;
    }
}

166. Fraction to Recurring Decimal

Given two integers representing the numerator and denominator of a fraction, return the fraction in string format.

If the fractional part is repeating, enclose the repeating part in parentheses.

For example,

Given numerator = 1, denominator = 2, return "0.5".
Given numerator = 2, denominator = 1, return "2".
Given numerator = 2, denominator = 3, return "0.(6)".

思路：有很多细节需要处理。1. 符号 2. 去除符号之后需要取绝对值，这个过程可能溢出（Integer.MIN_VALUE取绝对值时会溢出），所以取绝对值的时候先强制转换为long型再取绝对值，然后分子和分母都变成long型来运算。整数部分很好处理，直接加入到StringBuilder中。小数部分的处理如下：用一个HashMap存储余数 --> 要开始做处罚运算的地方，也就是sb.length()。这样当当前运算出的余数在HashMap中的时候，说明是无限循环小数部分，就在HashMap中该余数对应的value值的地方插入"("，再在StringBuilder末尾加入")"。如果没出现在HashMap中就将键值对存入HashMap中，继续循环，直到为0退出。最后返回sb.toString()即为答案。

public class Solution {
    public String fractionToDecimal(int numerator, int denominator) {
        if (denominator == 0) {
            return "";
        }
        if (numerator == 0) {
            return "0";
        }
        StringBuilder sb = new StringBuilder();
        if (numerator > 0 && denominator < 0 || numerator < 0 && denominator > 0) {
            sb.append("-");
        }
        long num = Math.abs((long)numerator);
        long den = Math.abs((long)denominator);
        // integer part
        sb.append(num / den);
        num %= den;
        if (num == 0) {
            return sb.toString();
        }
        // fractional part
        sb.append(".");
        Map<Long, Integer> map = new HashMap<>();
        map.put(num, sb.length());
        while (num != 0) {
            num *= 10;
            sb.append(num / den);
            num %= den;
            if (map.containsKey(num)) {
                sb.insert(map.get(num), "(");
                sb.append(")");
                break;
            } else {
                map.put(num, sb.length());
            }
        }
        return sb.toString();
    }
}

350. Intersection of Two Arrays II

Given two arrays, write a function to compute their intersection.

Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2, 2].

Note:
Each element in the result should appear as many times as it shows in both arrays.
The result can be in any order.
Follow up:
What if the given array is already sorted? How would you optimize your algorithm?
What if nums1's size is small compared to nums2's size? Which algorithm is better?
What if elements of nums2 are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?

题目：求两个数组的公共元素(包含重复元素)

思路：对第一个数组，用HashMap存储元素 --> 该元素出现的次数。对于第二个数组的每一个元素，看是否在HashMap里并且value值不为0，如果是就加入到结果集中，并且将HashMap中相应的value值减1。最后返回结果集。时间复杂度O(n)，空间复杂度O(n)。

public class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums1) {
            if (!map.containsKey(num)) {
                map.put(num, 1);
            } else {
                map.put(num, map.get(num) + 1);
            }
        }
        List<Integer> list = new ArrayList<>();
        for (int num : nums2) {
            if (map.containsKey(num) && map.get(num) != 0) {
                list.add(num);
                map.put(num, map.get(num) - 1);
            }
        }
        int[] result = new int[list.size()];
        int index = 0;
        for (int i = 0; i < list.size(); i++) {
            result[index++] = list.get(i);
        }
        return result;
    }
}

37. Sudoku Solver

Write a program to solve a Sudoku puzzle by filling the empty cells.

Empty cells are indicated by the character '.'.

You may assume that there will be only one unique solution.

题意：求数游戏的解决方案

思路：对于棋盘上每一个空白区域，从1 ～ 9逐一尝试填入，看填上某一数字之后合不合乎规则，如果合乎就将该区域填入该数字，继续递归。如果填入1 ～ 9都不符合，则说明无解，该区域还原为空白区域。时间复杂度O(9^n)，n为空白区域的个数。

public class Solution {
    public void solveSudoku(char[][] board) {
        if (board == null || board.length == 0 || board[0].length == 0) {
            return;
        }
        int n = board.length;
        int m = board[0].length;
        if (n != 9 || m != 9) {
            return;
        }
        solve(board);
    }
    public boolean solve(char[][] board) {
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                if (board[i][j] == '.') {
                    for (char c = '1'; c <= '9'; c++) {
                        if (valid(board, i, j, c)) {
                            board[i][j] = c;
                            if (solve(board)) {
                                return true;
                            } else {
                                board[i][j] = '.';
                            }
                        }   
                    }
                    return false;
                }
            }
        }
        return true;
    }
    public boolean valid(char[][] board, int x, int y, char c) {
        for (int i = 0; i < 9; i++) {
            // check row
            if (board[x][i] != '.' && board[x][i] == c) {
                return false;
            }
            // check column
            if (board[i][y] != '.' && board[i][y] == c) {
                return false;
            }
            // check block
            if (board[(x / 3) * 3 + i / 3][(y / 3) * 3 + i % 3] != '.'
                && board[(x / 3) * 3 + i / 3][(y / 3) * 3 + i % 3] == c) {
                return false;
            }
        }
        return true;
    }
}

463. Island Perimeter

You are given a map in form of a two-dimensional integer grid where 1 represents land and 0 represents water. Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells). The island doesn't have "lakes" (water inside that isn't connected to the water around the island). One cell is a square with side length 1. The grid is rectangular, width and height don't exceed 100. Determine the perimeter of the island.

Example:

[[0,1,0,0],
 [1,1,1,0],
 [0,1,0,0],
 [1,1,0,0]]

Answer: 16

题目：求岛屿周长

思路：公式：4 * 岛屿个数 - 2 * 公共部分个数。时间复杂度O(n*m)，空间复杂度O(1)。

public class Solution {
    public int islandPerimeter(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        int n = grid.length;
        int m = grid[0].length;
        int islands = 0;
        int neighbors = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) {
                    islands++;
                    if (j < m - 1 && grid[i][j + 1] == 1) {
                        neighbors++;
                    }
                    if (i < n - 1 && grid[i + 1][j] == 1) {
                        neighbors++;
                    }
                }
            }
        }
        return 4 * islands - 2 * neighbors;
    }
}

18. 4Sum

Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note: The solution set must not contain duplicate quadruplets.

For example, given array S = [1, 0, -1, 0, -2, 2], and target = 0.

A solution set is:
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

题意：给定一个数组，求该数组中的四个数的和等于一个给定值的所有组合情况。

思路：双指针，注意去重。时间复杂度O(n^3)。

public class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        if (nums == null || nums.length < 4) {
            return result;
        }
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 3; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            for (int j = i + 1; j < nums.length - 2; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                int start = j + 1;
                int end = nums.length - 1;
                while (start < end) {
                    int sum = nums[i] + nums[j] + nums[start] + nums[end];
                    if (sum < target) {
                        start++;
                    } else if (sum == target) {
                        List<Integer> tempList = new ArrayList<>();
                        tempList.add(nums[i]);
                        tempList.add(nums[j]);
                        tempList.add(nums[start]);
                        tempList.add(nums[end]);
                        result.add(tempList);
                        start++;
                        end--;
                        while (start < end && nums[start] == nums[start - 1]) {
                            start++;
                        }
                        while (start < end && nums[end] == nums[end + 1]) {
                            end--;
                        }
                    } else {
                        end--;
                    }
                }
            }
        }
        return result;
    }
}

30. Substring with Concatenation of All Words

You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in words exactly once and without any intervening characters.

For example, given:
s: "barfoothefoobarman"
words: ["foo", "bar"]

You should return the indices: [0,9].
(order does not matter).

思路：思路：固定起点i（外层循环），从起点开始搜索（内层循环），如果能搜索到一个窗口恰好满足该窗口内的子串是words中所有单词的结合，就将起点i加入到结果集中；否则终止内层循环，i移到下一个起点。时间复杂度O(nk)，n为字符串长度，k为数组长度。空间复杂度O(k)。

public class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> result = new ArrayList<>();
        if (s == null || s.length() == 0 || words  == null || words.length == 0
            || s.length() < words.length * words[0].length()) {
            return result;
        }
        Map<String, Integer> map = new HashMap<>();
        for (String word : words) {
            if (!map.containsKey(word)) {
                map.put(word, 1);
            } else {
                map.put(word, map.get(word) + 1);
            }
        }
        int wordLen = words[0].length();
        for (int i = 0; i <= s.length() - words.length * wordLen; i++) {
            Map<String, Integer> temp = new HashMap<>();
            int j = 0;
            for (j = 0; j < words.length; j++) {
                String word = s.substring(i + j * wordLen, i + (j + 1) * wordLen);
                if (!map.containsKey(word)) {
                    break;
                }
                if (!temp.containsKey(word)) {
                    temp.put(word, 1);
                } else {
                    temp.put(word, temp.get(word) + 1);
                }
                if (temp.get(word) > map.get(word)) {
                    break;
                }
            }
            if (j == words.length) {
                result.add(i);
            }
        }
        return result;
    }
}

389. Find the Difference

Given two strings s and t which consist of only lowercase letters.

String t is generated by random shuffling string s and then add one more letter at a random position.

Find the letter that was added in t.

Example:

Input:
s = "abcd"
t = "abcde"

Output:
e

Explanation:
'e' is the letter that was added.

思路I：HasmMap版本，HashMap存储s中每个字符和对应出现的次数，对于t中的每个字符，出现在HashMap中次数减1，直到该字符不在HashMap中或者在HashMap中出现的次数为0。注意：返回空字符是返回''而不是''。O(n), O(n)。

public class Solution {
    public char findTheDifference(String s, String t) {
        if (s == null || t == null || s.length() != t.length() - 1) {
            return '';
        }
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (!map.containsKey(c)) {
                map.put(c, 1);
            } else {
                map.put(c, map.get(c) + 1);
            }
        }
        for (int i = 0; i < t.length(); i++) {
            char c = t.charAt(i);
            if (!map.containsKey(c) || map.get(c) == 0) {
                return c;
            }
            map.put(c, map.get(c) - 1);
        }
        return '';
    }
}

 思路II：异或运算。初始化char c = 0，表示ascii码为0所代表的字符。将s和t的每个字符逐一异或就得到要求的结果。O(n)，O(1)。

public class Solution {
    public char findTheDifference(String s, String t) {
        if (s == null || t == null || s.length() != t.length() - 1) {
            return '';
        }
        char c = 0;
        for (int i = 0; i < s.length(); i++) {
            c ^= s.charAt(i);
        }
        for (int i = 0; i < t.length(); i++) {
            c ^= t.charAt(i);
        }
        return c;
    }
}

311. Sparse Matrix Multiplication

Given two sparse matrices A and B, return the result of AB.

You may assume that A's column number is equal to B's row number.

Example:

A = [
  [ 1, 0, 0],
  [-1, 0, 3]
]

B = [
  [ 7, 0, 0 ],
  [ 0, 0, 0 ],
  [ 0, 0, 1 ]
]


     |  1 0 0 |   | 7 0 0 |   |  7 0 0 |
AB = | -1 0 3 | x | 0 0 0 | = | -7 0 3 |
                  | 0 0 1 |

题意：两个矩阵相乘

思路I：naive，运行时间较高。

public class Solution {
    public int[][] multiply(int[][] A, int[][] B) {
        if (A == null || A.length == 0 || A[0].length == 0
            || B == null || B.length == 0 || B[0].length == 0) {
            return new int[0][0];
        }
        if (A[0].length != B.length) {
            return new int[0][0];
        }
        int n = A.length;
        int m = A[0].length;
        int l = B[0].length;
        int[][] C = new int[n][l];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < l; j++) {
                for (int k = 0; k < m; k++) {
                    if (A[i][k] != 0 && B[k][j] != 0) {
                        C[i][j] += A[i][k] * B[k][j];
                    }
                }
            }
        }
        return C;
    }
}

思路II：叠加和，其实就是改变了矩阵相乘的运算顺序。这道题让我们实现稀疏矩阵相乘，稀疏矩阵的特点是矩阵中绝大多数的元素为0，而相乘的结果是还应该是稀疏矩阵，即还是大多数元素为0，那么我们使用传统的矩阵相乘的算法肯定会处理大量的0乘0的无用功，所以我们需要适当的优化算法，使其可以顺利通过OJ，我们知道一个 i x k 的矩阵A乘以一个 k x j 的矩阵B会得到一个 i x j 大小的矩阵C，那么我们来看结果矩阵中的某个元素C[i][j]是怎么来的，起始是A[i][0]*B[0][j] + A[i][1]*B[1][j] + ... + A[i][k]*B[k][j]，那么为了不重复计算0乘0，我们首先遍历A数组，要确保A[i][k]不为0，才继续计算，然后我们遍历B矩阵的第k行，如果B[K][J]不为0，我们累加结果矩阵res[i][j] += A[i][k] * B[k][j]; 这样我们就能高效的算出稀疏矩阵的乘法。

public class Solution {
    public int[][] multiply(int[][] A, int[][] B) {
        if (A == null || A.length == 0 || A[0].length == 0
           || B == null || B.length == 0 || B[0].length == 0) {
            return new int[0][0];
        }
        if (A[0].length != B.length) {
            return new int[0][0];
        }
        int n = A.length;
        int m = A[0].length;
        int l = B[0].length;
        int[][] C = new int[n][l];
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < m; k++) {
                if (A[i][k] != 0) {
                    for (int j = 0; j < l; j++) {
                        if (B[k][j] != 0) {
                            C[i][j] += A[i][k] * B[k][j];
                        }
                    }
                }
            }
        }
        return C;
    }
}

274. H-Index

Given an array of citations (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.

According to the definition of h-index on Wikipedia: "A scientist has index h if h of his/her N papers have at least h citations each, and the other N − h papers have no more than h citations each."

For example, given citations = [3, 0, 6, 1, 5], which means the researcher has 5 papers in total and each of them had received 3, 0, 6, 1, 5 citations respectively. Since the researcher has 3 papers with at least 3 citations each and the remaining two with no more than 3 citations each, his h-index is 3.

Note: If there are several possible values for h, the maximum one is taken as the h-index.

Credits:
Special thanks to @jianchao.li.fighter for adding this problem and creating all test cases.

思路I：排序，O(nlgn)。

public class Solution {
    public int hIndex(int[] citations) {
        if (citations == null || citations.length == 0) {
            return 0;
        }
        int len = citations.length;
        Arrays.sort(citations);
        int i = len - 1;
        for (; i >= 0; i--) {
            if (citations[i] < len - i) {
                break;
            }
        }
        i++;
        return len - i;
    }
}

思路II：O(n)，记录一个数组，索引位引用次数，值为该引用次数的文章数，大于文章总数的引用次数当成文章总数。

public class Solution {
    public int hIndex(int[] citations) {
        if (citations == null || citations.length == 0) {
            return 0;
        }
        int[] count = new int[citations.length + 1];
        for (int i = 0; i < citations.length; i++) {
            if (citations[i] > citations.length) {
                count[citations.length]++;
            } else {
                count[citations[i]]++;
            }
        }
        int sum = 0;
        for (int i = citations.length; i >= 0; i--) {
            sum += count[i];
            if (sum >= i) {
                return i;
            }
        }
        return 0;
    }
}

链表专题

141. Linked List Cycle

Given a linked list, determine if it has a cycle in it.

Follow up:
Can you solve it without using extra space?

题意：判断一个链表是否有环

思路：快慢指针，slow=head，fast=head.next开始，slow每次走一步，fast每次走两步。时间复杂度O(n)，空间复杂度O(1)。

版本一

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null) {
            return false;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (fast != null && fast.next != null) {
            if (slow == fast) {
                return true;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return false;
    }
}

版本二 

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null) {
            return false;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return true;
    }
}

 142. Linked List Cycle II

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.

Note: Do not modify the linked list.

Follow up:
Can you solve it without using extra space?

题意：确定链表中环的入口节点

思路：先找到快慢指针的相遇节点，然后slow回到头结点即slow=head，fast向前移动一位即fast=fast.next，然后slow和fast一起同时向前移动，每次移动一步，知道两个指针再次相遇，该相遇节点即为环的入口节点。

复杂度分析：时间复杂度O(n)，空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return null;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        slow = head;
        fast = fast.next;
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

 

 160. Intersection of Two Linked Lists

Write a program to find the node at which the intersection of two singly linked lists begins.


For example, the following two linked lists:

A:          a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗            
B:     b1 → b2 → b3
begin to intersect at node c1.


Notes:

If the two linked lists have no intersection at all, return null.
The linked lists must retain their original structure after the function returns.
You may assume there are no cycles anywhere in the entire linked structure.
Your code should preferably run in O(n) time and use only O(1) memory.

题意：判读两个链表的公共节点

思路：先把第一个链表的尾节点的next域指向第二个链表的头结点，问题转化为求一个环形链表的入口节点。快慢指针来解决，当找到slow和fast的相遇节点后，还没完！重新修改快慢指针指向：slow=headA，fast=fast.next，然后slow和fast一起每次向前走一步，直到两者相遇，此时相遇的节点就是环形链表的入口节点。注意在返回公共节点之前一定要把第一个链表的尾节点的next指向修改回原来的null，以免改变原链表结构！时间复杂度O(n)，空间复杂度O(1)。

版本一

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode tailA = headA;
        while (tailA.next != null) {
            tailA = tailA.next;
        }
        tailA.next = headB;
        ListNode slow = headA;
        ListNode fast = headA.next;
        while (fast != null && fast.next != null) {
            if (slow == fast) {
                slow = headA;
                fast = fast.next;
                while (slow != fast) {
                    slow = slow.next;
                    fast = fast.next;
                }
                tailA.next = null;
                return slow;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        tailA.next = null;
        return null;
    }
}

版本二

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode tailA = headA;
        while (tailA.next != null) {
            tailA = tailA.next;
        }
        tailA.next = headB;
        ListNode slow = headA;
        ListNode fast = headA.next;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                tailA.next = null;
                return null;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        slow = headA;
        fast = fast.next;
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        tailA.next = null;
        return slow;
    }
}

237. Delete Node in a Linked List

Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.

Supposed the linked list is 1 -> 2 -> 3 -> 4 and you are given the third node with value 3, the linked list should become 1 -> 2 -> 4 after calling your function.

题意：给定要删除的节点，从链表中删除该节点。注意没有给定链表头结点！即无法得到当前节点的前驱节点！

思路：要删除节点的val值赋值成该节点的next节点的val值，然后修改该节点的next指向该节点next的next节点。时间复杂度O(1)，空间复杂度O(1)。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        if (node == null || node.next == null) {
            return;
        }
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

83. Remove Duplicates from Sorted List

Given a sorted linked list, delete all duplicates such that each element appear only once.

For example,
Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->2->3.

题意：从链表中删除重复的元素，保留一个重复的元素。

思路：前后指针prev和cur，初始指向head和head.next，当两个指针所指向的节点值相同时，改变prev的next指向cur的next节点，同时cur指针后移一位；否则，prev和cur都后移一位。

复杂度分析：时间复杂度O(n)，空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode prev = head;
        ListNode cur = head.next;
        while (cur != null) {
            if (prev.val == cur.val) {
                prev.next = cur.next;
                cur = cur.next;
            } else {
                prev = cur;
                cur = cur.next;
            }
        }
        return head;
    }
}

82. Remove Duplicates from Sorted List II

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

For example,
Given 1->2->3->3->4->4->5, return 1->2->5.
Given 1->1->1->2->3, return 2->3.

题意：从链表中删除重复的元素，剔除所有重复的元素。

思路：由于最后返回的头结点不确定，所以建dummy节点，dummy.next = head。前后指针pre和cur，pre始终指向最近一次非重复的节点，cur指向当前待校验的节点。初始pre指向dummy，cur指向head，当cur.next != null && cur.val == cur.next.val时循环，cur往后移动。退出循环时，如果pre的next不是cur，说明cur所指的节点是重复节点，pre.next = cur.next，cur后移一位，注意pre不能后移，因为cur这时所指向的新节点依然可能是重复节点，需要在下一层循环中来判断；如果pre的next是cur，说明cur节点不是重复节点，pre后移一位，cur后移一位继续外层循环，直到cur为null为止。

复杂度分析：时间复杂度O(n)，空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(0), pre = dummy;
        dummy.next = head;
        ListNode cur = head;
        while (cur != null) {
            while (cur.next != null && cur.val == cur.next.val) {
                cur = cur.next;
            }
            if (pre.next == cur) {
                pre = pre.next;
            } else {
                pre.next = cur.next;
            }
            cur = cur.next;
        }
        return dummy.next;
    }
}

203. Remove Linked List Elements

Remove all elements from a linked list of integers that have value val.

Example
Given: 1 --> 2 --> 6 --> 3 --> 4 --> 5 --> 6, val = 6
Return: 1 --> 2 --> 3 --> 4 --> 5

Credits:
Special thanks to @mithmatt for adding this problem and creating all test cases.

题意：从链表中删除节点值是给定值val得节点

思路：注意到链表头结点可能会发生改变，所以先建立一个dummy节点，其next指向head，然后和83类似。前后指针prev和cur，初始分别指向dummy和head，当cur所指向节点的val值等于给定值时，改变prev的next指向cur的next节点，同时cur指针后移一位；否则，prev和cur都后移一位。

错误点：因为链表头结点可能会发生改变，原来的head节点可能会从链表中剔除，所以最后返回的链表头结点一定是dummy.next而不是head！！！

复杂度分析：时间复杂度O(n)，空间复杂度O(1)

206. Reverse Linked List

题目：Reverse a singly linked list.

思路：前后指针prev和cur，初始分别指向null和head，每次翻转先存储cur的next节点after，然后cur的next域指向prev，接着移动指针：prev指向cur，cur指向after。最后cur==null时结束翻转，此时链表头结点为prev，返回prev即可。

复杂度分析：时间复杂度O(n)，空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode prev = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode after = cur.next;
            cur.next = prev;
            prev = cur;
            cur = after;
        }
        return prev;
    }
}

92. Reverse Linked List II

Reverse a linked list from position m to n. Do it in-place and in one-pass.

For example:
Given 1->2->3->4->5->NULL, m = 2 and n = 4,

return 1->4->3->2->5->NULL.

Note:
Given m, n satisfy the following condition:
1 ≤ m ≤ n ≤ length of list.

题意：反转链表中第m个节点到第n个节点，从1开始。1<=m<=n<=linkedlist.length

思路：由于最后返回的头节点不确定，所以先建立一个dummy节点，dummy.next=head。反转分三个过程：1 反转第m个节点到第n个节点 2 第m个节点的前一个节点的next指向第n个节点 3 第m个节点的next指向第n个节点的后一个节点。

复杂度分析：时间复杂度O(n)，空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        if (head == null || head.next == null || m >= n || m <= 0) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode node = dummy;
        for (int i = 0; i < m - 1; i++) {
            node = node.next;
        }
        ListNode nodeM = node.next;
        ListNode pre = null, cur = nodeM;
        for (int i = 0; i < n - m + 1; i++) {
            ListNode after = cur.next;
            cur.next = pre;
            pre = cur;
            cur = after;
        }
        ListNode nodeN = pre;
        node.next = nodeN;
        nodeM.next = cur;
        return dummy.next;
    }
}

234. Palindrome Linked List

题目：Given a singly linked list, determine if it is a palindrome. 判断一个链表是不是回文链表。

思路：受206翻转链表的启发，将原链表的后半部分翻转，然后一头一尾指针逐一校验。翻转后半部分链表的步骤：首先确定中间节点（偶数个节点的话偏头部的那个作为中间节点），用快慢指针来确定，初始slow=head，fast=head.next，循环直到fast==null || fast.next == null（步骤跟确定环形链表入口节点相似），此时slow所指向的节点就是该链表的中间节点。然后跟206步骤一样prev=null，cur=slow开始进行链表翻转。最后从链表头尾逐一校验，循环条件是head != null && tail != null，只要有一个节点为null，说明比较结束，该链表是回文链表。

错误点：从链表头尾逐一校验的循环过程中，当两个节点值不相等直接返回false，不相等记得要移动两个指针到下一个节点！！！再循环比较。

复杂度分析：时间复杂度O(n)，空间复杂度O(1）

21. Merge Two Sorted Lists

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

Example:

Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4

题意：合并两个有序链表

思路：因为最后返回的链表头结点不确定，所以首先建立虚拟节点dummy，然后新建cur节点指向dummy，然后逐一比较两个链表当前节点值得大小，哪个节点值小cur的next域就指向哪个节点，然后cur前移一位，值小的那个节点指针前移一位，一直比较直到某一节点为null。此时再把剩下的非null的节点（可能在第一个链表也可能在第二个链表上，但是不可能同时存在）连接起来。

复杂度分析：时间复杂度O(n)，空间复杂度O(1)

23. Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

题意：是上一题21的扩展版本，合并k个有序链表。

思路I：分治思想，转化为合并两个有序链表的问题。

复杂度分析：时间复杂度O(klgn)，n为链表的条数，k为链表的平均长度，空间复杂度O(lgn)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }
        return mergeHelper(lists, 0, lists.length - 1);
    }
    public ListNode mergeHelper(ListNode[] lists, int start, int end) {
        if (start == end) {
            return lists[start];
        }
        int mid = start + (end - start) / 2;
        ListNode left = mergeHelper(lists, start, mid);
        ListNode right = mergeHelper(lists, mid + 1, end);
        return mergeTwoLists(left, right);
    }
    public ListNode mergeTwoLists(ListNode left, ListNode right) {
        ListNode dummy = new ListNode(0), cur = dummy;
        while (left != null && right != null) {
            if (left.val <= right.val) {
                cur.next = left;
                left = left.next;
            } else {
                cur.next = right;
                right = right.next;
            }
            cur = cur.next;
        }
        if (left != null) {
            cur.next = left;
        }
        if (right != null) {
            cur.next = right;
        }
        return dummy.next;
    }
}

思路II：最小堆

复杂度分析：因为PriorityQueue的offer和poll操作的复杂度都是O(lgn)，n为优先级队列的最大容量。所以时间复杂度为O(nklgn)，空间复杂度O(n)，n为链表的条数，k为链表的平均长度

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }
        PriorityQueue<ListNode> pq = new PriorityQueue<>(lists.length, new Comparator<ListNode>() {
            public int compare(ListNode a, ListNode b) {
                return a.val - b.val;
            }
        });
        for (int i = 0; i < lists.length; i++) {
            if (lists[i] != null) {
                pq.offer(lists[i]); 
            }
        }
        ListNode dummy = new ListNode(0), cur = dummy;
        while (!pq.isEmpty()) {
            ListNode node = pq.poll();
            cur.next = node;
            cur = cur.next;
            if (node.next != null) {
                pq.offer(node.next);
            }
        }
        return dummy.next;
        
    }
}

61. Rotate List

Given a list, rotate the list to the right by k places, where k is non-negative.

题意：将链表的末尾的k个节点旋转到头部

思路：首先最后返回的链表头结点不确定，所以建立一个虚拟节点dummy，其next指向head。确定第几个节点后的所有节点要移到首部，这个第几个就是length - k % length，所以开始要计算出链表的长度即节点总个数。确定了该节点后，改变指针指向即可。注意指针指向的改变顺序，要先连接中间的部分，然后再连接首和尾！具体分析见代码里面的注释。

复杂度分析：时间复杂度O(n)，空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if (head == null || head.next == null || k <= 0) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        int length = 0;
        ListNode fast = dummy;
        while (fast.next != null) {
            fast = fast.next;
            length++;
        }
        int count = length - k % length;
        ListNode slow = dummy;
        for (int i = 0; i < count; i++) {
            slow = slow.next;
        }
        // 这里注意一定要先执行fast.next = head，即先把链表中间的部分连接好，再连接首尾，否则会出现错误。比如case：【1，2】，k=2，不先执行                 // fast.next = head的话，dummy.next直接就为null了，最后返回的dummy.next就是null，造成错误！
        fast.next = head;
        dummy.next = slow.next;
        slow.next = null;
        return dummy.next;
    }
}