StarMirror/CS-Notes

Fork 0

CyC2018 7e4d5152f7 auto commit

2018-02-22 14:47:22 +08:00

127 KiB

Raw Blame History

?????
- ???????
- ??????
- ????
- ????
  - ???????
  - ??????
  - ?????
- ????
  - BFS
  - DFS
  - Backtracking
- ????
- ???
- ????滮
  - ???????
  - ????·??
  - ??????????
  - ????????????
  - ???????????
  - 0-1 ????
  - ????????
  - ???????
  - ????????
- ???
  - ????
  - ??????
  - ???????
  - ???
  - ????????????
  - ????????
  - ??????????
  - ????
????????
- ??????
- ?????
- ?????
- ?????????
  - ???????
- ????
- ??
  - ???
  - ??α???
  - ??к??????
  - BST
  - Trie
- ?
- λ????
?ο?????

?????

???????

?????????????????????????Щ???????????

????? mid ???????? mid = (l + h) / 2 ??????????? l + h ???????????????????? mid = l + (h - l) / 2 ??
?? h ??????????????й???????????? l <= h ???h = mid - 1???????????? l < h ???h = mid?? ??????????????????? l <= h ?????? h = mid??????????????????????????? l = 1??h = 1????? mid ????? 1??????????????? h = mid ??????????????????????????? l < h ????? h = mid - 1??????????????????????????????? 1,2,3 ??????? 1 ????? l = 0??h = 2??mid = 1???ж? key < arr[mid] ??? h = mid - 1 = 0??????????????????????????????
l ???????? l = mid + 1??

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;
}

???

Leetcode : 69. Sqrt(x) (Easy)

????? x ????? sqrt ????? 0 ~ x ??????????? sqrt == x / sqrt ?????????????????? 0 ~ x ?????? sqrt??

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;
}

?????

Leetcode : 441. Arranging Coins (Easy)

n = 8

The coins can form the following rows:
??
?? ??
?? ?? ??
?? ??

Because the 4th row is incomplete, we return 3.

??????????? i ?а? i ?????????????е???????

???? h ?????? l????????????????в?????????

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;
}

????????? Single Element

Leetcode : 540. Single Element in a Sorted Array (Medium)

?????????????????????????????????????Σ???????????

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];
}

??????

?????????β???????????????????????????????????????

???????

Leetcode : 455. Assign Cookies (Easy)

???????????????????????????????????????????С????б?????С???????????????????ú????????????????????????????????????

?????С????????????????????????????С?????????????????????????С????????ú???????????????????????????????????

??????????????????У????????????? i ?????????? m ???????????? i ?????????????С???? m ???????????????? i ?????????С?????????????????????????? k ???????????????????????????и? i ?????????? n ?????????????????????? m ??????????????????????????????? k ?????????????????? m ???????????? n ????????????????????????????????????????????????????????????

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;
}

??????????

Leetcode : 452. Minimum Number of Arrows to Burst Balloons (Medium)

Input:
[[10,16], [2,8], [1,6], [7,12]]

Output:
2

?????????????????????????????????????????????????????????·???????????????????С????????????

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;
 }

????????????

Leetcode : 122. Best Time to Buy and Sell Stock II (Easy)

?????????????????????????ò??????????档

??????????? [a, b, c, d]??????? a <= b <= c <= d ????????????? d - a = (d - c) + (c - b) + (b - a) ???????????? prices[i] ?? prices[i] - prices[i-1] ???????? prices[i] - prices[i-1] ????????У??????????????????????????????

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;
}

???????

Leetcode : 605. Can Place Flowers (Easy)

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;
}

???????????????????

Leetcode : 665. Non-decreasing Array (Easy)

??????????ж?????????????????????????????????顣

?? nums[i] < nums[i - 1] ??????????????????? nums[i - 1] = nums[i]??????????? nums[i] = nums[i - 1] ???????? nums[i] ???????????????п???? nums[i + 1] ???????????? nums[i] ??С??

?????? nums[i] < nums[i - 2] ???????????? nums[i - 1] ??????????????????????????? nums[i] = nums[i - 1] ???С?

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;
}

?ж????????

Leetcode : 392. Is Subsequence (Medium)

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;
}

????????????????????????

Leetcode : 763. Partition Labels (Medium)

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]]

???????????????? (h, k) ??????h ???????k ????????????? k ???????????????????????????

????????????k ??????????????????????е?? k ??λ???С?

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;
}

????

?????????????????飬????????????????????Э????????

??????????????????в???????????????????? 0

Leetcode ??167. Two Sum II - Input array is sorted (Easy)

????????????????????С???????????????????????????С???????????β???????????????????β?????????

?????????????????? sum == target??????????????????? sum > target?????????????? sum ??С?Щ????? sum < target???????С??????? sum ????Щ??

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;
}

????????????????????? 0 ?????????????????????? P351

?????????????????????????鳤??

???????????????? P354/P355/P358

???к??ж???????????в??????

???????????????? P347

?????????е???????

Leetcode : 345. Reverse Vowels of a String (Easy)

??????????????????????????????????????β?????????????β?????????

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);
}

?????????

Leetcode : 633. Sum of Square Numbers (Easy)

?ж???????????????????????????? 5 = 1² + 2²??

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;
}

??????????????????????????

Leetcode : 680. Valid Palindrome II (Easy)

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;
}

?鲢????????????

Leetcode : 88. Merge Sorted Array (Easy)

??鲢????浽????????????

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--;
    }
}

?ж????????????

Leetcode : 141. Linked List Cycle (Easy)

?????????????????????????????????????????????????????????????????????????????

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;
}

????????

Leetcode : 524. Longest Word in Dictionary through Deleting (Medium)

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

Output:
"apple"

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;
}

????

???????

?????????? Kth Element ?????????? O(n) ??临????O(1) ??临?????????????

???????????????????????????????????飬?????????????临???? O(n²)??

??????

????????????? TopK Elements ???????????????С? K ???????е??????? TopK Elements??????????????????? Kth Element ??????????????????????? Kth Element????????????????? TopK Elements ?????????? Kth Element ??????????????飬????С????? Kth Element ???????? TopK Elements?????????????????????????????? Kth Element ?? TopK Elements ????????п????????????

Kth Element

Leetocde : 215. Kth Largest Element in an Array (Medium)

????ο???Solution explained

??临??? O(nlgn)????临??? O(1) ????????
??临??? O(nlgk)????临??? O(k) ??????????
??临??? O(n)????临??? O(1) ????QuickSelect

ToK Elements

???????????????? P336

?????

?????????????? k ????

Leetcode : 347. Top K Frequent Elements (Medium)

?????

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;
}

????

?????????????????????????????????????У??????????????????????

BFS

??????????????????????е????????????б????????? 0 ???????????? 6??2??1 ?? 5 ?????????

?????? 6 ??????????????? 4 ???? 2 ?????????????????????? 1 ?????????????????????? 5 ???????????? 3 ?? 4 ??????????????????????4 ?? 3 ??

????????????????????????????????

??????????????????????????·????????????? d_i ????? i ????????????·????????????????????????????????? i ?????????? j???? d_i<=d_j????????????????????????·?? ????? ????????α????????????????????·??????·????????????????????????????????????????·??????????·????

???????? BFS ????????????????

???У??????洢???????????
???????????????????????????????????????

???????????д?????????????·??????

[[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;
    }
}

DFS

?????????????????????????????????????????????????洢??????????????????????????????????????????????????????????????????б????????? 0 ?????????????????????? 6 ???????????? 6 ???б???????????? 4??????????????????????????????????????????????????????? 0 ?????????????????? 0 ???б???????????? 2??????????????衣

???????????????? DFS ?????????б???????????????????????????????DFS ????????????? ????? ????

???????? DFS ????????????????

???????????浱????????????????????????????????????????????????????
?????? BFS ??????????????????????????б???

??????????????

Leetcode : 695. Max Area of Island (Easy)

[[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;
}

??????????

Leetcode : 547. Friend Circles (Medium)

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);
        }
    }
}

?????е????????????

Leetcode : 200. Number of Islands (Medium)

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]);
    }
}

??????????????д????????·??

Leetcode : 257. Binary Tree Paths (Easy)

["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);
}

?????????

Leetcode : 130. Surrounded Regions (Medium)

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

????????????? 'X' ?? 'O' ???? '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]);
    }
}

????????????????????

Leetcode : 417. Pacific Atlantic Water Flow (Medium)

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).

???????????????????????????±?????????????????????Σ????θ??????????????????????????????????????????????е????

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);
    }
}

N ???

Leetcode : 51. N-Queens (Hard)

??????????? n*n ??????а?? n ?????????????????????У????У??????????????????е? n ????

?????е?????????????е????????????????????????????????????????????????????????????????????????б?????顢45 ????????????? 135 ???????????顣

45 ????????????????? 2*n - 1??????????????? (r,c) ??λ????????????±?? r + c??

135 ??????????????????? 2*n - 1??(r,c) ??λ????????????±?? n - 1 - (r - c)??

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] = '.';
    }
}

Backtracking

?????? DFS ?????????????????????????????????????? ??????? ?????????? { 'a','b','c' } ??????????????????????????????е???????????

???????????????????????????б????????????????????????????????????????????????????????????????????????????????????????????????????????????????鷵??????????????????δ??????????????????????????в?????????????????????????????????????????????????????????е?????

??????????

Leetcode : 17. Letter Combinations of a Phone Number (Medium)

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);
    }
}

???????????????

Leetcode : 79. Word Search (Medium)

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;
}

IP ???????

Leetcode : 93. Restore IP Addresses(Medium)

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));
        }
    }
}

????

Leetcode : 46. Permutations (Medium)

??????????????????????????С?

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;
    }
}

?????????????

Leetcode : 47. Permutations II (Medium)

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

?????????? Permutations ????????????????????????????????ж?????????????????????????????????????????δ?????????????????????

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;
    }
}

???

Leetcode : 77. Combinations (Medium)

?????????????? 1 ~ n ????? k ?????????п????????

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)); // ??????????????? List
        return;
    }
    
    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 ????δ????
    }
}

??????

Leetcode : 39. Combination Sum (Medium)

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);
         }
     }
 }

???????????????

Leetcode : 40. Combination Sum II (Medium)

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);
        }
    }
}

???

Leetcode : 78. Subsets (Medium)

??????????????????????????????????????[1, 2] ?? [2, 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);
    }
}

????????????

Leetcode : 90. Subsets II (Medium)

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);
    }
}

????????????????????????

Leetcode : 131. Palindrome Partitioning (Medium)

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;
}

????

Leetcode : 37. Sudoku Solver (Hard)

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;
}

????

????????????

Leetcode : 241. Different Ways to Add Parentheses (Medium)

Input: "2-1-1".

((2-1)-1) = 0
(2-(1-1)) = 2

Output : [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;
}

???

????????????С???????????

????滮

?????????????????????????????????????????????????????????Ρ?

???????

??????????????

Leetcode : 343. Integer Break (Medim)

?????????For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 + 4).

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];
}

????????????????

Leetcode : 279. Perfect Squares(Medium)

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

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];
}

???????????????????

Leetcode : 91. Decode Ways (Medium)

?????????Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).

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];
}

????·??

???????·????

Leetcode : 62. Unique Paths (Medium)

????????????????????????????·????????????????????????????

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];
}

???????С·????

Leetcode : 64. Minimum Path Sum (Medium)

??????????????????????????????С·?????????????????????????

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];
}

??????????

????????????????? 4 ?????????????????? N ???????????????????????????临?????С? O(lgN)??

?????

Leetcode : 70. Climbing Stairs (Easy)

??????????? N ????????ο???????????????????ж????????????????

??????????? dp ?洢?????????????????????????????±?? 1 ???????dp[i] ???????? i ???????????????? i ?????????? i-1 ?? i-2 ????????????????????? i ????????????????? i-1 ??? i-2 ???????????????

dp[i] = dp[i-1] + dp[i-2]

dp[N] ???????

????? dp[i] ??? dp[i - 1] ?? dp[i - 2] ?й??????????????????????洢 dp[i - 1] ?? dp[i - 2] ????????????? O(n) ??临??????? O(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;
}

??????

????????????????-P181

?????????????????г????????????? 1 ?С?????????????????????????? 1 ?С????????????????????С??????С?? 3 ???????????????С???????????? N???? N ????????????

?? i ????????????????

dp[i] = dp[i-1] + dp[i-3]

???????

Leetcode : 198. House Robber (Easy)

?????????????????????????????????????????????????????

???? dp ?????????洢???????????????? dp[i] ????????? i ??????????????????????????????????????????????????? i ??????????????? i - 2 ?? i - 3 ???????????

$\\dp[i]=max(dp[i-2],dp[i-3])+nums[i]$

O(n) ??临???????????

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]);
}

O(1) ??临???????????

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);
}

???????ν???????

Leetcode : 213. House Robber II (Medium)

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]);
}

???????

??????????? N ?? ?? ?? ??????????????????????????????

??????????? dp ?洢???????????dp[i] ???? i ???????????????????????? i ????????? j ????????棬???? j ????????? k ????????档???? i ?? k ??????????????????

?? i==k?????? i ?? k ???????????????????????λ??????????? i-2 ?????? dp[i-2] ????????????????? j ?? i-1 ???????????? (i-1)*dp[i-2] ????????????

?? i != k?????? i ?? j ?????? i ???????????????λ??????? i-1 ?????? dp[i-1] ???????????????? j ?? i-1 ???????????? (n-1)*dp[i-1] ????????????

???????????????????????????????

dp[i] = (i-1) \* dp[i-2] + (i-1) \* dp[i-1]

dp[N] ???????

????????????????dp[i] ??? dp[i-1] ?? dp[i-2] ?й????????????????????????洢 dp[i-1] ?? dp[i-2]??

????????????

?????????? {S₁, S₂,...,S_n} ????????????????????? {S_i1, S_i2,..., S_im}?????? i1??i2 ... im ??????????????????и??????????????????е???????????????????е????????????

????????????У????±? ix > iy ???S_ix > S_iy???????????????е????????????????

??????????? dp ?洢???????????е?????dp[n] ????? S_n ??β?????е????????????г????????????????????? {S_i1, S_i2,...,S_im}????? im < n ???? S_im < S_n ????? {S_i1, S_i2,..., S_im, S_n} ?????????????У??????????е???????? 1??????????????????????????У?????????????????????о??????????????????????????????? S_n ????????? S_n ???β?????????????С???? dp[n] = max{ dp[i]+1 | S_i < S_n && i < n} ??

??????? dp[n] ????????????????????????????????У???? {S_n} ???????????????У?????????????????????????? dp[n] ??С? 1??????

$\\dp[n]=max{1,dp[i]+1|S_i<S_n&&i<n}$

???????????? N ?????У????????в?????????? S_N ???β????? dp[N] ???????е????????????е???????????? dp ?????????????????????????? max{ dp[i] | 1 <= i <= N} ???????

????????????

Leetcode : 300. Longest Increasing Subsequence (Medium)

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;
}

?????????临???? O(n²) ????????????????????临??????? O(nlog_n)????????? tails ???飬???? tails[i] ?洢????? i + 1 ?????????????е?????????????????????? [4,5,6,3]????

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

?????????? x??????????? tails ???????е??????????????? tails ???棻??? tails[i-1] < x <= tails[i]????????? tails[i] = x ??

??????? tails ???鱣?????????????? S_i λ?? tails ?????λ??????????????????

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;
}

???????????

Leetcode : 376. Wiggle Subsequence (Medium)

?????? O(n) ??临??????

????????? up ?? down??

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);
}

???????????

?????????????? S1 ?? S2?????????????????????С?

?????????????? dp ?????洢???????????е????????? dp[i][j] ??? S1 ??? i ??????? S2 ??? j ????????????????е????????? S1_i ?? S2_j ????????????????????

?? ?? S1_i==S2_j ???????????? S1 ??? i-1 ??????? S2 ??? j-1 ????????????????е??????????? S1_i ?????????????????г???? 1 ???? dp[i][j] = dp[i-1][j-1] + 1??

?? ?? S1_i != S2_j ??????????????????? S1 ??? i-1 ??????? S2 ??? j ????????????????У??? S1 ??? i ??????? S2 ??? j-1 ????????????????У?????????????? dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }??

???????????????е????????????

![](http://latex.codecogs.com/gif.latex?\\ dp[i][j]=\left{ \begin{array}{rcl} dp[i-1][j-1]&&{S1_i==S2_j}\ max(dp[i-1][j],dp[i][j-1])&&{S1_i<>S2_j} \end{array}\right. )

???????? N ?????? S₁ ?? ????? M ?????? S₂??dp[N][M] ???????? S₁ ?????? S₂ ?????????????г????

????????????????????????????????????????

?? ?????????????У???????????????????С? ?? ???????????????У?dp[i] ????? S_i ???β?????????????г?????????б?????? S_i ?????????????????У?dp[i][j] ??? S1 ??? i ??????? S2 ??? j ??????????????????г????????????? S1_i ?? S2_j ?? ?? ???? 2 ???????????????????????????? dp[N][M] ????????????????????????? dp[N] ?????????????? S_N ???β?????????????в?????????????????????????У??????????? dp ?????????????

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];
}

0-1 ????

?????????? N ????????????????????????????????Щ????????????????? w ???? v??

?????????????? dp ?洢??????????? dp[i][j] ???????????? j ????????? i ???????????????????? i ????????? w?????? v??????? i ?????????????????У??????????????????

?? ?? i ??????????????????????????? j ??? i ??????????????????????????? j ??? i-1 ??????????????dp[i][j] = dp[i-1][j]?? ?? ?? i ??????????????У?dp[i][j] = dp[i-1][j-w] + v??

?? i ???????????????????????????????????????????

?????0-1 ?????????????????

$\\dp[i][j]=max(dp[i-1][j],dp[i-1][j-w]+v)$

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];
}

??????

?????????????? 0-1 ??????????????????????????????? i ?????????????? i-1 ??????????й????????? dp ??????????飬???? dp[j] ??????? dp[i-1][j] ??????? dp[i][j]???????

$\\dp[j]=max(dp[j],dp[j-w]+v)$

??? dp[j-w] ??? dp[i-1][j-w]???????????? dp[i][j-w] ????? dp[i-1][j-w] ????????????????? dp[i][j] ????? dp[i][j-w]????????????????????????????

????????????????

0-1 ???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????? 5 ?????????????????? 0 ???????? 1?????????????? 16????????С? 2 ?????????????????? 1 ????? 2?????? 22.

id	w	v	v/w
0	1	6	6
1	2	10	5
2	3	12	4

????

??????????????????????????????? 0-1 ?????????????????????????? 1/2/4... ????????????????????????????????????????????Ρ?

?????????????????????????????????? 0-1 ??????

?????????????????????????????????????????????????????

???????????????????????????

?????????????????????

Leetcode : 416. Partition Equal Subset Sum (Medium)

????????????????С? sum/2 ?? 0-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];
}

????????????б???

Leetcode : 139. Word Break (Medium)

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];
}

?????????????????????????????????

Leetcode : 494. Target Sum (Medium)

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.

????????????? subset sum ?????????? 0-1 ????????????????????????????????????P ?? N?????? P ????????N ??????????????????

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

????????????????????????????????????? (target + sum(nums))/2????????????

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];
}

01????????????????

Leetcode : 474. Ones and Zeroes (Medium)

Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
Output: 4

Explanation: This are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are ??10,??0001??,??1??,??0??

??????????????? 0-1 ????????????????????С??0 ???????? 1 ????????

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];
}

?????

Leetcode : 322. Coin Change (Medium)

????????????Щ???????????????Щ??????????????????????????????????????????????????á?

?????????????????????????????? 0-1???????????????Ψ??????????????????? 0 ?????????????β???????

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];
}

??????

Leetcode : 377. Combination Sum IV (Medium)

nums = [1, 2, 3]
target = 4

The 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];
}

?????????ε???????

Leetcode : 123. Best Time to Buy and Sell Stock III (Hard)

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;
}

?????? k ?ε???????

Leetcode : 188. Best Time to Buy and Sell Stock IV (Hard)

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];
}

????????

?????????

Leetcode : 303. Range Sum Query - Immutable (Easy)

?????? i ~ j ???????????? sum[j] - sum[i-1]?????? sum[i] ? 0 ~ j ????

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];
    }
}

???????????

Leetcode : 53. Maximum Subarray (Easy)

?? sum[i] ??? num[i] ???β???????????????????? sum[i-1] ??? sum[i] ???????? sum[i-1] С?? 0??????? num[i] ???β???????鲻???????????????????????????????????????? num[i] ??С??

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;
}

?????е???????????????

Leetcode : 413. Arithmetic Slices (Medium)

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.

???? (1,2,3,4)????????????????????????????????? (1,2,3,4,5)??????????????????????? (1,2,3,4) ?????????????????? (1,2,3,4,5)????? dp[i] = dp[i - 1] + 1??

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;
}

???????

?????????????????????????

Leetcode : 583. Delete Operation for Two Strings (Medium)

?????????????????????????????????????

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];
}

???????????????????????? // TODO

Leetcode : 72. Edit Distance (Hard)

??????????????????????????// TODO

????????????????-?????

????????

???????????????

Leetcode : 309. Best Time to Buy and Sell Stock with Cooldown(Medium)

???????????????????????????????

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]);
}

???? 0 ~ n ???????????????? 1 ?????

Leetcode : 338. Counting Bits (Medium)

???????? 6(110)????????????????? 2(10) ????????? 1 ????? dp[i] = dp[i&(i-1)] + 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;
    }

?????????????????????

Leetcode : 646. Maximum Length of Pair Chain (Medium)

???? (a, b) ?? (c, d) ????? b < c?????????????????????

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;
}

???????????????????

Leetcode : 121. Best Time to Buy and Sell Stock (Easy)

???????ν????

???????????С?????????С???????????????????????????????????????????????????

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;
}

??????????

Leetcode : 650. 2 Keys Keyboard (Medium)

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;
}

???

????

???????

????????????????????????????? 84 = 2² * 3¹ * 5⁰ * 7¹ * 11⁰ * 13⁰ * 17⁰ * ??

????

?? x = 2^m0 * 3^m1 * 5^m2 * 7^m3 * 11^m4 * ?? ?? y = 2ⁿ⁰ * 3ⁿ¹ * 5ⁿ² * 7ⁿ³ * 11ⁿ⁴ * ??

??? x ???? y??y mod x == 0????????????? i??mi <= ni??

x ?? y ?? ?????? ???gcd(x,y) = 2^min(m0,n0) * 3^min(m1,n1) * 5^min(m2,n2) * ...

x ?? y ?? ??С?????? ???lcm(x,y) = 2^max(m0,n0) * 3^max(m1,n1) * 5^max(m2,n2) * ...

????????????

Leetcode : 204. Count Primes (Easy)

????????????????????????????????????????????????????????

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);
}

???????????????????????? a % b ??????????????????????????? ????????2.7 ??????????ü???????λ???????滻????

???? a ?? b ???????? f(a, b)???У?

1. ??? a ?? b ????????f(a, b) = 2*f(a/2, b/2); 2. ??? a ????? b ????????f(a, b) = f(a/2, b); 3. ??? b ????? a ????????f(a, b) = f(a, b/2); 4. ??? a ?? b ?????????f(a, b) = f(a, a-b);

?? 2 ??? 2 ????????????λ??????

???????

Java ?? static String toString(int num, int radix) ???????????????? redix ???????????????

7 ????

Leetcode : 504. Base 7 (Easy)

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

16 ????

Leetcode : 405. Convert a Number to Hexadecimal (Easy)

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;
}

???

?????β???ж???? 0

Leetcode : 172. Factorial Trailing Zeroes (Easy)

β???? 0 ?? 2 * 5 ??????2 ????????????? 5 ?????????????????ж???? 5 ???ɡ?

????????? N?????????? 5 ????????N/5 + N/5² + N/5³ + ...?????? N/5 ????????? N ?????? 5 ???????????? 5??N/5² ????????? N ?????? 5² ????????????? 5 ...??

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

????????? N! ??????????????λ 1 ??λ?????????ж???? 2 ?????????????? ????????2.2 ????????ж???? 5 ?????2 ?????? N/2 + N/2² + N/2³ + ...

????????????

????????

Leetcode : 67. Add Binary (Easy)

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;
}

????????

Leetcode : 415. Add Strings (Easy)

?????????????????????????

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();
}

????????

??????????????е????????????

Leetcode : 462. Minimum Moves to Equal Array Elements II (Medium)

???????????ο????????????????????????????С?????????

???????????????????????????С?????????????????????λ?????????????

?? m ???λ????a ?? b ?? m ??????????????? b > a???? a ?? b ???????????????????? b - a?????????? (b - m) + (m - a)???????????????????????λ?????????????

?????鳤??? N?????????? N/2 ?? a ?? b ????????????????? m ??λ?á?

?? 1

????????临????O(NlgN)

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;
}

?? 2

???????????????λ??????临??? O(N)

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;
}

??????????

?????г?????????? n / 2 ?????

Leetcode : 169. Majority Element (Easy)

??????????????м???????????????????? n / 2

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

???????? Boyer-Moore Majority Vote Algorithm ?????????????????临???? O(n)???????????????????? cnt ????????????????????????????????????????????????? cnt--????????????? i ???????? cnt == 0 ?????? i ???????? majority???????? majority????????????????? i / 2 ???????????? i / 2 ??? cnt ?????????? 0 ????????? n - i ??????У?majority ????????? (n - i) / 2?????????????????? majority??

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;
}

?????г?????????? n / k ?????

???????????????? P343

? k - 1 ?????

????

?????

Leetcode : 367. Valid Perfect Square (Easy)

??????У?1,4,9,16,.. ?????3,5,7,...

??????????У?????????????????? 1 ???????????С?

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

3 ?? n ?η?

Leetcode : 326. Power of Three (Easy)

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

????????е?????????????

Leetcode : 628. Maximum Product of Three Numbers (Easy)

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);
}

???????

Leetcode : 238. Product of Array Except Self (Medium)

???????????????????飬????????????飬?????????????????????г????λ???????????????????????

????????临???? O(n)???????????ó?????

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();
    }
}

?????????

Leetcode : 225. Implement Stack using Queues (Easy)

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();
    }
}

??С??

Leetcode : 155. Min Stack (Easy)

???????????????洢?????????洢??С???

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;
    }
}

?????????С?????????????????????????????????????????????С???????????????? ????????3.7??

?????????????

Leetcode : 20. Valid Parentheses (Easy)

"()[]{}"

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]

Leetcode : 739. Daily Temperatures (Medium)

???????洢??δ???????????????????????????????????????????????????????????????????У????????????????????????????????????

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;
}

??????????????????????

Leetcode : 496. Next Greater Element I (Easy)

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

???????????? Stack ???????е????????????????????????????????????????????????????????????????????????

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;
}

?????????????????????????

Leetcode : 503. Next Greater Element II (Medium)

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;
}

?????

???? Hash Table ????????????????????????????????????????????洢?????????????临?????????????????? Hash Table ?????任???????????

Java ?е? HashSet ????洢???????????? O(1) ????临??????????????????С?

???????????????Χ???????????????????????????洢???????????????????????Сд???????????????????????? 26 ????????????洢???????????????临??????? O(1)??

Java ?е? HashMap ???????????????????????????????????

?????????????????????????????????? HashMap ?????????????????????????????????????????? url ?????У?Leetcdoe : 535. Encode and Decode TinyURL (Medium)???????? HashMap ?????洢?????? url ???? url ???????ò????????????? url???????????? url ????? url ?????λ????????????

HashMap ????????????????м??????????????????????????? HashSet ??????????????????Χ???????????????????????????

?????е???????????????

Leetcode : 1. Two Sum (Easy)

???????????????????????????????????????????????????????临???? O(nlg_n)????临???? O(1)??

?? HashMap ?洢??????????????????????? nums[i] ????ж? HashMap ???????? target - nums[i] ???????????? target - nums[i] ??????????? i ?????????????????÷???????临???? O(n)????临???? O(n)???????????????

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;
}

????г????

??г???????????????С?????????? 1

Leetcode : 594. Longest Harmonious Subsequence (Easy)

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;
}

?????

????????????????????????????

Leetcode : 242. Valid Anagram (Easy)

??????????Сд?????????? 26 ??Сд??????????? Hash Table ??????????????????????????Χ??С???????????????????????

??ó???? 26 ????????????????????????????????????????????????????????????????

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;
}

????????

Leetcode : 205. Isomorphic Strings (Easy)

???? "egg" ?? "add" ????????????????

???????????γ????λ?????????????????????????γ????λ?????????????????????

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;
}

???????????????????????????????????

Leetcode : 409. Longest Palindrome

??ó???? 128 ?????????????????????????????????????????????????????????????????????????????????м????????????????????????????е???????????????????м?

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;
}

?ж??????????????????

Leetcode : 9. Palindrome Number (Easy)

??????????????????????????????????????ж??

???????????????????????????????????????ж????????????????

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;
}

???????????

Leetcode : 647. Palindromic Substrings (Medium)

???????????????????λ????????????????????????

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++;
    }
}

??????????????????? 1 ?? ???? 0 ????????????????????

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".

Leetcode : 696. Count Binary Substrings (Easy)

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;
}

??????????λ????

????????3.1

????????????? s1 ?? s2 ??????ж? s2 ???????? s1 ???????λ????????????????

s1 = AABCD, s2 = CDAA
Return : true

s1 ?????????λ?????? s1s1 ?????????????????ж? s2 ????? s1s1 ????????????ɡ?

??????????λ

????????2.17

????????????????? k λ??

???? abcd123 ??????? 3 λ ??? 123abcd

?? abcd123 ?е? abcd ?? 123 ?????????? dcba321?????????????????????????123abcd??

??????е??????

????????????????

???罫 "I am a student" ????? "student a am I"

?????????????????????????????

?????????

??????? // TODO

??????????? P114

??????? //TODO

???????????????? P335

???????е? 0 ????β

Leetcode : 283. Move Zeroes (Easy)

    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;
        }
    }

???????????? [1, n] ???????????????滻?????????????????????????????

Leetcode : 645. Set Mismatch (Easy)

??????????????????????????????????临???? O(nlog_n)??????????? O(n) ????临????O(1) ??临????????

?????????????????????????????????????????????λ?????

???????飬????? i λ????????? i + 1 ???????????? i λ ?? nums[i] - 1 λ?????????? num[i] - 1 ?????? nums[i] ????????λ??????????????????????????????У??????ν?????????? i λ???????????????????????????????????????????????????????????????????????????????????? nums[i] != nums[nums[i] - 1 ??????

?????????

Leetcode :448. Find All Numbers Disappeared in an Array (Easy)????????ж???????
Leetcode : 442. Find All Duplicates in an Array (Medium)??????????????????

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;
}

????????????????????????? [0, n-1] ???

Leetcode : 287. Find the Duplicate Number (Medium)

??????????

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]
]

??????????

Leetocde : 240. Search a 2D Matrix II (Medium)

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;
}

???????? Kth Element

Leetcode : 378. Kth Smallest Element in a Sorted Matrix ((Medium))

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

return 13.

????ο???Share my thoughts and Clean Java Code

??????????

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;
    }

    @Override
    public int compareTo(Tuple that) {
        return this.val - that.val;
    }
}

????

?ж?????????????

Leetcode : 160. Intersection of Two Linked Lists

A:          a1 ?? a2
                  ?K
                    c1 ?? c2 ?? c3
                  ?J
B:    b1 ?? b2 ?? b3

?????临???? O(n) ??临???? O(1)

?? A ?????? a + c??B ?????? b + c?????? c ?β????????????????? a + c + b = b + c + a??

?????? A ????????????????β??????????????? B ???????????????? B?????????????? B ????????????????β??????????????? A ???????????????? A???????????????? A ?? B ?????????????????????????

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;
}

???????ж???????????????????????????? ????????3.6 ???????????????????????????β???????????????????????????????????????????????????????????????????????????????????????????

?????

Leetcode : 206. Reverse Linked List

??巨??????????????

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;
}

?鲢?????????????

Leetcode : 21. Merge Two Sorted Lists

???????????????????鷽??????壺??????????????????????????????????????????????????????????????????

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;
}

?????????????????????

Leetcode : 83. Remove Duplicates from Sorted List (Easy)

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;
}

????????

Leetcode : 234. Palindrome Linked List (Easy)

?г?????????η????????????????????

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;
}

??????????????

????????3.4

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

??????????????

Leetcode : 328. Odd Even Linked List (Medium)

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;
}

??

???

??????????????????????????????????????????????????????????????????????????????

??????

Leetcode : 104. Maximum Depth of Binary Tree (Easy)

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

?????

Leetcode : 226. Invert Binary Tree (Easy)

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;
}

?鲢??????

Leetcode : 617. Merge Two Binary Trees (Easy)

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;
}

?ж?·???????????????

Leetcdoe : 112. Path Sum (Easy)

?????????·?????????? root ?? leaf ?????н????

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);
}

???·??????????????·??????

Leetcode : 437. Path Sum III (Easy)

?????????·????????? root ??????? leaf ??β?????????????

pathSumStartWithRoot() ??????????????????·????????

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;
}

??????

Leetcode : 101. Symmetric Tree (Easy)

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);
}

?????

Leetcode : 110. Balanced Binary Tree (Easy)

????????????????????????С????? 1

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);
}

??С·??

Leetcode : 111. Minimum Depth of Binary Tree (Easy)

?????????????????????????С????

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;
}

????????????

Leetcode : 404. Sum of Left Leaves (Easy)

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;
}

????????

Leetcode : 669. Trim a Binary Search Tree (Easy)

????????????????? L ~ R ??????

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;
}

????

Leetcode : 572. Subtree of Another Tree (Easy)

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);
}

???????????й???????????

Leetcode : 108. Convert Sorted Array to Binary Search Tree (Easy)

???????????BST????????????????????????н??С??????????????н??

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  5

Return 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;
}

??????????е??С????

Leetcode : 671. Second Minimum Node In a Binary Tree (Easy)

Input:
    2
  / \
  2  5
    / \
    5  7

Output: 5

???????????? 0 ???? 2 ???????????????????????????С????

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;
}

??????????????????????

Leetcode : 235. Lowest Common Ancestor of a Binary Search Tree (Easy)

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;
}

???????????

Leetcode : 236. Lowest Common Ancestor of a Binary Tree (Medium)

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;
}

????????????·??????

Leetcode : 687. Longest Univalue Path (Easy)

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);
}

???????

Leetcode : 337. House Robber III (Medium)

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);
}

??α???

??? BFS???????????????????????洢????????????????? ????????????????????????????е????????????????????????????????????????????????α???????????????

????????????????????

637. Average of Levels in Binary Tree (Easy)

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;
}

???????????

Leetcode : 513. Find Bottom Left Tree Value (Easy)

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] ?????????[1 2 4 5 3 6] ??????????[4 2 5 1 3 6] ??????????[4 5 2 6 3 1]

??α?????? BFS ???????????? BFS ????????????????????????????????????? DFS ????

?????????????????????????????????????????????

?? ???

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);
}

????????????????????

Leetcode : 144. Binary Tree Preorder Traversal (Medium)

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;
}

?????????????????????

Leetcode : ### 145. Binary Tree Postorder Traversal (Medium)

??????? root -> left -> right?????????? left -> right -> root?????????????????? root -> right -> left???????????????????????????

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;
}

?????????????????????

Leetcode : 94. Binary Tree Inorder Traversal (Medium)

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;
}

??????????????????????????????? //TODO

BST

??????? BST ???????????????

?? BST ??????????????????????????????

653. Two Sum IV - Input is a BST

?????????????????????????????????????????в????

????????????????÷?????????????????????????????????????????????????????????????С?

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);
}

?? BST ?в?????С?????????????????

Leetcode : 530. Minimum Absolute Difference in BST (Easy)

???? BST ??????????????????????????????????????????????????????????С???

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);
}

?? BST ????????????????????????

Leetcode : Convert BST to Greater Tree (Easy)

?????????????

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);
    }
}

??? BST ?г????????????

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);
}

??? BST ??? k ?????

Leetcode : 230. Kth Smallest Element in a BST (Medium)

??????

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);
}

Trie

Trie???????????????????????ж?????????????????????????????????

?????? Trie

Leetcode : 208. Implement Trie (Prefix Tree) (Medium)

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]);
    }
}

?????? Trie????????????

Leetcode : 677. Map Sum Pairs (Medium)

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;
    }
}

?

λ????

1. ???????

0s ??? ??? 0 ??1s ?????? 1??

x ^ 0s = x      x & 0s = 0      x | 0s = x
x ^ 1s = \~x     x & 1s = x      x | 1s = 1s
x ^ x = 0       x & x = x       x | x = x

?? ???? x ^ 1s = ~x ??????????λ?????????????? x ^ x = 0 ???????????????????????????????????????????????? ?? ???? x & 0s = 0 ?? x & 1s = x ?????????????????????????? num ?? mask ??00111100 ????λ???????????? num ???? mask ?? 1 ??????????λ?? ?? ???? x | 0s = x ?? x | 1s = 1s ???????????????ò?????????? num ?? mask??00111100 ????λ????????? num ???? mask ?? 1 ??????????λ??????? 1 ??

>> n ????????????????? 2ⁿ?? >>> n ????????????????? 0?? << n ????????????????? 2ⁿ??

n&(n-1) ??λ????????? n ??λ??????????????λ???????????????? 10110100????? 1 ??? 10110011???????????????? 10110000??

n-n&(~n+1) ??????????? n ??λ??????????????λ??

n&(-n) ???????? n ??λ??????????????λ??-n ??? n ?????? 1????????????? 10110100??-n ??? 01001100???????? 00000100

2. mask ????

???? 111111111???? 0 ????????~0??

??????е? i λ? 1 ?? mask???? 1 ??????? i λ?????1<<i ?????? 1<<5 ?????е? 5 λ? 1 ?? mask ??00010000??

???? 1 ?? i λ? 1 ?? mask??1<<(i+1)-1 ????????罫 1<<(4+1)-1 = 00010000-1 = 00001111??

???? 1 ?? i λ? 0 ?? mask????轫 1 ?? i λ? 1 ?? mask ??????? ~(1<<(i+1)-1)??

3. λ????????

?? ????? i λ

num & 00010000 != 0

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

?? ???? i λ????? 1

num | 00010000

num | (1 << i);

?? ???? i λ???? 0

num & 11101111

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

?? ?????λ???? i λ???? 0

num & 00001111

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

?? ???? 0 λ???? i λ???? 0

num & 11110000

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

?? ???? i λ????? 0 ???? 1

????? i λ??????? v ???? i λ????С?λ??????

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

4. Java ?е?λ????

static int Integer.bitCount()            // ??? 1 ??????
static int Integer.highestOneBit()       // ??????λ
static String toBinaryString(int i)      // ???λ???????????????

???????????????????ж???λ???

Leetcode : 461. Hamming Distance (Easy)

????????????????????????????λ???? 1 ??????ж???? 1 ???ɡ?

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;
}

??????? Integer.bitcount() ????? 1 ?????????

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

?????????????λ

Leetcode : 190. Reverse Bits (Easy)

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

??????????????????????

???????????????? ??P317

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

?? c = a ^ b????? b ^ c = b ^ b ^ a = a??a ^ c = a ^ a ^ b = b??

?ж??????????? 4 ?? n ?η?

Leetcode : 342. Power of Four (Easy)

??????????????????????????λ? 1 ????????? 0 ?????? 16 ?? 10000?????????? 1 ??????? 2 λ??????????????????????????????????????ж????????????

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

??????? Java ?? Integer.toString() ?????????????? 4 ????????????????????ж??????????? 1 ?????

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

?ж??????????? 2 ?? n ?η?

Leetcode : 231. Power of Two (Easy)

????????? Power of Four ??????????? 2 ?? n ?η???????????????????????? 1 ?????

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

???? 1000 & 0111 == 0 ???????????????????

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

??????Ψ??????????????

Leetcode : 136. Single Number (Easy)

?????????????????? 0???????????????????????????????????????????????

??????У?Leetcode : 389. Find the Difference (Easy)??????????????????????????????????????????? O(1) ???临?????????????????? HashSet??

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

?????в?????????????

Leetcode : 260. Single Number III (Medium)

???????????????λ??????????????λ????????

??????????????????????????????????????????????????

diff &= -diff ????? diff ?????? 0 ??λ??????????????????????????λ??????????????????λ?????????λ??????????????????????

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;
}

?ж????????λ?????????????????? 0 ?? 1

Leetcode : 693. Binary Number with Alternating Bits (Easy)

???? 10101 ????λ?????????????????????? 1 λ??? 1010 ?????????????λ???????????????????? 11111??

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

????????????

Leetcode : 476. Number Complement (Easy)

??????????????е??? 0 ????

???? 00000101??????????????? 00000111 ?????????????????????????????? 00000111??

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;
}

???????? Java ?? Integer.highestOneBit() ????????ú????? 1 ??????

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

???? 10000000 ?????????????? 11111111?????????????·?????

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);
}

???????????

Leetcode : 371. Sum of Two Integers (Easy)

a ^ b ?????п????λ???????????????(a & b) << 1 ?????λ???????????????? (a & b) << 1 ?????????? 0???????????飬??λ?????? 0 ??????????????λ???? 0??????????

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

??????????

???????????????? P319

??????????????

Leetcode : 318. Maximum Product of Word Lengths (Medium)

?????????????????????????????Сд?????????????????????????????????????????????????????????????????????

?????·????????????????ж???????????????????????????????????Сд???????? 26 λ????????????? 32 λ?????????洢???????????????

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;
}

?ο?????

Leetcode
??? Offer
???????????
??????
????????????????
?????????????
??
???????????????л??????

127 KiB Raw Blame History Unescape Escape

?????

???????

??????

????

????

???????

??????

?????

????

BFS

DFS

Backtracking

????

???

????滮

???????

????·??

??????????

????????????

???????????

0-1 ????

????????

???????

????????

???

????

??????

???????

???

????????????

????????

??????????

????

????????

??????

?????

?????

?????????

???????

????

??

???

??α???

??к??????

BST

Trie

?

λ????

?ο?????

127 KiB

Raw Blame History