动态规划
鸡蛋掉落
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];
}
}