算法练习（动态规划）

1.

public int longestSubstring(String s, int k) {
        return dfs(s, k);
    }

    private int dfs(String s, int k) {
        int[] charCount = new int[26];
        Arrays.fill(charCount, 0);
        for (int i = 0; i < s.length(); i++) {
            charCount[s.charAt(i) - 'a']++;
        }

        String spilt = "";
        for (int i = 0; i < 26; i++) {
            if (charCount[i] > 0 && charCount[i] < k) {
                spilt = String.valueOf((char) (i + 'a'));
            }
        }

        if (spilt.equals("")) {
            return s.length();
        }

        String[] spilts = s.split(spilt);
        int max = 0;
        for (int i = 0; i < spilts.length; i++) {
            int length = dfs(spilts[i], k);
            max = Math.max(max, length);
        }
        return max;
    }

2.

 public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }


    int max = Integer.MIN_VALUE;

    public int maxPathSum(TreeNode root) {
        pathDfs(root);
        return max;
    }

    private int pathDfs(TreeNode root) {
        if (root == null) {
            return 0;
        }

        int left = Math.max(pathDfs(root.left), 0);
        int right = Math.max(pathDfs(root.right), 0);

        int priceNewPath = root.val + left + right;
        max = Math.max(max, priceNewPath);

        return root.val + Math.max(left, right);
    }

3.

public static int longestConsecutive(int[] nums) {
        Set<Integer> num_set = new HashSet<Integer>();
        for (int num : nums) {
            num_set.add(num);
        }

        int longestStreak = 0;

        for (int num : num_set) {
            if (!num_set.contains(num - 1)) {
                int currentNum = num;
                int currentStreak = 1;

                while (num_set.contains(currentNum + 1)) {
                    currentNum += 1;
                    currentStreak += 1;
                }

                longestStreak = Math.max(longestStreak, currentStreak);
            }
        }
        return longestStreak;
    }
 //只用数组试了下，很慢  
public static int longestConsecutive(int[] nums) {
        int[] a = nums.clone();
        Arrays.sort(a);
        if (a.length == 0){
            return 0;
        }
        if (a.length == 1){
            return 1;
        }
        int maxLength = 0;
        int temp = 1;
        for (int i = 1; i < a.length; i++) {
            if (a[i] - a[i - 1] == 1){
                temp++;
            }else if (a[i] == a[i - 1]){
                continue;
            }else {
                maxLength = Math.max(maxLength,temp);
                temp = 1;
            }
        }
        maxLength = Math.max(maxLength,temp);
        return maxLength;
  }

4.

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

5.

protected boolean isSquare(int n) {
        int sq = (int) Math.sqrt(n);
        return n == sq * sq;
    }

public int numSquares(int n) {
        //数学方法，由公式就是好
        //four-square and three-square theorems.
        while (n % 4 == 0)
            n /= 4;
        if (n % 8 == 7)
            return 4;

        if (this.isSquare(n))
            return 1;
        // enumeration to check if the number can be decomposed into sum of two squares.
        for (int i = 1; i * i <= n; ++i) {
            if (this.isSquare(n - i * i))
                return 2;
        }
        // bottom case of three-square theorem.
        return 3;
    }


public int numSquares(int n) {
        ArrayList<Integer> square_num = new ArrayList<>();
        for (int i = 0; i * i <= n; i++) {
            square_num.add(i * i);
        }

        Set<Integer> queue = new HashSet<>();
        queue.add(n);

        int num = 0;

        while (queue.size() >= 0) {
            num += 1;
            Set<Integer> next_queue = new HashSet<>();

            for (Integer integer : queue) {
                for (Integer square : square_num) {
                    if (integer.equals(square)) {
                        return num;
                    } else if (integer < square) {
                        break;
                    } else {
                        next_queue.add(integer - square);
                    }
                }
            }

            queue = next_queue;
        }
        return num;
}

6.

public int lengthOfLIS(int[] nums) {
        //动态规划
        if (nums.length == 0) {
            return 0;
        }
        int[] dp = new int[nums.length];
        dp[0] = 1;
        int maxLength = 1;
        for (int i = 1; i < nums.length; i++) {
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            maxLength = Math.max(maxLength, dp[i]);
        }
        return maxLength;
    }

public int lengthOfLIS(int[] nums) {
       //贪心+二分查找
        int len = 1;
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int[] dp = new int[n + 1];
        dp[len] = nums[0];
        for (int i = 1; i < n; i++) {
            if (dp[len] <= nums[i]) {
                dp[++len] = nums[i];
            } else {
                int l = 1;
                int r = len;
                int pos = 0;
                while (l <= r) {
                    int mid = (l + r) >> 1;
                    if (dp[mid] < nums[i]) {
                        pos = mid;
                        l = mid + 1;
                    } else {
                        r = mid - 1;
                    }
                }
                dp[pos + 1] = nums[i];
            }
        }
        return len;
    }

7.

 public int coinChange(int[] coins, int amount) {
        if (amount == 0) {
            return 0;
        }
        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];
    }

8.

/*题目要找的是连续递增的序列，且方向只能是上，下，左，右4个方向，所以可以先从一个格子开始找，对比它4周的格子，有没有比它小的，如果有，比如有A，B，C三个格子都比它小，那么当前格子的最大连续递增长度就是这3个格子的最大连续递增长度中的最大值+1（有点绕，多读两遍应该就可以理解了），那么A，B，C的最大长度从哪里来呢，答案肯定是递归去找，直到找到一个比它四周都小的格子，当前格子长度就定为1，至此，整个思路就缕清了，需要用一个与matrix一样大小的数组来存放每一个格子的最大递增长度
时间复杂度：O(mn) 需要将整个数组遍历一遍，由于有visited记录，不会重复遍历
空间复杂度：O(mn) 需要一个与matrix同样大小的数组，记录已经访问过的格子

注意：由于题中是连续递增的，所以不会出现成环的情况*/
public int longestIncreasingPath(int[][] matrix) {
        if (matrix == null || matrix.length == 0) {
            return 0;
        }

        int[][] visited = new int[matrix.length][matrix[0].length];
        int max = 0;
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                if (visited[i][j] == 0) {
                    max = Math.max(max, dfs(i, j, matrix, visited));
                }
            }
        }
        return max;
    }

    public int dfs(int i, int j, int[][] matrix, int[][] visited) {
        if (i < 0 || i > matrix.length || j < 0 || j > matrix[0].length) {
            return 0;
        }
        if (visited[i][j] > 0) {
            return visited[i][j];
        }
        int max = 0;
        if (i - 1 >= 0 && matrix[i - 1][j] < matrix[i][j]) {
            max = Math.max(max, dfs(i - 1, j, matrix, visited));
        }
        if (i + 1 < matrix.length && matrix[i + 1][j] < matrix[i][j]) {
            max = Math.max(max, dfs(i + 1, j, matrix, visited));
        }
        if (j - 1 >= 0 && matrix[i][j - 1] < matrix[i][j]) {
            max = Math.max(max, dfs(i, j - 1, matrix, visited));
        }
        if (j + 1 < matrix[0].length && matrix[i][j + 1] < matrix[i][j]) {
            max = Math.max(max, dfs(i, j + 1, matrix, visited));
        }

        visited[i][j] = max + 1;
        return max + 1;
    }
    
 /*括扑排序*/
 public int longestIncreasingPath(int[][] matrix) {
        if (matrix==null||matrix.length==0){
            return 0;
        }
        int[][] count = new int[matrix.length][matrix[0].length];
        int[][] direction = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
        //统计每个点的入度用count数组保存，因为是递增，所以如果在上下左右，每发现一个比当前点小的数，当前点入度+1
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                for (int[] d : direction) {
                    if (longestIncreasingPathVerify(matrix, i + d[0], j + d[1]) && matrix[i + d[0]][j + d[1]] < matrix[i][j]) {
                        count[i][j]++;
                    }
                }
            }
        }
        Deque<int[]> deque = new LinkedList<>();
        //count数组中所有入度为0的点加入队列
        for (int i = 0; i < count.length; i++) {
            for (int j = 0; j < count[i].length; j++) {
                if (count[i][j] == 0) {
                    deque.add(new int[]{i, j});
                }
            }
        }
        int ans = 0;
        while (!deque.isEmpty()) {
            ans++;
            for (int size = deque.size(); size > 0; size--) {
                int[] poll = deque.poll();
                for (int[] d : direction) {
                    if (longestIncreasingPathVerify(matrix, poll[0] + d[0], poll[1] + d[1]) && matrix[poll[0] + d[0]][poll[1] + d[1]] > matrix[poll[0]][poll[1]]) {
                        if (--count[poll[0] + d[0]][poll[1] + d[1]] == 0) {
                            deque.add(new int[]{poll[0] + d[0], poll[1] + d[1]});
                        }
                    }
                }
            }
        }
        return ans;
    }

    private boolean longestIncreasingPathVerify(int[][] matrix, int i, int j) {
        return i >= 0 && j >= 0 && i < matrix.length && j < matrix[i].length;
    }