动态规划

鸡蛋掉落

class Solution {
    public int superEggDrop(int K, int N) {
        int[][] dp = new int[K + 1][N + 1];
        for (int i = 0; i <= K; i++) {
            dp[i][0] = 0;
            dp[i][1] = 1;
        }

        for (int i = 1; i <= N; i++) {
            dp[0][i] = 0;
            dp[1][i] = i;
        }

        for (int i = 2; i < K + 1; i++) {
            for (int j = 2; j < N + 1; j++) {
                int left = 0;
                int right = j;
                while (left < right) {
                    int mid = left + (right - left + 1) / 2;
                    int broken = dp[i - 1][mid - 1];
                    int unBroken = dp[i][j - mid];
                    if (broken > unBroken) {
                        right = mid -1;
                    } else {
                        left = mid;
                    }
                }
                dp[i][j] = Math.max(dp[i - 1][left - 1], dp[i][j - left]) + 1;
            }
        }
        return dp[K][N];
    }
}

最长重复子数组

class Solution {
    public int findLength(int[] A, int[] B) {
        int[][] dp = new int[A.length][B.length];


        dp[0][0] = A[0] == B[0] ? 1 : 0;
        for (int i = 0; i < A.length; i++) {
            dp[i][0] = A[i] == B[0] ? 1 : 0;
        }
         for (int i = 0; i < B.length; i++) {
            dp[0][i] = A[0] == B[i] ? 1 : 0;
        }
        int result = 0;
        for (int i = 1; i < A.length; i++) {
            for (int j = 1; j < B.length; j++) {
                if (A[i] == B[j])
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                else
                    dp[i][j] = 0;
                result = Math.max(result, dp[i][j]);
            }
        }
        return result;
    }
}

最长回文子串

class Solution {
    // i, j 是回文
    // 
    public String longestPalindrome(String s) {
        char[] cs = s.toCharArray();
        int m = cs.length;
        int maxLength = 1;
        int begin = 0;
        if (m < 2) {
            return s;
        }

        boolean[][] result = new boolean[m][m];

        for (int i = 0; i < m; i++) {
            result[i][i] = true;
        }

        for (int i = 1; i < m; i++) {
            for (int j = 0; j < i; j++) {
                if (cs[i] != cs[j]) {
                    result[i][j] = false;
                } else {
                    if (i - j < 3) {
                        result[i][j] = true;
                    } else {
                        result[i][j] = result[i - 1][j + 1];
                    }
                }

                if (result[i][j] && i - j + 1 > maxLength) {
                    maxLength = i -j + 1;
                    begin = j;
                }
            }
        }
        return s.substring(begin, maxLength + begin);


    }
}

编辑距离

class Solution {
    public int minDistance(String word1, String word2) {
        if (word1.length() == 0 || word2.length() == 0) {
            return word1.length() == 0 ? word2.length() : word1.length();
        }

        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
       
        for (int i = 1; i <= word1.length(); i++) {
            dp[i][0] = i;
        }
        for (int i = 1; i <= word2.length(); i++) {
            dp[0][i] = i;
        }
        dp[0][0] = 0;
        for (int i = 1; i <= word1.length(); i++) {
            for (int j = 1; j <= word2.length(); j++) {
                if (word2.charAt(j-1) == word1.charAt(i-1)) {
                    dp[i][j] = dp[i-1][j-1];
                } else {
                    dp[i][j] = Math.min(Math.min(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1])+1;
                }
            }
        }
        return dp[word1.length()][word2.length()];
    }
}

最大子序和

class Solution {
    public int maxSubArray(int[] nums) {
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
        }

        int result = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            result = Math.max(result, dp[i]);
        }
        return result;
    }
}

最小路径和

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

爬楼梯

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

最长上升子序列

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

统计全为 1 的正方形子矩阵

class Solution {
    public int countSquares(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] dp = new int[m][n];
        int result = 0;
        for (int i = 0; i < m; i++) {
            dp[i][0] = matrix[i][0];
            result += dp[i][0];
        }
        for (int i = 1; i < n; i++) {
            dp[0][i] = matrix[0][i];
            result += dp[0][i];
        }
        
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][j] == 0) 
                    dp[i][j] = 0;
                else
                    dp[i][j] = Math.min(dp[i-1][j], Math.min(dp[i-1][j-1], dp[i][j-1])) + 1;
                result += dp[i][j];
            }
        }
        return result;
    }
}

零钱兑换

class Solution {
    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 + 1; i++) {
            for (int coin : coins) {
                if (i >= coin)
                    dp[i] = Math.min(dp[i], dp[i-coin] + 1);
            }
        }
        return dp[amount] == amount + 1 ? -1 : dp[amount];
    }
}

零钱兑换 II

class Solution {
    public int change(int amount, int[] coins) {
        int dp[] = new int[amount + 1];
        dp[0] = 1;
        for (int i = 1; i < amount + 1; i++) {
            dp[i] = 0;
        }

        for (int i = 0; i < coins.length; i++) {
            for (int j = 0; j <= amount ; j++) {
                if (j >= coins[i])
                    dp[j] += dp[j-coins[i]];
            }
        }
        
        return dp[amount];
    }
}

最长回文子序列

class Solution {
    public int longestPalindromeSubseq(String s) {
        int n = s.length();
        int[][] dp = new int[n][n];
        for (int l = 0; l < n; l++) {
            for (int j = 0; j + l < n; j++) {
                int i = j + l;
                if (l==0) {
                    dp[j][i] = 1;
                } else if(l==1) {
                    dp[j][i] = s.charAt(i) == s.charAt(j) ? 2 : 1;
                } else {
                    if (s.charAt(i) != s.charAt(j)) {
                        dp[j][i] = Math.max(dp[j+1][i], dp[j][i-1]);
                    } else {
                        dp[j][i] = dp[j+1][i-1] + 2;
                    }
                }
            }
        }
        return dp[0][n-1];
    }
}

分割等和子集

class Solution {
    public boolean canPartition(int[] nums) {
        int n = nums.length;
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum+=nums[i];
        }
        if (sum % 2 == 1) {
            return false;
        }
        int target = sum/2;
        boolean[][] dp = new boolean[n][target+1];
        for (int i = 0; i < n; i++) {
            if (nums[i] <= target)
                dp[i][nums[i]] = true;
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < target + 1; j++) {
                dp[i][j] = dp[i-1][j];
                if (nums[i] == j) {
                    dp[i][j] = true;
                    continue;
                }
                if (nums[i] < j) {
                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]];
                }
            }
        }
        return dp[n - 1][target];
    }
}