public void merge(int[] nums1, int m, int[] nums2, int n) {int p1 = 0, p2 = 0;int[] sorted = new int[m + n];while (p1 < m || p2 < n) {int current;if (p1 == m) {current = nums2[p2++];} else if (p2 == n) {current = nums1[p1++];} else if (nums1[p1] < nums2[p2]) {current = nums1[p1++];} else {current = nums2[p2++];}sorted[p1 + p2 - 1] = current;}for (int i = 0; i < sorted.length; ++i) {nums1[i] = sorted[i];}}

    public int removeElement(int[] nums, int val) {int left = 0;for (int right = 0; right < nums.length; ++right) {if (nums[right] != val) {if (left != right) {nums[left] = nums[right];}left++;}}return left;}

    public int removeDuplicates(int[] nums) {int i = 1;for (int j = 1; j < nums.length; ++j) {if (nums[i - 1] != nums[j]) {nums[i] = nums[j];i++;}}return i;}

    public int removeDuplicates(int[] nums) {if (nums.length < 2) {return nums.length;}int i = 2;for (int j = 2; j < nums.length; ++j) {if (nums[i - 2] != nums[j]) {nums[i] = nums[j];i++;}}return i;}

    public void rotate(int[] nums, int k) {k %= nums.length;reverse(nums, 0, nums.length - 1);reverse(nums, 0, k - 1);reverse(nums, k, nums.length - 1);}private void reverse(int[] nums, int start, int end) {while (start < end) {int tmp = nums[start];nums[start] = nums[end];nums[end] = tmp;start++;end--;}}

    public List<List<Integer>> threeSum(int[] nums) {List<List<Integer>> result = new ArrayList<>();if (nums.length == 0) {return result;}Arrays.sort(nums);for (int k = 0; k < nums.length - 2; ++k) {if (k > 0 && nums[k - 1] == nums[k]) {continue;}int i = k + 1, j = nums.length - 1;while (i < j) {int sum = nums[k] + nums[i] + nums[j];if (sum > 0) {while (i < j && nums[j] == nums[--j]) ;} else if (sum < 0) {while (i < j && nums[i] == nums[++i]) ;} else {result.add(Arrays.asList(nums[k], nums[i], nums[j]));while (i < j && nums[i] == nums[++i]) ;while (i < j && nums[j] == nums[--j]) ;}}}return result;}

    public int[] plusOne(int[] digits) {for (int i = digits.length - 1; i >= 0; --i) {digits[i] = (digits[i] + 1) % 10;if (digits[i] != 0) {return digits;}}digits = new int[digits.length + 1];digits[0] = 1;return digits;}

class RandomizedSet {private List<Integer> nums;private Map<Integer, Integer> indices;private Random random;public RandomizedSet() {this.nums = new ArrayList<>();this.indices = new HashMap<>();this.random = new Random();}public boolean insert(int val) {if (indices.containsKey(val)) {return false;}int index = nums.size();nums.add(val);indices.put(val, index);return true;}public boolean remove(int val) {if (!indices.containsKey(val)) {return false;}int index = indices.get(val);int last = nums.get(nums.size() - 1);nums.set(index, last);indices.put(last, index);nums.remove(nums.size() - 1);indices.remove(val);return true;}public int getRandom() {int randomIndex = random.nextInt(nums.size());return nums.get(randomIndex);}
}

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

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

    public int maxArea(int[] height) {int maxArea = 0;for (int i = 0, j = height.length - 1; i < j; ) {int minHeight = height[i] < height[j] ? height[i++] : height[j--];maxArea = Math.max(maxArea, minHeight * (j - i + 1));}return maxArea;}

思路：

1. 先找出最大的索引i满足nums[i]<nums[i+1]，如果不存在，就翻转整个数组
2. 再找出另一个最大索引j满足nums[j]>nums[i]
3. 交换nums[i]和nums[j]
4. 最后翻转nums[i+1:]

    public void nextPermutation(int[] nums) {int i = nums.length - 2;while (i >= 0 && nums[i] >= nums[i + 1]) {i--;}if (i >= 0) {int j = nums.length - 1;while (nums[i] >= nums[j]) {j--;}swap(nums, i, j);}reverse(nums, i + 1);}private void swap(int[] nums, int i, int j) {int tmp = nums[i];nums[i] = nums[j];nums[j] = tmp;}private void reverse(int[] nums, int i) {int j = nums.length - 1;while (i < j) {swap(nums, i, j);i++;j--;}}

    public void reverseString(char[] s) {int i = 0, j = s.length - 1;while (i < j) {char tmp = s[i];s[i] = s[j];s[j] = tmp;i++;j--;}}

    public String longestCommonPrefix(String[] strs) {if (strs == null || strs.length == 0) {return "";}for (int i = 0; i < strs[0].length(); ++i) {char c = strs[0].charAt(i);for (int j = 1; j < strs.length; ++j) {if (i == strs[j].length() || strs[j].charAt(i) != c) {return strs[0].substring(0, i);}}}return strs[0];}

    public boolean isSubsequence(String s, String t) {int i = 0, j = 0;while (i < s.length() && j < t.length()) {if (s.charAt(i) == t.charAt(j)) {i++;}j++;}return i >= s.length();}

    public int lengthOfLastWord(String s) {int end = s.length() - 1;while (end >= 0 && s.charAt(end) == ' ') {end--;}if (end < 0) {return 0;}int start = end;while (start >= 0 && s.charAt(start) != ' ') {start--;}return end - start;}

    public String reverseWords(String s) {String[] strs = s.trim().split(" ");StringBuilder res = new StringBuilder();for (int i = strs.length - 1; i >= 0; i--) {if (strs[i].equals("")) {continue;}res.append(strs[i] + " ");}return res.toString().trim();}

    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {ListNode dummy = new ListNode(-1);ListNode current = dummy;int carry = 0;while (l1 != null || l2 != null) {int p = l1 == null ? 0 : l1.val;int q = l2 == null ? 0 : l2.val;int sum = p + q + carry;carry = sum / 10;current.next = new ListNode(sum % 10);current = current.next;if (l1 != null) {l1 = l1.next;}if (l2 != null) {l2 = l2.next;}}if (carry > 0) {current.next = new ListNode(carry);}return dummy.next;}

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {ListNode dummy = new ListNode(-1);ListNode current = dummy;while (l1 != null && l2 != null) {if (l1.val < l2.val) {current.next = l1;l1 = l1.next;} else {current.next = l2;l2 = l2.next;}current = current.next;}if (l1 != null) {current.next = l1;}if (l2 != null) {current.next = l2;}return dummy.next;}

    public ListNode removeNthFromEnd(ListNode head, int n) {ListNode fast = head, slow = head;for (int i = 0; i < n + 1; ++i) {if (fast == null) {return head.next;}fast = fast.next;}while (fast != null) {fast = fast.next;slow = slow.next;}slow.next = slow.next.next;return head;}

    public ListNode deleteDuplicates(ListNode head) {ListNode current = head;while (current != null && current.next != null) {if (current.val == current.next.val) {current.next = current.next.next;} else {current = current.next;}}return head;}

    public ListNode deleteDuplicates(ListNode head) {if (head == null) {return head;}ListNode dummy = new ListNode(-1, head);ListNode current = dummy;while (current.next != null && current.next.next != null) {if (current.next.val == current.next.next.val) {int x = current.next.val;while (current.next != null && current.next.val == x) {current.next = current.next.next;}} else {current = current.next;}}return dummy.next;}

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

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

    public ListNode reverseList(ListNode head) {ListNode pre = null, next = null;while (head != null) {next = head.next;head.next = pre;pre = head;head = next;}return pre;}

    public ListNode reverseBetween(ListNode head, int left, int right) {ListNode dummy = new ListNode(-1, head);ListNode preStart = dummy;for (int i = 0; i < left - 1; ++i) {preStart = preStart.next;}ListNode start = preStart.next;ListNode end = start;for (int i = 0; i < right - left; ++i) {end = end.next;}ListNode endNext = end.next;preStart.next = null;end.next = null;preStart.next = reverse(start);start.next = endNext;return dummy.next;}private ListNode reverse(ListNode node) {ListNode pre = null, next = null;while (node != null) {next = node.next;node.next = pre;pre = node;node = next;}return pre;}

    public ListNode reverseKGroup(ListNode head, int k) {ListNode dummy = new ListNode(-1, head);ListNode pre = dummy, end = dummy;while (end.next != null) {for (int i = 0; i < k && end != null; ++i) {end = end.next;}if (end == null) {break;}ListNode start = pre.next, endNext = end.next;pre.next = null;end.next = null;pre.next = reverse(start);start.next = endNext;pre = start;end = start;}return dummy.next;}private ListNode reverse(ListNode node) {ListNode pre = null, next = null;while (node != null) {next = node.next;node.next = pre;pre = node;node = next;}return pre;}

    public ListNode rotateRight(ListNode head, int k) {if (head == null || head.next == null || k == 0) {return head;}ListNode current = head;int len = 0;while (current != null) {current = current.next;len++;}k = k % len;if (k == 0) {return head;}ListNode fast = head, slow = head;for (int i = 0; i < k + 1; ++i) {fast = fast.next;}while (fast != null) {fast = fast.next;slow = slow.next;}ListNode newHead = slow.next;slow.next = null;ListNode node = newHead;while (node.next != null) {node = node.next;}node.next = head;return newHead;}

    public ListNode partition(ListNode head, int x) {if (head == null) {return head;}ListNode leftDummy = new ListNode(-1);ListNode left = leftDummy;ListNode rightDummy = new ListNode(-1);ListNode right = rightDummy;ListNode current = head;while (current != null) {if (current.val < x) {left.next = current;left = left.next;} else {right.next = current;right = right.next;}current = current.next;}right.next = null;left.next = rightDummy.next;return leftDummy.next;}

    public void reorderList(ListNode head) {if (head == null) {return;}ListNode mid = middleNode(head);ListNode l1 = head;ListNode l2 = mid.next;mid.next = null;l2 = reverseListNode(l2);mergeListNode(l1, l2);}private ListNode middleNode(ListNode head) {ListNode slow = head, fast = head;while (fast.next != null && fast.next.next != null) {slow = slow.next;fast = fast.next.next;}return slow;}private ListNode reverseListNode(ListNode node) {ListNode current = node, pre = null, next = null;while (current != null) {next = current.next;current.next = pre;pre = current;current = next;}return pre;}private void mergeListNode(ListNode l1, ListNode l2) {ListNode l1Tmp;ListNode l2Tmp;while (l1 != null && l2 != null) {l1Tmp = l1.next;l2Tmp = l2.next;l1.next = l2;l1 = l1Tmp;l2.next = l1;l2 = l2Tmp;}}

    public boolean isValid(String s) {Stack<Character> stack = new Stack<>();char[] array = s.toCharArray();for (char c : array) {if (stack.isEmpty()) {stack.add(c);} else if (check(stack.peek(), c)) {stack.pop();} else {stack.add(c);}}return stack.isEmpty();}private boolean check(char c1, char c2) {return (c1 == '(' && c2 == ')') || (c1 == '{' && c2 == '}') || (c1 == '[' && c2 == ']');}

class MyStack {private Queue<Integer> q1;private Queue<Integer> q2;private int top;public MyStack() {this.q1 = new LinkedList<>();this.q2 = new LinkedList<>();}public void push(int x) {top = x;q1.offer(x);}public int pop() {while (q1.size() > 1) {top = q1.poll();q2.offer(top);}int result = q1.poll();Queue<Integer> tmp = q1;q1 = q2;q2 = tmp;return result;}public int top() {return top;}public boolean empty() {return q1.isEmpty();}
}

class MinStack {private Stack<Integer> stack;private Stack<Integer> minStack;public MinStack() {this.stack = new Stack<>();this.minStack = new Stack<>();}public void push(int val) {stack.add(val);if (!minStack.isEmpty() && val > minStack.peek()) {minStack.add(minStack.peek());} else {minStack.add(val);}}public void pop() {stack.pop();minStack.pop();}public int top() {return stack.peek();}public int getMin() {return minStack.peek();}
}

思路：小顶堆

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

    public int lengthOfLongestSubstring(String s) {int i = 0, j = 0, result = 0, n = s.length();Set<Character> set = new HashSet<>();while (i < n && j < n) {if (!set.contains(s.charAt(i))) {set.add(s.charAt(i++));result = Math.max(result, i - j);} else {set.remove(s.charAt(j++));}}return result;}

    public int longestConsecutive(int[] nums) {Set<Integer> numSet = new HashSet<>();for (int num : nums) {numSet.add(num);}int result = 0, seqLen = 0;for (int num : numSet) {if (!numSet.contains(num - 1)) {seqLen = 1;while (numSet.contains(++num)) {seqLen++;}result = Math.max(seqLen, result);}}return result;}

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

    public int majorityElement(int[] nums) {Map<Integer, Integer> countMap = count(nums);Map.Entry<Integer, Integer> map = null;for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {if (map == null || entry.getValue() > map.getValue()) {map = entry;}}return map.getKey();}private Map<Integer, Integer> count(int[] nums) {Map<Integer, Integer> result = new HashMap<>();for (int num : nums) {result.put(num, result.getOrDefault(num, 0) + 1);}return result;}

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

    public List<List<String>> groupAnagrams(String[] strs) {Map<String, List<String>> map = new HashMap<>();for (String str : strs) {char[] array = str.toCharArray();Arrays.sort(array);String s = String.valueOf(array);if (map.containsKey(s)) {map.get(s).add(str);} else {List<String> tmpList = new ArrayList<>();tmpList.add(str);map.put(s, tmpList);}}return new ArrayList<>(map.values());}

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

    public int minSubArrayLen(int target, int[] nums) {int start = 0, end = 0, sum = 0, n = nums.length, result = Integer.MAX_VALUE;while (end < n) {sum += nums[end];while (sum >= target) {result = Math.min(end - start + 1, result);sum -= nums[start];start++;}end++;}return result == Integer.MAX_VALUE ? 0 : result;}

思路：哈希表+双向链表

class LRUCache {private int capacity;private Map<Integer, Integer> cache;private LinkedList<Integer> keys;public LRUCache(int capacity) {this.capacity = capacity;this.cache = new HashMap<>();this.keys = new LinkedList<>();}public int get(int key) {if (!cache.containsKey(key)) {return -1;}int result = cache.get(key);put(key, result);return result;}public void put(int key, int value) {if (cache.containsKey(key)) {keys.remove((Integer) key);} else if (keys.size() >= capacity) {Integer old = keys.removeFirst();cache.remove(old);}cache.put(key, value);keys.addLast(key);}
}

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

    public boolean isSameTree(TreeNode p, TreeNode q) {if (p == null) {return q == null;}return q != null && p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);}

    public TreeNode invertTree(TreeNode root) {if (root == null) {return root;}TreeNode left = invertTree(root.left);TreeNode right = invertTree(root.right);root.left = right;root.right = left;return root;}

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

    public void flatten(TreeNode root) {if (root == null) {return;}List<TreeNode> nodeList = new ArrayList<>();inorder(root, nodeList);for (int i = 1; i < nodeList.size(); ++i) {TreeNode last = nodeList.get(i - 1);TreeNode current = nodeList.get(i);last.left = null;last.right = current;}}private void inorder(TreeNode node, List<TreeNode> nodeList) {if (node == null) {return;}nodeList.add(node);inorder(node.left, nodeList);inorder(node.right, nodeList);}

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

    public int sumNumbers(TreeNode root) {return helper(root, 0);}private int helper(TreeNode node, int preSum) {if (node == null) {return preSum;}int sum = preSum * 10 + node.val;if (node.left == null && node.right == null) {return sum;}return helper(node.left, sum) + helper(node.right, sum);}

    Integer max = Integer.MIN_VALUE;public int maxPathSum(TreeNode root) {helper(root);return max;}private int helper(TreeNode node) {if (node == null) {return 0;}int left = helper(node.left);int right = helper(node.right);max = Math.max(max, node.val + left + right);return Math.max(0, node.val + Math.max(left, right));}

    public int countNodes(TreeNode root) {if (root == null) {return 0;}return countNodes(root.left) + countNodes(root.right) + 1;}

    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);if (left == null) {return right;} else if (right == null) {return left;} else {return root;}}

    public Node connect(Node root) {if (root == null) {return null;}LinkedList<Node> tmpList = new LinkedList<>();tmpList.add(root);while (!tmpList.isEmpty()) {int n = tmpList.size();Node last = null;for (int i = 0; i < n; ++i) {Node node = tmpList.poll();if (node.left != null) {tmpList.add(node.left);}if (node.right != null) {tmpList.add(node.right);}if (last != null) {last.next = node;}last = node;}}return root;}

    public List<List<Integer>> levelOrder(TreeNode root) {List<List<Integer>> result = new ArrayList<>();if (root == null) {return result;}LinkedList<TreeNode> tmpList = new LinkedList<>();tmpList.add(root);while (!tmpList.isEmpty()) {int n = tmpList.size();List<Integer> level = new ArrayList<>();for (int i = 0; i < n; ++i) {TreeNode node = tmpList.poll();level.add(node.val);if (node.left != null) {tmpList.add(node.left);}if (node.right != null) {tmpList.add(node.right);}}result.add(level);}return result;}

思路：二叉树层次遍历取最后一个

    public List<Integer> rightSideView(TreeNode root) {List<Integer> result = new ArrayList<>();if (root == null) {return result;}LinkedList<TreeNode> tmpList = new LinkedList<>();tmpList.add(root);while (!tmpList.isEmpty()) {int n = tmpList.size();for (int i = 0; i < n; ++i) {TreeNode node = tmpList.poll();if (node.left != null) {tmpList.add(node.left);}if (node.right != null) {tmpList.add(node.right);}if (i == n - 1) {result.add(node.val);}}}return result;}

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

思路：二叉树层次遍历，对应层翻转

    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {List<List<Integer>> result = new ArrayList<>();if (root == null) {return result;}LinkedList<TreeNode> tmpList = new LinkedList<>();tmpList.add(root);while (!tmpList.isEmpty()) {int n = tmpList.size();List<Integer> levelList = new ArrayList<>();for (int i = 0; i < n; ++i) {TreeNode node = tmpList.poll();if (node.left != null) {tmpList.add(node.left);}if (node.right != null) {tmpList.add(node.right);}levelList.add(node.val);}if (result.size() % 2 == 1) {Collections.reverse(levelList);}result.add(levelList);}return result;}

    double last = -Double.MAX_VALUE;public boolean isValidBST(TreeNode root) {if (root == null) {return true;}if (isValidBST(root.left)) {if (last < root.val) {last = root.val;return isValidBST(root.right);}}return false;}

    List<Integer> tmpList = new ArrayList<>();public int kthSmallest(TreeNode root, int k) {helper(root);return tmpList.get(k - 1);}private void helper(TreeNode root) {if (root == null) {return;}helper(root.left);tmpList.add(root.val);helper(root.right);}

    int pre = -1;int result = Integer.MAX_VALUE;public int getMinimumDifference(TreeNode root) {helper(root);return result;}private void helper(TreeNode node) {if (node == null) {return;}helper(node.left);if (pre == -1) {pre = node.val;} else {result = Math.min(result, node.val - pre);pre = node.val;}helper(node.right);}

class BSTIterator {private int index;private List<Integer> nodeValueList;public BSTIterator(TreeNode root) {this.index = 0;this.nodeValueList = new ArrayList<>();inorder(root, nodeValueList);}public int next() {return nodeValueList.get(index++);}public boolean hasNext() {return index < nodeValueList.size();}private void inorder(TreeNode node, List<Integer> tmpList) {if (node == null) {return;}inorder(node.left, tmpList);tmpList.add(node.val);inorder(node.right, tmpList);}
}

思路：

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

    Map<Character, String> phone = new HashMap<Character, String>() {{put('2', "abc");put('3', "def");put('4', "ghi");put('5', "jkl");put('6', "mno");put('7', "pqrs");put('8', "tuv");put('9', "wxyz");}};List<String> result = new ArrayList<>();public List<String> letterCombinations(String digits) {if (digits.length() == 0) {return result;}helper(0, digits, "");return result;}private void helper(int depth, String digits, String currentStr) {if (depth == digits.length()) {result.add(currentStr);return;}String latters = phone.get(digits.charAt(depth));for (int i = 0; i < latters.length(); ++i) {helper(depth + 1, digits, currentStr + latters.charAt(i));}}

    List<List<Integer>> result = new ArrayList<>();public List<List<Integer>> combine(int n, int k) {helper(1, new ArrayList<>(), n, k);return result;}private void helper(int depth, List<Integer> tmpList, int n, int k) {if (tmpList.size() == k) {result.add(new ArrayList<>(tmpList));return;}for (int i = depth; i <= n; ++i) {tmpList.add(i);helper(i + 1, tmpList, n, k);tmpList.remove(tmpList.size() - 1);}}

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

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

    List<String> result = new ArrayList<>();public List<String> generateParenthesis(int n) {helper(0, 0, "", n);return result;}private void helper(int left, int right, String currentStr, int n) {if (left == n && right == n) {result.add(currentStr);return;}if (left < n) {helper(left + 1, right, currentStr + "(", n);}if (right < left) {helper(left, right + 1, currentStr + ")", n);}}

    public boolean canJump(int[] nums) {int n = nums.length;if (n <= 1) {return true;}int step = 0;for (int i = 0; i < nums.length - 1; ++i) {step = Math.max(step, nums[i]);if (step + i >= nums.length - 1) {return true;}if (step == 0) {return false;}step--;}return false;}

    public int jump(int[] nums) {int step = 0, end = 0, maxFar = 0;for (int i = 0; i < nums.length - 1; ++i) {maxFar = Math.max(maxFar, i + nums[i]);if (end == i) {end = maxFar;step++;}}return step;}

思路：排序+双指针+贪心

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

    public int searchInsert(int[] nums, int target) {int low = 0, high = nums.length - 1, mid;while (low <= high) {mid = low + (high - low) / 2;if (nums[mid] > target) {high = mid - 1;} else if (nums[mid] < target) {low = mid + 1;} else {return mid;}}return low;}

    public int search(int[] nums, int target) {int low = 0, high = nums.length - 1;while (low <= high) {int mid = low + (high - low) / 2;if (nums[mid] == target) {return mid;}if (nums[mid] >= nums[low]) {if (target >= nums[low] && target < nums[mid]) {high = mid - 1;} else {low = mid + 1;}} else {if (target > nums[mid] && target <= nums[high]) {low = mid + 1;} else {high = mid - 1;}}}return -1;}

    public int peakIndexInMountainArray(int[] arr) {int low = 1, high = arr.length - 2, result = 0;while (low <= high) {int mid = low + (high - low) / 2;if (arr[mid] > arr[mid + 1]) {result = mid;high = mid - 1;} else {low = mid + 1;}}return result;}

    public int singleNonDuplicate(int[] nums) {int left = 0, right = nums.length - 1;while (left < right) {int mid = (left + right) / 2;if (mid % 2 == 0) {if (nums[mid] == nums[mid + 1]) {left = mid + 1;} else {right = mid;}} else {if (nums[mid] == nums[mid - 1]) {left = mid + 1;} else {right = mid;}}}return nums[right];}

    public int climbStairs(int n) {if (n <= 2) {return n;}int[] dp = new int[n + 1];dp[1] = 1;dp[2] = 2;for (int i = 3; i <= n; ++i) {dp[i] = dp[i - 1] + dp[i - 2];}return dp[n];}

    public int maxProfit(int[] prices) {int min = Integer.MAX_VALUE;int max = 0;for (int price : prices) {min = Math.min(min, price);max = Math.max(max, price - min);}return max;}

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

    public int maxSubArray(int[] nums) {int[] dp = new int[nums.length];int result = Integer.MIN_VALUE;for (int i = 0; i < nums.length; ++i) {if (i >= 1 && dp[i - 1] > 0) {dp[i] = dp[i - 1] + nums[i];} else {dp[i] = nums[i];}result = Math.max(dp[i], result);}return result;}