public int search(int key, int[] arr) {int l = 0, h = arr.length - 1;while (l <= h) {int mid = l + (h - l) / 2;if (key == arr[mid]) return mid;if (key < arr[mid]) h = mid - 1;else l = mid + 1;}return -1;
}

public int mySqrt(int x) {if(x <= 1) return x;int l = 1, h = x;while(l <= h){int mid = l + (h - l) / 2;int sqrt = x / mid;if(sqrt == mid) return mid;else if(sqrt < mid) h = mid - 1;else l = mid + 1;}return h;
}

n = 8The coins can form the following rows:
¤
¤ ¤
¤ ¤ ¤
¤ ¤Because the 4th row is incomplete, we return 3.

public int arrangeCoins(int n) {int l = 0, h = n;while(l <= h){int m = l + (h - l) / 2;long x = m * (m + 1L) / 2;if(x == n) return m;else if(x < n) l = m + 1;else h = m - 1;}return h;
}

public int arrangeCoins(int n) {int level = 1;while (n > 0) {n -= level;level++;}return n == 0 ? level - 1 : level - 2;
}

public int singleNonDuplicate(int[] nums) {int l = 0, h = nums.length - 1;while(l < h) {int m = l + (h - l) / 2;if(m % 2 == 1) m--; // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数if(nums[m] == nums[m + 1]) l = m + 2;else h = m;}return nums[l];
}

public int findContentChildren(int[] g, int[] s) {Arrays.sort(g);Arrays.sort(s);int i = 0, j = 0;while(i < g.length && j < s.length){if(g[i] <= s[j]) i++;j++;}return i;
}

public int findMinArrowShots(int[][] points) {if(points.length == 0) return 0;Arrays.sort(points,(a,b) -> (a[1] - b[1]));int curPos = points[0][1];int ret = 1;for (int i = 1; i < points.length; i++) {if(points[i][0] <= curPos) {continue;}curPos = points[i][1];ret++;}return ret;}

public int maxProfit(int[] prices) {int profit = 0;for(int i = 1; i < prices.length; i++){if(prices[i] > prices[i-1]) profit += (prices[i] - prices[i-1]);}return profit;
}

Input: flowerbed = [1,0,0,0,1], n = 1
Output: True

public boolean canPlaceFlowers(int[] flowerbed, int n) {int cnt = 0;for(int i = 0; i < flowerbed.length; i++){if(flowerbed[i] == 1) continue;int pre = i == 0 ? 0 : flowerbed[i - 1];int next = i == flowerbed.length - 1 ? 0 : flowerbed[i + 1];if(pre == 0 && next == 0) {cnt++;flowerbed[i] = 1;}}return cnt >= n;
}

public boolean checkPossibility(int[] nums) {int cnt = 0;for(int i = 1; i < nums.length; i++){if(nums[i] < nums[i - 1]){cnt++;if(i - 2 >= 0 && nums[i - 2] > nums[i]) nums[i] = nums[i-1];else nums[i - 1] = nums[i];}}return cnt <= 1;
}

s = "abc", t = "ahbgdc"
Return true.

public boolean isSubsequence(String s, String t) {for (int i = 0, pos = 0; i < s.length(); i++, pos++) {pos = t.indexOf(s.charAt(i), pos);if(pos == -1) return false;}return true;
}

Input: S = "ababcbacadefegdehijhklij"
Output: [9,7,8]
Explanation:
The partition is "ababcbaca", "defegde", "hijhklij".
This is a partition so that each letter appears in at most one part.
A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.

public List<Integer> partitionLabels(String S) {List<Integer> ret = new ArrayList<>();int[] lastIdxs = new int[26];for(int i = 0; i < S.length(); i++) lastIdxs[S.charAt(i) - 'a'] = i;int startIdx = 0;while(startIdx < S.length()) {int endIdx = startIdx;for(int i = startIdx; i < S.length() && i <= endIdx; i++) {int lastIdx = lastIdxs[S.charAt(i) - 'a'];if(lastIdx == i) continue;if(lastIdx > endIdx) endIdx = lastIdx;}ret.add(endIdx - startIdx + 1);startIdx = endIdx + 1;}return ret;
}

Input:
[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]Output:
[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]

public int[][] reconstructQueue(int[][] people) {if(people == null || people.length == 0 || people[0].length == 0) return new int[0][0];Arrays.sort(people, new Comparator<int[]>() {public int compare(int[] a, int[] b) {if(a[0] == b[0]) return a[1] - b[1];return b[0] - a[0];}});int n = people.length;List<int[]> tmp = new ArrayList<>();for(int i = 0; i < n; i++) {tmp.add(people[i][1], new int[]{people[i][0], people[i][1]});}int[][] ret = new int[n][2];for(int i = 0; i < n; i++) {ret[i][0] = tmp.get(i)[0];ret[i][1] = tmp.get(i)[1];}return ret;
}

public int[] twoSum(int[] numbers, int target) {int i = 0, j = numbers.length - 1;while (i < j) {int sum = numbers[i] + numbers[j];if (sum == target) return new int[]{i + 1, j + 1};else if (sum < target) i++;else j--;}return null;
}

private HashSet<Character> vowels = new HashSet<>(Arrays.asList('a','e','i','o','u','A','E','I','O','U'));public String reverseVowels(String s) {if(s.length() == 0) return s;int i = 0, j = s.length() - 1;char[] result = new char[s.length()];while(i <= j){char ci = s.charAt(i);char cj = s.charAt(j);if(!vowels.contains(ci)){result[i] = ci;i++;} else if(!vowels.contains(cj)){result[j] = cj;j--;} else{result[i] = cj;result[j] = ci;i++;j--;}}return new String(result);
}

public boolean judgeSquareSum(int c) {int left = 0, right = (int) Math.sqrt(c);while(left <= right){int powSum = left * left + right * right;if(powSum == c) return true;else if(powSum > c) right--;else left++;}return false;
}

public boolean validPalindrome(String s) {int i = 0, j = s.length() -1;while(i < j){if(s.charAt(i) != s.charAt(j)){return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);}i++;j--;}return true;
}private boolean isPalindrome(String s, int l, int r){while(l < r){if(s.charAt(l) != s.charAt(r))return false;l++;r--;}return true;
}

public void merge(int[] nums1, int m, int[] nums2, int n) {int i = m - 1, j = n - 1; // 需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值int idx = m + n - 1;while(i >= 0 || j >= 0){if(i < 0) nums1[idx] = nums2[j--];else if(j < 0) nums1[idx] = nums1[i--];else if(nums1[i] > nums2[j]) nums1[idx] = nums1[i--];else nums1[idx] = nums2[j--];idx--;}
}

public boolean hasCycle(ListNode head) {if(head == null) return false;ListNode l1 = head, l2 = head.next;while(l1 != null && l2 != null){if(l1 == l2) return true;l1 = l1.next;if(l2.next == null) break;l2 = l2.next.next;}return false;
}

public String findLongestWord(String s, List<String> d) {String ret = "";for (String str : d) {for (int i = 0, j = 0; i < s.length() && j < str.length(); i++) {if (s.charAt(i) == str.charAt(j)) j++;if (j == str.length()) {if (ret.length() < str.length()|| (ret.length() == str.length() && ret.compareTo(str) > 0)) {ret = str;}}}}return ret;
}

public int findKthLargest(int[] nums, int k) {int N = nums.length;Arrays.sort(nums);return nums[N - k];
}

public int findKthLargest(int[] nums, int k) {PriorityQueue<Integer> pq = new PriorityQueue<>();for(int val : nums) {pq.offer(val);if(pq.size() > k) {pq.poll();}}return pq.peek();
}

public int findKthLargest(int[] nums, int k) {k = nums.length - k;int lo = 0;int hi = nums.length - 1;while (lo < hi) {final int j = partition(nums, lo, hi);if(j < k) {lo = j + 1;} else if (j > k) {hi = j - 1;} else {break;}}return nums[k];}private int partition(int[] a, int lo, int hi) {int i = lo;int j = hi + 1;while(true) {while(i < hi && less(a[++i], a[lo]));while(j > lo && less(a[lo], a[--j]));if(i >= j) {break;}exch(a, i, j);}exch(a, lo, j);return j;}private void exch(int[] a, int i, int j) {final int tmp = a[i];a[i] = a[j];a[j] = tmp;}private boolean less(int v, int w) {return v < w;}
}

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

[[1,1,0,1],
[1,0,1,0],
[1,1,1,1],
[1,0,1,1]]

public int minPathLength(int[][] grids, int tr, int tc) {int[][] next = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};int m = grids.length, n = grids[0].length;Queue<Position> queue = new LinkedList<>();queue.add(new Position(0, 0, 1));while (!queue.isEmpty()) {Position pos = queue.poll();for (int i = 0; i < 4; i++) {Position nextPos = new Position(pos.r + next[i][0], pos.c + next[i][1], pos.length + 1);if (nextPos.r < 0 || nextPos.r >= m || nextPos.c < 0 || nextPos.c >= n) continue;if (grids[nextPos.r][nextPos.c] != 1) continue;grids[nextPos.r][nextPos.c] = 0;if (nextPos.r == tr && nextPos.c == tc) return nextPos.length;queue.add(nextPos);}}return -1;
}private class Position {int r, c, length;public Position(int r, int c, int length) {this.r = r;this.c = c;this.length = length;}
}

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,1,1,0,1,0,0,0,0,0,0,0,0],
[0,1,0,0,1,1,0,0,1,0,1,0,0],
[0,1,0,0,1,1,0,0,1,1,1,0,0],
[0,0,0,0,0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,0,1,1,0,0,0,0]]

public int maxAreaOfIsland(int[][] grid) {int m = grid.length, n = grid[0].length;int max = 0;for(int i = 0; i < m; i++){for(int j = 0; j < n; j++){if(grid[i][j] == 1) max = Math.max(max, dfs(grid, i, j));}}return max;
}private int dfs(int[][] grid, int i, int j){int m = grid.length, n = grid[0].length;if(i < 0 || i >= m || j < 0 || j >= n) return 0;if(grid[i][j] == 0) return 0;grid[i][j] = 0;return dfs(grid, i + 1, j) + dfs(grid, i - 1, j) + dfs(grid, i, j + 1) + dfs(grid, i, j - 1) + 1;
}

Input:
[[1,1,0],[1,1,0],[0,0,1]]
Output: 2
Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
The 2nd student himself is in a friend circle. So return 2.

public int findCircleNum(int[][] M) {int n = M.length;int ret = 0;boolean[] hasFind = new boolean[n];for(int i = 0; i < n; i++) {if(!hasFind[i]) {dfs(M, i, hasFind);ret++;}}return ret;
}private void dfs(int[][] M, int i, boolean[] hasFind) {hasFind[i] = true;int n = M.length;for(int k = 0; k < n; k++) {if(M[i][k] == 1 && !hasFind[k]) {dfs(M, k, hasFind);}}
}

11110
11010
11000
00000
Answer: 1

private int m, n;
private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};public int numIslands(char[][] grid) {if (grid == null || grid.length == 0) return 0;m = grid.length;n = grid[0].length;int ret = 0;for (int i = 0; i < m; i++) {for (int j = 0; j < n; j++) {if (grid[i][j] == '1') {dfs(grid, i, j);ret++;}}}return ret;
}private void dfs(char[][] grid, int i, int j) {if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') return;grid[i][j] = '0';for (int k = 0; k < direction.length; k++) {dfs(grid, i + direction[k][0], j + direction[k][1]);}
}

  1
/  \
2    3
\5

["1->2->5", "1->3"]

public List<String> binaryTreePaths(TreeNode root) {List<String> ret = new ArrayList();if(root == null) return ret;dfs(root, "", ret);return ret;
}private void dfs(TreeNode root, String prefix, List<String> ret){if(root == null) return;if(root.left == null && root.right == null){ret.add(prefix + root.val);return;}prefix += (root.val + "->");dfs(root.left, prefix, ret);dfs(root.right, prefix, ret);
}

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

private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
private int m, n;public void solve(char[][] board) {if (board == null || board.length == 0) return;m = board.length;n = board[0].length;for (int i = 0; i < m; i++) {dfs(board, i, 0);dfs(board, i, n - 1);}for (int i = 0; i < n; i++) {dfs(board, 0, i);dfs(board, m - 1, i);}for (int i = 0; i < m; i++) {for (int j = 0; j < n; j++) {if (board[i][j] == 'T') board[i][j] = 'O';else if (board[i][j] == 'O') board[i][j] = 'X';}}
}private void dfs(char[][] board, int r, int c) {if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != 'O') return;board[r][c] = 'T';for (int i = 0; i < direction.length; i++) {dfs(board, r + direction[i][0], c + direction[i][1]);}
}

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  **   *   *   *   * AtlanticReturn:
[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).

private int m, n;
private int[][] matrix;
private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};public List<int[]> pacificAtlantic(int[][] matrix) {List<int[]> ret = new ArrayList<>();if (matrix == null || matrix.length == 0) return ret;this.m = matrix.length;this.n = matrix[0].length;this.matrix = matrix;boolean[][] canReachP = new boolean[m][n];boolean[][] canReachA = new boolean[m][n];for (int i = 0; i < m; i++) {dfs(i, 0, canReachP);dfs(i, n - 1, canReachA);}for (int i = 0; i < n; i++) {dfs(0, i, canReachP);dfs(m - 1, i, canReachA);}for (int i = 0; i < m; i++) {for (int j = 0; j < n; j++) {if (canReachP[i][j] && canReachA[i][j]) {ret.add(new int[]{i, j});}}}return ret;
}private void dfs(int r, int c, boolean[][] canReach) {if(canReach[r][c]) return;canReach[r][c] = true;for (int i = 0; i < direction.length; i++) {int nextR = direction[i][0] + r;int nextC = direction[i][1] + c;if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n|| matrix[r][c] > matrix[nextR][nextC]) continue;dfs(nextR, nextC, canReach);}
}

private List<List<String>> ret;
private char[][] nQueens;
private boolean[] colUsed;
private boolean[] diagonals45Used;
private boolean[] diagonals135Used;
private int n;public List<List<String>> solveNQueens(int n) {ret = new ArrayList<>();nQueens = new char[n][n];Arrays.fill(nQueens, '.');colUsed = new boolean[n];diagonals45Used = new boolean[2 * n - 1];diagonals135Used = new boolean[2 * n - 1];this.n = n;backstracking(0);return ret;
}private void backstracking(int row) {if (row == n) {List<String> list = new ArrayList<>();for (char[] chars : nQueens) {list.add(new String(chars));}ret.add(list);return;}for (int col = 0; col < n; col++) {int diagonals45Idx = row + col;int diagonals135Idx = n - 1 - (row - col);if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {continue;}nQueens[row][col] = 'Q';colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;backstracking(row + 1);colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;nQueens[row][col] = '.';}
}

Input:Digit string "23"
Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

private static final String[] KEYS = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};public List<String> letterCombinations(String digits) {List<String> ret = new ArrayList<>();if (digits != null && digits.length() != 0) {combination("", digits, 0, ret);}return ret;
}private void combination(String prefix, String digits, int offset, List<String> ret) {if (offset == digits.length()) {ret.add(prefix);return;}String letters = KEYS[digits.charAt(offset) - '0'];for (char c : letters.toCharArray()) {combination(prefix + c, digits, offset + 1, ret);}
}

For example,
Given board =
[['A','B','C','E'],['S','F','C','S'],['A','D','E','E']
]
word = "ABCCED", -> returns true,
word = "SEE", -> returns true,
word = "ABCB", -> returns false.

private static int[][] shift = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
private static boolean[][] visited;
private int m;
private int n;public boolean exist(char[][] board, String word) {if (word == null || word.length() == 0) return true;if (board == null || board.length == 0 || board[0].length == 0) return false;m = board.length;n = board[0].length;visited = new boolean[m][n];for (int i = 0; i < m; i++) {for (int j = 0; j < n; j++) {if (dfs(board, word, 0, i, j)) return true;}}return false;
}private boolean dfs(char[][] board, String word, int start, int r, int c) {if (start == word.length()) {return true;}if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != word.charAt(start) ||  visited[r][c] ) {return false;}visited[r][c] = true;for (int i = 0; i < shift.length; i++) {int nextR = r + shift[i][0];int nextC = c + shift[i][1];if (dfs(board, word, start + 1, nextR, nextC)) return true;}visited[r][c] = false;return false;
}

Given "25525511135",
return ["255.255.11.135", "255.255.111.35"].

private List<String> ret;public List<String> restoreIpAddresses(String s) {ret = new ArrayList<>();doRestore(0, "", s);return ret;
}private void doRestore(int k, String path, String s) {if (k == 4 || s.length() == 0) {if (k == 4 && s.length() == 0) {ret.add(path);}return;}for (int i = 0; i < s.length() && i <= 2; i++) {if (i != 0 && s.charAt(0) == '0') break;String part = s.substring(0, i + 1);if (Integer.valueOf(part) <= 255) {doRestore(k + 1, path.length() != 0 ? path + "." + part : part, s.substring(i + 1));}}
}

[1,2,3] have the following permutations:
[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]
]

public List<List<Integer>> permute(int[] nums) {List<List<Integer>> ret = new ArrayList<>();List<Integer> permuteList = new ArrayList<>();boolean[] visited = new boolean[nums.length];backtracking(permuteList, visited, nums, ret);return ret;
}private void backtracking(List<Integer> permuteList, boolean[] visited, int[] nums, List<List<Integer>> ret){if(permuteList.size() == nums.length){ret.add(new ArrayList(permuteList));return;}for(int i = 0; i < visited.length; i++){if(visited[i]) continue;visited[i] = true;permuteList.add(nums[i]);backtracking(permuteList, visited, nums, ret);permuteList.remove(permuteList.size() - 1);visited[i] = false;}
}

[1,1,2] have the following unique permutations:
[[1,1,2], [1,2,1], [2,1,1]]

public List<List<Integer>> permuteUnique(int[] nums) {List<List<Integer>> ret = new ArrayList<>();List<Integer> permuteList = new ArrayList<>();Arrays.sort(nums);boolean[] visited = new boolean[nums.length];backtracking(permuteList, visited, nums, ret);return ret;
}private void backtracking(List<Integer> permuteList, boolean[] visited, int[] nums, List<List<Integer>> ret) {if (permuteList.size() == nums.length) {ret.add(new ArrayList(permuteList));return;}for (int i = 0; i < visited.length; i++) {if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) continue;if (visited[i]) continue;visited[i] = true;permuteList.add(nums[i]);backtracking(permuteList, visited, nums, ret);permuteList.remove(permuteList.size() - 1);visited[i] = false;}
}

If n = 4 and k = 2, a solution is:
[[2,4],[3,4],[2,3],[1,2],[1,3],[1,4],
]

public List<List<Integer>> combine(int n, int k) {List<List<Integer>> ret = new ArrayList<>();List<Integer> combineList = new ArrayList<>();backtracking(1, n, k, combineList, ret);return ret;
}private void backtracking(int start, int n, int k, List<Integer> combineList, List<List<Integer>> ret){if(k == 0){ret.add(new ArrayList(combineList)); // 这里要重新构造一个 Listreturn;}for(int i = start; i <= n - k + 1; i++){ // 剪枝combineList.add(i);                        // 把 i 标记为已访问backtracking(i + 1, n, k - 1, combineList, ret);combineList.remove(combineList.size() - 1); // 把 i 标记为未访问}
}

given candidate set [2, 3, 6, 7] and target 7,
A solution set is:
[[7],[2, 2, 3]]

 private List<List<Integer>> ret;public List<List<Integer>> combinationSum(int[] candidates, int target) {ret = new ArrayList<>();doCombination(candidates, target, 0, new ArrayList<>());return ret;}private void doCombination(int[] candidates, int target, int start, List<Integer> list) {if (target == 0) {ret.add(new ArrayList<>(list));return;}for (int i = start; i < candidates.length; i++) {if (candidates[i] <= target) {list.add(candidates[i]);doCombination(candidates, target - candidates[i], i, list);list.remove(list.size() - 1);}}}

For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
A solution set is:
[[1, 7],[1, 2, 5],[2, 6],[1, 1, 6]
]

private List<List<Integer>> ret;public List<List<Integer>> combinationSum2(int[] candidates, int target) {ret = new ArrayList<>();Arrays.sort(candidates);doCombination(candidates, target, 0, new ArrayList<>(), new boolean[candidates.length]);return ret;
}private void doCombination(int[] candidates, int target, int start, List<Integer> list, boolean[] visited) {if (target == 0) {ret.add(new ArrayList<>(list));return;}for (int i = start; i < candidates.length; i++) {if (i != 0 && candidates[i] == candidates[i - 1] && !visited[i - 1]) continue;if (candidates[i] <= target) {list.add(candidates[i]);visited[i] = true;doCombination(candidates, target - candidates[i], i + 1, list, visited);visited[i] = false;list.remove(list.size() - 1);}}
}

private List<List<Integer>> ret;
private List<Integer> subsetList;public List<List<Integer>> subsets(int[] nums) {ret = new ArrayList<>();subsetList = new ArrayList<>();for (int i = 0; i <= nums.length; i++) {backtracking(0, i, nums);}return ret;
}private void backtracking(int startIdx, int size, int[] nums) {if (subsetList.size() == size) {ret.add(new ArrayList(subsetList));return;}for (int i = startIdx; i < nums.length; i++) {subsetList.add(nums[i]);backtracking(i + 1, size, nums); // startIdx 设为下一个元素，使 subset 中的元素都递增排序subsetList.remove(subsetList.size() - 1);}
}

For example,
If nums = [1,2,2], a solution is:[[2],[1],[1,2,2],[2,2],[1,2],[]
]

private List<List<Integer>> ret;
private List<Integer> subsetList;
private boolean[] visited;public List<List<Integer>> subsetsWithDup(int[] nums) {ret = new ArrayList<>();subsetList = new ArrayList<>();visited = new boolean[nums.length];Arrays.sort(nums);for (int i = 0; i <= nums.length; i++) {backtracking(0, i, nums);}return ret;
}private void backtracking(int startIdx, int size, int[] nums) {if (subsetList.size() == size) {ret.add(new ArrayList(subsetList));return;}for (int i = startIdx; i < nums.length; i++) {if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) continue;subsetList.add(nums[i]);visited[i] = true;backtracking(i + 1, size, nums);visited[i] = false;subsetList.remove(subsetList.size() - 1);}
}

private List<List<String>> ret;public List<List<String>> partition(String s) {ret = new ArrayList<>();doPartion(new ArrayList<>(), s);return ret;
}private void doPartion(List<String> list, String s) {if (s.length() == 0) {ret.add(new ArrayList<>(list));return;}for (int i = 0; i < s.length(); i++) {if (isPalindrome(s, 0, i)) {list.add(s.substring(0, i + 1));doPartion(list, s.substring(i + 1));list.remove(list.size() - 1);}}
}private boolean isPalindrome(String s, int begin, int end) {while (begin < end) {if (s.charAt(begin++) != s.charAt(end--)) return false;}return true;
}

private boolean[][] rowsUsed = new boolean[9][10];
private boolean[][] colsUsed = new boolean[9][10];
private boolean[][] cubesUsed = new boolean[9][10];
private char[][] board;public void solveSudoku(char[][] board) {this.board = board;for (int i = 0; i < 9; i++) {for (int j = 0; j < 9; j++) {if (board[i][j] == '.') continue;int num = board[i][j] - '0';rowsUsed[i][num] = true;colsUsed[j][num] = true;cubesUsed[cubeNum(i, j)][num] = true;}}for (int i = 0; i < 9; i++) {for (int j = 0; j < 9; j++) {backtracking(i, j);}}
}private boolean backtracking(int row, int col) {while (row < 9 && board[row][col] != '.') {row = col == 8 ? row + 1 : row;col = col == 8 ? 0 : col + 1;}if (row == 9) {return true;}for (int num = 1; num <= 9; num++) {if (rowsUsed[row][num] || colsUsed[col][num] || cubesUsed[cubeNum(row, col)][num]) continue;rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = true;board[row][col] = (char) (num + '0');if (backtracking(row, col)) return true;board[row][col] = '.';rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = false;}return false;
}private int cubeNum(int i, int j) {int r = i / 3;int c = j / 3;return r * 3 + c;
}

Input: "2-1-1".((2-1)-1) = 0
(2-(1-1)) = 2Output : [0, 2]

public List<Integer> diffWaysToCompute(String input) {int n = input.length();List<Integer> ret = new ArrayList<>();for (int i = 0; i < n; i++) {char c = input.charAt(i);if (c == '+' || c == '-' || c == '*') {List<Integer> left = diffWaysToCompute(input.substring(0, i));List<Integer> right = diffWaysToCompute(input.substring(i + 1));for (int l : left) {for (int r : right) {switch (c) {case '+': ret.add(l + r); break;case '-': ret.add(l - r); break;case '*': ret.add(l * r); break;}}}}}if (ret.size() == 0) ret.add(Integer.valueOf(input));return ret;
}

public int integerBreak(int n) {int[] dp = new int[n + 1];dp[1] = 1;for(int i = 2; i <= n; i++) {for(int j = 1; j <= i - 1; j++) {dp[i] = Math.max(dp[i], Math.max(j * dp[i - j], j * (i - j)));}}return dp[n];
}

public int numSquares(int n) {List<Integer> squares = new ArrayList<>(); // 存储小于 n 的平方数int diff = 3;while(square <= n) {squares.add(square);square += diff;diff += 2;}int[] dp = new int[n + 1];for(int i = 1; i <= n; i++) {int max = Integer.MAX_VALUE;for(int s : squares) {if(s > i) break;max = Math.min(max, dp[i - s] + 1);}dp[i] = max;}return dp[n];
}

public int numDecodings(String s) {if(s == null || s.length() == 0) return 0;int n = s.length();int[] dp = new int[n + 1];dp[0] = 1;dp[1] = s.charAt(0) == '0' ? 0 : 1;for(int i = 2; i <= n; i++) {int one = Integer.valueOf(s.substring(i - 1, i));if(one != 0) dp[i] += dp[i - 1];if(s.charAt(i - 2) == '0') continue;int two = Integer.valueOf(s.substring(i - 2, i));if(two <= 26) dp[i] += dp[i - 2];}return dp[n];
}

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

public int minPathSum(int[][] grid) {if(grid.length == 0 || grid[0].length == 0) return 0;int m = grid.length, n = grid[0].length;int[] dp = new int[n];for(int i = 0; i < m; i++) {for(int j = 0; j < n; j++) {if(j == 0) dp[0] = dp[0] + grid[i][0];else if(i == 0) dp[j] = dp[j - 1] + grid[0][j];else dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];}}return dp[n - 1];
}

public int climbStairs(int n) {if(n == 1) return 1;if(n == 2) return 2;// 前一个楼梯、后一个楼梯int pre1 = 2, pre2 = 1;for(int i = 2; i < n; i++){int cur = pre1 + pre2;pre2 = pre1;pre1 = cur;}return pre1;
}

public int rob(int[] nums) {int n = nums.length;if(n == 0) return 0;if(n == 1) return nums[0];if(n == 2) return Math.max(nums[0], nums[1]);int[] dp = new int[n];dp[0] = nums[0];dp[1] = nums[1];dp[2] = nums[0] + nums[2];for(int i = 3; i < n; i++){dp[i] = Math.max(dp[i -2], dp[i - 3]) + nums[i];}return Math.max(dp[n - 1], dp[n - 2]);
}

public int rob(int[] nums) {int n = nums.length;if(n == 0) return 0;if(n == 1) return nums[0];if(n == 2) return Math.max(nums[0], nums[1]);int pre3 = nums[0], pre2 = nums[1], pre1 = nums[2] + nums[0];for(int i = 3; i < n; i++){int cur = Math.max(pre2, pre3) + nums[i];pre3 = pre2;pre2 = pre1;pre1 = cur;}return Math.max(pre1, pre2);
}

public int rob(int[] nums) {if(nums == null || nums.length == 0) return 0;int n = nums.length;if(n == 1) return nums[0];return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
}private int rob(int[] nums, int s, int e) {int n = nums.length;if(e - s == 0) return nums[s];if(e - s == 1) return Math.max(nums[s], nums[s + 1]);int[] dp = new int[n];dp[s] = nums[s];dp[s + 1] = nums[s + 1];dp[s + 2] = nums[s] + nums[s + 2];for (int i = s + 3; i <= e; i++) {dp[i] = Math.max(dp[i - 2], dp[i - 3]) + nums[i];}return Math.max(dp[e], dp[e - 1]);
}

public int lengthOfLIS(int[] nums) {int n = nums.length;int[] dp = new int[n];for(int i = 0; i < n; i++){int max = 1;for(int j = 0; j < i; j++){if(nums[i] > nums[j]) max = Math.max(max, dp[j] + 1);}dp[i] = max;}int ret = 0;for(int i = 0; i < n; i++){ret = Math.max(ret, dp[i]);}return ret;
}

len = 1  :      [4], [5], [6], [3]  => tails[0] = 3
len = 2  :      [4, 5], [5, 6]      => tails[1] = 5
len = 3  :      [4, 5, 6]            => tails[2] = 6

public int lengthOfLIS(int[] nums) {int n = nums.length;int[] tails = new int[n];int size = 0;for(int i = 0; i < n; i++){int idx = binarySearch(tails, 0, size, nums[i]);tails[idx] = nums[i];if(idx == size) size++;}return size;
}private int binarySearch(int[] nums, int sIdx, int eIdx, int key){while(sIdx < eIdx){int mIdx = sIdx + (eIdx - sIdx) / 2;if(nums[mIdx] == key) return mIdx;else if(nums[mIdx] > key) eIdx = mIdx;else sIdx = mIdx + 1;}return sIdx;
}

public int wiggleMaxLength(int[] nums) {int len = nums.length;if (len == 0) return 0;int up = 1, down = 1;for (int i = 1; i < len; i++) {if (nums[i] > nums[i - 1]) up = down + 1;else if (nums[i] < nums[i - 1]) down = up + 1;}return Math.max(up, down);
}

public int lengthOfLCS(int[] nums1, int[] nums2) {int n1 = nums1.length, n2 = nums2.length;int[][] dp = new int[n1 + 1][n2 + 1];for (int i = 1; i <= n1; i++) {for (int j = 1; j <= n2; j++) {if (nums1[i - 1] == nums2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);}}return dp[n1][n2];
}

public int knapsack(int W, int N, int[] weights, int[] values) {int[][] dp = new int[N][W];for (int i = W - 1; i >= 0; i--) {dp[0][i] = i > weights[0] ? values[0] : 0;}for (int i = 1; i < N; i++) {for (int j = W - 1; j >= weights[i]; j--) {dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i]);}for (int j = weights[i - 1] - 1; j >= 0; j--) {dp[i][j] = dp[i - 1][j];}}return dp[N - 1][W - 1];
}

public boolean canPartition(int[] nums) {int sum = 0;for (int num : nums) {sum += num;}if (sum % 2 != 0) {return false;}int W = sum / 2;boolean[] dp = new boolean[W + 1];int n = nums.length;for(int i = 0; i <= W; i++) {if(nums[0] == i) dp[i] = true;}for(int i = 1; i < n; i++) {for(int j = W; j >= nums[i]; j--) {dp[j] = dp[j] || dp[j - nums[i]];}}return dp[W];
}

s = "leetcode",
dict = ["leet", "code"].
Return true because "leetcode" can be segmented as "leet code".

public boolean wordBreak(String s, List<String> wordDict) {int n = s.length();boolean[] dp = new boolean[n + 1];dp[0] = true;for (int i = 1; i <= n; i++) {for (String word : wordDict) {if (word.length() <= i&& word.equals(s.substring(i - word.length(), i))) {dp[i] = dp[i] || dp[i - word.length()];}}}return dp[n];
}

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 = 3There are 5 ways to assign symbols to make the sum of nums be target 3.

                  sum(P) - sum(N) = target
sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)2 * sum(P) = target + sum(nums)

public int findTargetSumWays(int[] nums, int S) {int sum = 0;for (int num : nums) {sum += num;}if (sum < S || (sum + S) % 2 == 1) {return 0;}return subsetSum(nums, (sum + S) >>> 1);
}private int subsetSum(int[] nums, int targetSum) {Arrays.sort(nums);int[] dp = new int[targetSum + 1];dp[0] = 1;for (int i = 0; i < nums.length; i++) {int num = nums[i];for (int j = targetSum; j >= num; j--) {dp[j] = dp[j] + dp[j - num];}}return dp[targetSum];
}

Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
Output: 4Explanation: This are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are “10,”0001”,”1”,”0”

public int findMaxForm(String[] strs, int m, int n) {if (strs == null || strs.length == 0) return 0;int l = strs.length;int[][] dp = new int[m + 1][n + 1];for (int i = 0; i < l; i++) {String s = strs[i];int ones = 0, zeros = 0;for (char c : s.toCharArray()) {if (c == '0') zeros++;else if (c == '1') ones++;}for (int j = m; j >= zeros; j--) {for (int k = n; k >= ones; k--) {if (zeros <= j && ones <= k) {dp[j][k] = Math.max(dp[j][k], dp[j - zeros][k - ones] + 1);}}}}return dp[m][n];
}

public int coinChange(int[] coins, int amount) {int[] dp = new int[amount + 1];Arrays.fill(dp, amount + 1);dp[0] = 0;for (int i = 1; i <= amount; i++) {for (int j = 0; j < coins.length; j++) {if (coins[j] <= i) {dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);}}}return dp[amount] > amount ? -1 : dp[amount];
}

nums = [1, 2, 3]
target = 4The possible combination ways are:
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)Note that different sequences are counted as different combinations.Therefore the output is 7.

public int combinationSum4(int[] nums, int target) {int[] dp = new int[target + 1];dp[0] = 1;for (int i = 1; i <= target; i++) {for (int j = 0; j < nums.length; j++) {if(nums[j] <= i) {dp[i] += dp[i - nums[j]];}}}return dp[target];
}

public int maxProfit(int[] prices) {int firstBuy = Integer.MIN_VALUE, firstSell = 0;int secondBuy = Integer.MIN_VALUE, secondSell = 0;for (int curPrice : prices) {if (firstBuy < -curPrice) firstBuy = -curPrice;if (firstSell < firstBuy + curPrice) firstSell = firstBuy + curPrice;if (secondBuy < firstSell - curPrice) secondBuy = firstSell - curPrice;if (secondSell < secondBuy + curPrice) secondSell = secondBuy + curPrice;}return secondSell;
}

dp[i, j] = max(dp[i, j-1], prices[j] - prices[jj] + dp[i-1, jj]) { jj in range of [0, j-1] } = max(dp[i, j-1], prices[j] + max(dp[i-1, jj] - prices[jj]))

public int maxProfit(int k, int[] prices) {int n = prices.length;if (k >= n/2) {int maxPro = 0;for (int i = 1; i < n; i++) {if (prices[i] > prices[i-1])maxPro += prices[i] - prices[i-1];}return maxPro;}int[][] dp = new int[k + 1][n];for (int i = 1; i <= k; i++) {int localMax = dp[i - 1][0] - prices[0];for (int j = 1; j < n; j++) {dp[i][j] = Math.max(dp[i][j - 1], prices[j] + localMax);localMax = Math.max(localMax, dp[i - 1][j] - prices[j]);}}return dp[k][n - 1];
}

class NumArray {int[] nums;public NumArray(int[] nums) {for(int i = 1; i < nums.length; i++)nums[i] += nums[i - 1];this.nums = nums;}public int sumRange(int i, int j) {return i == 0 ? nums[j] : nums[j] - nums[i - 1];}
}

public int maxSubArray(int[] nums) {int n = nums.length;int[] sum = new int[n];sum[0] = nums[0];int max = sum[0];for(int i = 1; i < n; i++){sum[i] = (sum[i-1] > 0 ? sum[i-1] : 0) + nums[i];max = Math.max(max, sum[i]);}return max;
}

A = [1, 2, 3, 4]return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.

public int numberOfArithmeticSlices(int[] A) {int n = A.length;int[] dp = new int[n];for(int i = 2; i < n; i++) {if(A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {dp[i] = dp[i - 1] + 1;}}int ret = 0;for(int cnt : dp) {ret += cnt;}return ret;
}

public int minDistance(String word1, String word2) {int m = word1.length(), n = word2.length();int[][] dp = new int[m + 1][n + 1];for (int i = 0; i <= m; i++) {for (int j = 0; j <= n; j++) {if (i == 0 || j == 0) continue;dp[i][j] = word1.charAt(i - 1) == word2.charAt(j - 1) ? dp[i - 1][j - 1] + 1: Math.max(dp[i][j - 1], dp[i - 1][j]);}}return m + n - 2 * dp[m][n];
}

s0[i] = max(s0[i - 1], s2[i - 1]); // Stay at s0, or rest from s2
s1[i] = max(s1[i - 1], s0[i - 1] - prices[i]); // Stay at s1, or buy from s0
s2[i] = s1[i - 1] + prices[i]; // Only one way from s1

public int maxProfit(int[] prices) {if (prices == null || prices.length == 0) return 0;int n = prices.length;int[] s0 = new int[n];int[] s1 = new int[n];int[] s2 = new int[n];s0[0] = 0;s1[0] = -prices[0];s2[0] = Integer.MIN_VALUE;for (int i = 1; i < n; i++) {s0[i] = Math.max(s0[i - 1], s2[i - 1]);s1[i] = Math.max(s1[i - 1], s0[i - 1] - prices[i]);s2[i] = Math.max(s2[i - 1], s1[i - 1] + prices[i]);}return Math.max(s0[n - 1], s2[n - 1]);
}

    public int[] countBits(int num) {int[] ret = new int[num + 1];for(int i = 1; i <= num; i++){ret[i] = ret[i&(i-1)] + 1;}return ret;}

public int findLongestChain(int[][] pairs) {if(pairs == null || pairs.length == 0) {return 0;}Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));int n = pairs.length;int[] dp = new int[n];Arrays.fill(dp, 1);for(int i = 0; i < n; i++) {for(int j = 0; j < i; j++) {if(pairs[i][0] > pairs[j][1]){dp[i] = Math.max(dp[i], dp[j] + 1);}}}int ret = 0;for(int num : dp) {ret = Math.max(ret, num);}return ret;
}

public int maxProfit(int[] prices) {int n = prices.length;if(n == 0) return 0;int soFarMin = prices[0];int max = 0;for(int i = 1; i < n; i++){if(soFarMin > prices[i]) soFarMin = prices[i];else max = Math.max(max, prices[i] - soFarMin);}return max;
}

public int minSteps(int n) {int[] dp = new int[n + 1];for (int i = 2; i <= n; i++) {dp[i] = i;for (int j = i - 1; j >= 0; j--) {if (i % j == 0) {dp[i] = dp[j] + dp[i / j];break;}}}return dp[n];
}

public int minSteps(int n) {if (n == 1) return 0;for (int i = 2; i <= Math.sqrt(n); i++) {if (n % i == 0) return i + minSteps(n / i);}return n;
}

public int countPrimes(int n) {boolean[] notPrimes = new boolean[n + 1];int cnt = 0;for(int i = 2; i < n; i++){if(notPrimes[i]) continue;cnt++;// 从 i * i 开始，因为如果 k < i，那么 k * i 在之前就已经被去除过了for(long j = (long) i * i; j < n; j += i){notPrimes[(int) j] = true;}}return cnt;
}

int gcd(int a, int b) {if (b == 0) return a;return gcd(b, a % b);
}

int lcm(int a, int b){return a * b / gcd(a, b);
}

public String convertToBase7(int num) {if (num < 0) {return '-' + convertToBase7(-num);}if (num < 7) {return num + "";}return convertToBase7(num / 7) + num % 7;
}

public String toHex(int num) {char[] map = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};if(num == 0) return "0";String ret = "";while(num != 0){ret = map[(num & 0b1111)] + ret;num >>>= 4;}return ret;
}

public int trailingZeroes(int n) {return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
}

public String addBinary(String a, String b) {int i = a.length() - 1, j = b.length() - 1, carry = 0;String str = "";while(i >= 0 || j >= 0){if(i >= 0 && a.charAt(i--) == '1') carry++;if(j >= 0 && b.charAt(j--) == '1') carry++;str = (carry % 2) + str;carry /= 2;}if(carry == 1) str = "1" + str;return str;
}

public String addStrings(String num1, String num2) {StringBuilder sb = new StringBuilder();int carry = 0;for(int i = num1.length() - 1, j = num2.length() - 1; i >= 0 || j >= 0 || carry == 1; i--, j--){int x = i < 0 ? 0 : num1.charAt(i) - '0';int y = j < 0 ? 0 : num2.charAt(j) - '0';sb.append((x + y + carry) % 10);carry = (x + y + carry) / 10;}return sb.reverse().toString();
}

public int minMoves2(int[] nums) {Arrays.sort(nums);int ret = 0;int l = 0, h = nums.length - 1;while(l <= h) {ret += nums[h] - nums[l];l++;h--;}return ret;
}

public int minMoves2(int[] nums) {int ret = 0;int n = nums.length;int median = quickSelect(nums, 0, n - 1, n / 2 + 1);for(int num : nums) ret += Math.abs(num - median);return ret;
}private int quickSelect(int[] nums, int start, int end, int k) {int l = start, r = end, privot = nums[(l + r) / 2];while(l <= r) {while(nums[l] < privot) l++;while(nums[r] > privot) r--;if(l >= r) break;swap(nums, l, r);l++; r--;}int left = l - start + 1;if(left > k) return quickSelect(nums, start, l - 1, k);if(left == k && l == r) return nums[l];int right = r - start + 1;return quickSelect(nums, r + 1, end, k - right);
}private void swap(int[] nums, int i, int j) {int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
}

public int majorityElement(int[] nums) {Arrays.sort(nums);return nums[nums.length / 2];
}

public int majorityElement(int[] nums) {int cnt = 0, majority = 0;for(int i = 0; i < nums.length; i++){if(cnt == 0) {majority = nums[i];cnt++;}else if(majority == nums[i]) cnt++;else cnt--;}return majority;
}

public boolean isPerfectSquare(int num) {int subNum = 1;while (num > 0) {num -= subNum;subNum += 2;}return num == 0;
}

public boolean isPowerOfThree(int n) {return n > 0 && (1162261467 % n == 0);
}

public int maximumProduct(int[] nums) {int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, max3 = Integer.MIN_VALUE, min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;for (int n : nums) {if (n > max1) {max3 = max2;max2 = max1;max1 = n;} else if (n > max2) {max3 = max2;max2 = n;} else if (n > max3) {max3 = n;}if (n < min1) {min2 = min1;min1 = n;} else if (n < min2) {min2 = n;}}return Math.max(max1*max2*max3, max1*min1*min2);
}

public int[] productExceptSelf(int[] nums) {int n = nums.length;int[] ret = new int[n];ret[0] = 1;for(int i = 1; i < n; i++) {ret[i] = ret[i - 1] * nums[i - 1];}int right = 1;for(int i = n - 1; i >= 0; i--) {ret[i] *= right;right *= nums[i];}return ret;
}

class  MyQueue {private Stack<Integer> st = new Stack();public void push(int x) {Stack<Integer> temp = new Stack();while(!st.isEmpty()){temp.push(st.pop());}st.push(x);while(!temp.isEmpty()){st.push(temp.pop());}}public int pop() {return st.pop();}public int peek() {return st.peek();}public boolean empty() {return st.isEmpty();}
}

class  MyQueue {private Stack<Integer> in = new Stack();private Stack<Integer> out = new Stack();public void push(int x) {in.push(x);}public int pop() {in2out();return out.pop();}public int peek() {in2out();return out.peek();}private void in2out(){if(out.isEmpty()){while(!in.isEmpty()){out.push(in.pop());}}}public boolean empty() {return in.isEmpty() && out.isEmpty();}
}

class MyStack {private Queue<Integer> queue;public MyStack() {queue = new LinkedList<>();}public void push(int x) {queue.add(x);for(int i = 1; i < queue.size(); i++){ // 翻转queue.add(queue.remove());}}public int pop() {return queue.remove();}public int top() {return queue.peek();}public boolean empty() {return queue.isEmpty();}
}

class MinStack {private Stack<Integer> dataStack;private Stack<Integer> minStack;private int min;public MinStack() {dataStack = new Stack<>();minStack = new Stack<>();min = Integer.MAX_VALUE;}public void push(int x) {dataStack.add(x);if(x < min) {min = x;}minStack.add(min);}public void pop() {dataStack.pop();minStack.pop();if(!minStack.isEmpty()) {min = minStack.peek();} else{min = Integer.MAX_VALUE;}}public int top() {return dataStack.peek();}public int getMin() {return min;}
}

"()[]{}"Output : true

public boolean isValid(String s) {Stack<Character> stack = new Stack<>();for(int i = 0; i < s.length(); i++){char c = s.charAt(i);if(c == '(' || c == '{' || c == '[') stack.push(c);else{if(stack.isEmpty()) return false;char cStack = stack.pop();if(c == ')' && cStack != '(' ||c == ']' && cStack != '[' ||c == '}' && cStack != '{' ) {return false;}}}return stack.isEmpty();
}

Input: [73, 74, 75, 71, 69, 72, 76, 73]
Output: [1, 1, 4, 2, 1, 1, 0, 0]

public int[] dailyTemperatures(int[] temperatures) {int n = temperatures.length;int[] ret = new int[n];Stack<Integer> stack = new Stack<>();for(int i = 0; i < n; i++) {while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {int idx = stack.pop();ret[idx] = i - idx;}stack.add(i);}return ret;
}

Input: nums1 = [4,1,2], nums2 = [1,3,4,2].
Output: [-1,3,-1]

public int[] nextGreaterElement(int[] nums1, int[] nums2) {Map<Integer, Integer> map = new HashMap<>();Stack<Integer> stack = new Stack<>();for(int num : nums2){while(!stack.isEmpty() && num > stack.peek()){map.put(stack.pop(), num);}stack.add(num);}int[] ret = new int[nums1.length];for(int i = 0; i < nums1.length; i++){if(map.containsKey(nums1[i])) ret[i] = map.get(nums1[i]);else ret[i] = -1;}return ret;
}

public int[] nextGreaterElements(int[] nums) {int n = nums.length, next[] = new int[n];Arrays.fill(next, -1);Stack<Integer> stack = new Stack<>();for (int i = 0; i < n * 2; i++) {int num = nums[i % n];while (!stack.isEmpty() && nums[stack.peek()] < num)next[stack.pop()] = num;if (i < n) stack.push(i);}return next;
}

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

public int findLHS(int[] nums) {Map<Long, Integer> map = new HashMap<>();for (long num : nums) {map.put(num, map.getOrDefault(num, 0) + 1);}int result = 0;for (long key : map.keySet()) {if (map.containsKey(key + 1)) {result = Math.max(result, map.get(key + 1) + map.get(key));}}return result;
}

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

public boolean isIsomorphic(String s, String t) {int[] m1 = new int[256];int[] m2 = new int[256];for(int i = 0; i < s.length(); i++){if(m1[s.charAt(i)] != m2[t.charAt(i)]) {return false;}m1[s.charAt(i)] = i + 1;m2[t.charAt(i)] = i + 1;}return true;
}

public int longestPalindrome(String s) {int[] cnts = new int[128]; // ascii 码总共 128 个for(char c : s.toCharArray()) cnts[c]++;int ret = 0;for(int cnt : cnts)  ret += (cnt / 2) * 2;if(ret < s.length()) ret ++; // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间return ret;
}

public boolean isPalindrome(int x) {if(x == 0) return true;if(x < 0) return false;if(x % 10 == 0) return false;int right = 0;while(x > right){right = right * 10 + x % 10;x /= 10;}return x == right || x == right / 10;
}

private int cnt = 0;
public int countSubstrings(String s) {for(int i = 0; i < s.length(); i++) {extendSubstrings(s, i, i);    // 奇数长度extendSubstrings(s, i, i + 1); // 偶数长度}return cnt;
}private void extendSubstrings(String s, int start, int end) {while(start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {start--;end++;cnt++;}
}

Input: "00110011"
Output: 6
Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".

public int countBinarySubstrings(String s) {int preLen = 0, curLen = 1, ret = 0;for(int i = 1; i < s.length(); i++){if(s.charAt(i) == s.charAt(i-1)) curLen++;else{preLen = curLen;curLen = 1;}if(preLen >= curLen) ret++;}return ret;
}

s1 = AABCD, s2 = CDAA
Return : true

    public void moveZeroes(int[] nums) {int n = nums.length;int idx = 0;for(int i = 0; i < n; i++){if(nums[i] != 0) nums[idx++] = nums[i];}while(idx < n){nums[idx++] = 0;}}

public int[] findErrorNums(int[] nums) {for(int i = 0; i < nums.length; i++){while(nums[i] != i + 1 && nums[i] != nums[nums[i] - 1]) swap(nums, i, nums[i] - 1);}for(int i = 0; i < nums.length; i++){if(i + 1 != nums[i]) return new int[]{nums[i], i + 1};}return null;
}private void swap(int[] nums, int i, int j){int tmp = nums[i];nums[i] = nums[j];nums[j] = tmp;
}

public int findDuplicate(int[] nums) {int l = 1, h = nums.length - 1;while (l <= h) {int mid = l + (h - l) / 2;int cnt = 0;for (int i = 0; i < nums.length; i++) {if (nums[i] <= mid) cnt++;}if (cnt > mid) h = mid - 1;else l = mid + 1;}return l;
}

public int findDuplicate(int[] nums) {int slow = nums[0], fast = nums[nums[0]];while (slow != fast) {slow = nums[slow];fast = nums[nums[fast]];}fast = 0;while (slow != fast) {slow = nums[slow];fast = nums[fast];}return slow;
}

[[ 1,  5,  9],[10, 11, 13],[12, 13, 15]
]

public boolean searchMatrix(int[][] matrix, int target) {if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;int m = matrix.length, n = matrix[0].length;int row = 0, col = n - 1;while (row < m && col >= 0) {if (target == matrix[row][col]) return true;else if (target < matrix[row][col]) col--;else row++;}return false;
}

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

public int kthSmallest(int[][] matrix, int k) {int m = matrix.length, n = matrix[0].length;int lo = matrix[0][0], hi = matrix[m - 1][n - 1];while(lo <= hi) {int mid = lo + (hi - lo) / 2;int cnt = 0;for(int i = 0; i < m; i++) {for(int j = 0; j < n && matrix[i][j] <= mid; j++) {cnt++;}}if(cnt < k) lo = mid + 1;else hi = mid - 1;}return lo;
}

public int kthSmallest(int[][] matrix, int k) {int m = matrix.length, n = matrix[0].length;PriorityQueue<Tuple> pq = new PriorityQueue<Tuple>();for(int j = 0; j < n; j++) pq.offer(new Tuple(0, j, matrix[0][j]));for(int i = 0; i < k - 1; i++) { // 小根堆，去掉 k - 1 个堆顶元素，此时堆顶元素就是第 k 的数Tuple t = pq.poll();if(t.x == m - 1) continue;pq.offer(new Tuple(t.x + 1, t.y, matrix[t.x + 1][t.y]));}return pq.poll().val;
}class Tuple implements Comparable<Tuple> {int x, y, val;public Tuple(int x, int y, int val) {this.x = x; this.y = y; this.val = val;}@Overridepublic int compareTo(Tuple that) {return this.val - that.val;}
}

A:          a1 → a2↘c1 → c2 → c3↗
B:    b1 → b2 → b3

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {if(headA == null || headB == null) return null;ListNode l1 = headA, l2 = headB;while(l1 != l2){l1 = (l1 == null) ? headB : l1.next;l2 = (l2 == null) ? headA : l2.next;}return l1;
}

public ListNode reverseList(ListNode head) {ListNode newHead = null; // 设为 null ，作为新链表的结尾while(head != null){ListNode nextNode = head.next;head.next = newHead;newHead = head;head = nextNode;}return newHead;
}

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {if(l1 == null) return l2;if(l2 == null) return l1;ListNode newHead = null;if(l1.val < l2.val){newHead = l1;newHead.next = mergeTwoLists(l1.next, l2);} else{newHead = l2;newHead.next = mergeTwoLists(l1, l2.next);}return newHead;
}

public ListNode deleteDuplicates(ListNode head) {if(head == null || head.next == null) return head;head.next = deleteDuplicates(head.next);return head.next != null && head.val == head.next.val ? head.next : head;
}

public boolean isPalindrome(ListNode head) {if(head == null || head.next == null) return true;ListNode slow = head, fast = head.next;while(fast != null && fast.next != null){slow = slow.next;fast = fast.next.next;}if(fast != null){  // 偶数节点，让 slow 指向下一个节点slow = slow.next;}cut(head, slow); // 切成两个链表ListNode l1 = head, l2 = slow;l2 = reverse(l2);return isEqual(l1, l2);
}private void cut(ListNode head, ListNode cutNode){while( head.next != cutNode ) head = head.next;head.next = null;
}private ListNode reverse(ListNode head){ListNode newHead = null;while(head != null){ListNode nextNode = head.next;head.next = newHead;newHead = head;head = nextNode;}return newHead;
}private boolean isEqual(ListNode l1, ListNode l2){while(l1 != null && l2 != null){if(l1.val != l2.val) return false;l1 = l1.next;l2 = l2.next;}return true;
}

B.val = C.val;
B.next = C.next;

public ListNode oddEvenList(ListNode head) {if (head == null) {return head;}ListNode odd = head, even = head.next, evenHead = even;while (even != null && even.next != null) {odd.next = odd.next.next;odd = odd.next;even.next = even.next.next;even = even.next;}odd.next = evenHead;return head;
}

public int maxDepth(TreeNode root) {if(root == null) return 0;return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}

public TreeNode invertTree(TreeNode root) {if(root == null) return null;TreeNode left = root.left; // 后面的操作会改变 left 指针，因此先保存下来root.left = invertTree(root.right);root.right = invertTree(left);return root;
}

public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {if(t1 == null && t2 == null) return null;if(t1 == null) return t2;if(t2 == null) return t1;TreeNode root = new TreeNode(t1.val + t2.val);root.left = mergeTrees(t1.left, t2.left);root.right = mergeTrees(t1.right, t2.right);return root;
}

public boolean hasPathSum(TreeNode root, int sum) {if(root == null) return false;if(root.left == null && root.right == null && root.val == sum) return true;return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
}

public int pathSum(TreeNode root, int sum) {if(root == null) return 0;int ret = pathSumStartWithRoot(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);return ret;
}private int pathSumStartWithRoot(TreeNode root, int sum){if(root == null) return 0;int ret = 0;if(root.val == sum) ret++;ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);return ret;
}

public boolean isSymmetric(TreeNode root) {if(root == null) return true;return isSymmetric(root.left, root.right);
}private boolean isSymmetric(TreeNode t1, TreeNode t2){if(t1 == null && t2 == null) return true;if(t1 == null || t2 == null) return false;if(t1.val != t2.val) return false;return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
}

private boolean result = true;public boolean isBalanced(TreeNode root) {maxDepth(root);return result;
}public int maxDepth(TreeNode root) {if (root == null) return 0;int l = maxDepth(root.left);int r = maxDepth(root.right);if (Math.abs(l - r) > 1) result = false;return 1 + Math.max(l, r);
}

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 left + right + 1;return Math.min(left, right) + 1;
}

public int sumOfLeftLeaves(TreeNode root) {if(root == null) return 0;if(isLeaf(root.left)) return root.left.val +  sumOfLeftLeaves(root.right);return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
}private boolean isLeaf(TreeNode node){if(node == null) return false;return node.left == null && node.right == null;
}

public TreeNode trimBST(TreeNode root, int L, int R) {if(root == null) return null;if(root.val > R) return trimBST(root.left, L, R);if(root.val < L) return trimBST(root.right, L, R);root.left = trimBST(root.left, L, R);root.right = trimBST(root.right, L, R);return root;
}

public boolean isSubtree(TreeNode s, TreeNode t) {if(s == null && t == null) return true;if(s == null || t == null) return false;if(s.val == t.val && isSame(s, t)) return true;return isSubtree(s.left, t) || isSubtree(s.right, t);
}private boolean isSame(TreeNode s, TreeNode t){if(s == null && t == null) return true;if(s == null || t == null) return false;if(s.val != t.val) return false;return isSame(s.left, t.left) && isSame(s.right, t.right);
}

public TreeNode sortedArrayToBST(int[] nums) {return toBST(nums, 0, nums.length - 1);
}private TreeNode toBST(int[] nums, int sIdx, int eIdx){if(sIdx > eIdx) return null;int mIdx = (sIdx + eIdx) / 2;TreeNode root = new TreeNode(nums[mIdx]);root.left =  toBST(nums, sIdx, mIdx - 1);root.right = toBST(nums, mIdx + 1, eIdx);return root;
}

          1/ \2  3/ \4  5Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].

private int max = 0;public int diameterOfBinaryTree(TreeNode root) {depth(root);return max;
}private int depth(TreeNode root) {if (root == null) {return 0;}int leftDepth = depth(root.left);int rightDepth = depth(root.right);max = Math.max(max, leftDepth + rightDepth);return Math.max(leftDepth, rightDepth) + 1;
}

Input:2/ \2  5/ \5  7Output: 5

public int findSecondMinimumValue(TreeNode root) {if(root == null) return -1;if(root.left == null && root.right == null) return -1;int leftVal = root.left.val;int rightVal = root.right.val;if(leftVal == root.val) leftVal = findSecondMinimumValue(root.left);if(rightVal == root.val) rightVal = findSecondMinimumValue(root.right);if(leftVal != -1 && rightVal != -1) return Math.min(leftVal, rightVal);if(leftVal != -1) return leftVal;return rightVal;
}

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {if(root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);if(root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);return root;
}

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {if (root == null || root == p || root == q) return root;TreeNode left = lowestCommonAncestor(root.left, p, q);TreeNode right = lowestCommonAncestor(root.right, p, q);return left == null ? right : right == null ? left : root;
}

              1/ \4  5/ \  \4  4  5Output : 2

private int path = 0;
public int longestUnivaluePath(TreeNode root) {dfs(root);return path;
}private int dfs(TreeNode root){if(root == null) return 0;int left = dfs(root.left);int right = dfs(root.right);int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;path = Math.max(path, leftPath + rightPath);return Math.max(leftPath, rightPath);
}

public int rob(TreeNode root) {if (root == null) return 0;int val1 = root.val;if (root.left != null) {val1 += rob(root.left.left) + rob(root.left.right);}if (root.right != null) {val1 += rob(root.right.left) + rob(root.right.right);}int val2 = rob(root.left) + rob(root.right);return Math.max(val1, val2);
}

public List<Double> averageOfLevels(TreeNode root) {List<Double> ret = new ArrayList<>();if(root == null) return ret;Queue<TreeNode> queue = new LinkedList<>();queue.add(root);while(!queue.isEmpty()){int cnt = queue.size();double sum = 0;for(int i = 0; i < cnt; i++){TreeNode node = queue.poll();sum += node.val;if(node.left != null) queue.add(node.left);if(node.right != null) queue.add(node.right);}ret.add(sum / cnt);}return ret;
}

public int findBottomLeftValue(TreeNode root) {Queue<TreeNode> queue = new LinkedList<>();queue.add(root);while(!queue.isEmpty()){root = queue.poll();if(root.right != null) queue.add(root.right);if(root.left != null) queue.add(root.left);}return root.val;
}

   1/ \2  3/ \  \
4  5  6

void dfs(TreeNode root){visit(root);dfs(root.left);dfs(root.right);
}

void dfs(TreeNode root){dfs(root.left);visit(root);dfs(root.right);
}

void dfs(TreeNode root){dfs(root.left);dfs(root.right);visit(root);
}

public List<Integer> preorderTraversal(TreeNode root) {List<Integer> ret = new ArrayList<>();if (root == null) return ret;Stack<TreeNode> stack = new Stack<>();stack.push(root);while (!stack.isEmpty()) {TreeNode node = stack.pop();ret.add(node.val);if (node.right != null) stack.push(node.right);if (node.left != null) stack.push(node.left); // 先添加右子树再添加左子树，这样是为了让左子树在栈顶}return ret;
}

public List<Integer> postorderTraversal(TreeNode root) {List<Integer> ret = new ArrayList<>();if (root == null) return ret;Stack<TreeNode> stack = new Stack<>();stack.push(root);while (!stack.isEmpty()) {TreeNode node = stack.pop();ret.add(node.val);if (node.left != null) stack.push(node.left);if (node.right != null) stack.push(node.right);}Collections.reverse(ret);return ret;
}

public List<Integer> inorderTraversal(TreeNode root) {List<Integer> ret = new ArrayList<>();Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;while(cur != null || !stack.isEmpty()) {while(cur != null) { // 模拟递归栈的不断深入stack.add(cur);cur = cur.left;}TreeNode node = stack.pop();ret.add(node.val);cur = node.right;}return ret;
}

public boolean findTarget(TreeNode root, int k) {List<Integer> nums = new ArrayList<>();inOrder(root, nums);int i = 0, j = nums.size() - 1;while(i < j){int sum = nums.get(i) + nums.get(j);if(sum == k) return true;if(sum < k) i++;else j--;}return false;
}private void inOrder(TreeNode root, List<Integer> nums){if(root == null) return;inOrder(root.left, nums);nums.add(root.val);inOrder(root.right, nums);
}

private int minDiff = Integer.MAX_VALUE;
private int preVal = -1;public int getMinimumDifference(TreeNode root) {inorder(root);return minDiff;
}private void inorder(TreeNode node){if(node == null) return;inorder(node.left);if(preVal != -1) minDiff = Math.min(minDiff, Math.abs(node.val - preVal));preVal = node.val;inorder(node.right);
}

private int sum = 0;public TreeNode convertBST(TreeNode root) {traver(root);return root;
}private void traver(TreeNode root) {if (root == null) {return;}if (root.right != null) {traver(root.right);}sum += root.val;root.val = sum;if (root.left != null) {traver(root.left);}
}

private int cnt = 1;
private int maxCnt = 1;
private TreeNode preNode = null;
private List<Integer> list;public int[] findMode(TreeNode root) {list = new ArrayList<>();inorder(root);int[] ret = new int[list.size()];int idx = 0;for(int num : list){ret[idx++] = num;}return ret;
}private void inorder(TreeNode node){if(node == null) return;inorder(node.left);if(preNode != null){if(preNode.val == node.val) cnt++;else cnt = 1;}if(cnt > maxCnt){maxCnt = cnt;list.clear();list.add(node.val);} else if(cnt == maxCnt){list.add(node.val);}preNode = node;inorder(node.right);
}

public int kthSmallest(TreeNode root, int k) {int leftCnt = count(root.left);if(leftCnt == k - 1) return root.val;if(leftCnt > k - 1) return kthSmallest(root.left, k);return kthSmallest(root.right, k - leftCnt - 1);
}private int count(TreeNode node) {if(node == null) return 0;return 1 + count(node.left) + count(node.right);
}

private int cnt = 0;
private int val;public int kthSmallest(TreeNode root, int k) {inorder(root, k);return val;
}private void inorder(TreeNode node, int k) {if(node == null) return;inorder(node.left, k);cnt++;if(cnt == k) {val = node.val;return;}inorder(node.right, k);
}

class Trie {private class Node{Node[] childs = new Node[26];boolean isLeaf;}private Node root = new Node();/** Initialize your data structure here. */public Trie() {}/** Inserts a word into the trie. */public void insert(String word) {int idx = word.charAt(0) - 'a';insert(word, root);}private void insert(String word, Node node){int idx = word.charAt(0) - 'a';if(node.childs[idx] == null){node.childs[idx] = new Node();}if(word.length() == 1) node.childs[idx].isLeaf = true;else insert(word.substring(1), node.childs[idx]);}/** Returns if the word is in the trie. */public boolean search(String word) {return search(word, root); }private boolean search(String word, Node node){if(node == null) return false;int idx = word.charAt(0) - 'a';if(node.childs[idx] == null) return false;if(word.length() == 1) return node.childs[idx].isLeaf;return search(word.substring(1), node.childs[idx]);}/** Returns if there is any word in the trie that starts with the given prefix. */public boolean startsWith(String prefix) {return startWith(prefix, root);}private boolean startWith(String prefix, Node node){if(node == null) return false;if(prefix.length() == 0) return true;int idx = prefix.charAt(0) - 'a';return startWith(prefix.substring(1), node.childs[idx]);}
}

class MapSum {private class Trie {int val;Map<Character, Trie> childs;boolean isWord;Trie() {childs = new HashMap<>();}}private Trie root;public MapSum() {root = new Trie();}public void insert(String key, int val) {Trie cur = root;for(char c : key.toCharArray()) {if(!cur.childs.containsKey(c)) {Trie next = new Trie();cur.childs.put(c, next);}cur = cur.childs.get(c);}cur.val = val;cur.isWord = true;}public int sum(String prefix) {Trie cur = root;for(char c : prefix.toCharArray()) {if(!cur.childs.containsKey(c)) return 0;cur = cur.childs.get(c);}return dfs(cur);}private int dfs(Trie cur) {int sum = 0;if(cur.isWord) {sum += cur.val;}for(Trie next : cur.childs.values()) {sum += dfs(next);}return sum;}
}

(num & (1 << i)) != 0;

num | (1 << i);

num & (\~(1 << i))

num & ((1 << i) - 1);

num & (\~((1 << (i+1)) - 1));

(num & (1 << i)) | (v << i);

static int Integer.bitCount()            // 统计 1 的数量
static int Integer.highestOneBit()       // 获得最高位
static String toBinaryString(int i)      // 转换位二进制表示的字符串

public int hammingDistance(int x, int y) {int z = x ^ y;int cnt = 0;while(z != 0){if((z & 1) == 1) cnt++;z = z >> 1;}return cnt;
}

public int hammingDistance(int x, int y) {return Integer.bitCount(x ^ y);
}

public int reverseBits(int n) {int ret = 0;for(int i = 0; i < 32; i++){ret <<= 1;ret |= (n & 1);n >>>= 1;}return ret;
}

a = a ^ b;
b = a ^ b;
a = a ^ b;

public boolean isPowerOfFour(int num) {int i = 1;while(i > 0){if(i == num) return true;i = i << 2;}return false;
}

public boolean isPowerOfFour(int num) {return Integer.toString(num, 4).matches("10*");
}

public boolean isPowerOfTwo(int n) {return n > 0 && Integer.bitCount(n) == 1;
}

public boolean isPowerOfTwo(int n) {return n > 0 && (n & (n - 1)) == 0;
}

public int singleNumber(int[] nums) {int ret = 0;for(int n : nums) ret = ret ^ n;return ret;
}

public int[] singleNumber(int[] nums) {int diff = 0;for(int num : nums) diff ^= num;// 得到最右一位diff &= -diff;int[] ret = new int[2];for(int num : nums) {if((num & diff) == 0) ret[0] ^= num;else ret[1] ^= num;}return ret;
}

public boolean hasAlternatingBits(int n) {int a = (n ^ (n >> 1));return (a & (a + 1)) == 0;
}

public int findComplement(int num) {if(num == 0) return 1;int mask = 1 << 30;while((num & mask) == 0) mask >>= 1;mask = (mask << 1) - 1;return num ^ mask;
}

public int findComplement(int num) {if(num == 0) return 1;int mask = Integer.highestOneBit(num);mask = (mask << 1) - 1;return num ^ mask;
}

mask |= mask >> 1    11000000
mask |= mask >> 2    11110000
mask |= mask >> 4    11111111

public int findComplement(int num) {int mask = num;mask |= mask >> 1;mask |= mask >> 2;mask |= mask >> 4;mask |= mask >> 8;mask |= mask >> 16;return (mask ^ num);
}

public int getSum(int a, int b) {return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
}

public int maxProduct(String[] words) {int n = words.length;if (n == 0) return 0;int[] val = new int[n];for (int i = 0; i < n; i++) {for (char c : words[i].toCharArray()) {val[i] |= 1 << (c - 'a');}}int ret = 0;for (int i = 0; i < n; i++) {for (int j = i + 1; j < n; j++) {if ((val[i] & val[j]) == 0) {ret = Math.max(ret, words[i].length() * words[j].length());}}}return ret;
}