【算法题-分类型总结】动态规划相关的算法题

1、跳台阶/楼梯

public class Solution {

    public int jumpFloor(int target) {

        int p = 1, q = 1;

        //和自下而上的方法使用相同的循环结构

        for(int i = 2; i <= target; i++) {

            int temp = p;

            p = p + q;

            q = temp;

        }

        return p;

    }

}

 

2、最长公共子串

import java.util.*;

 

 

public class Solution {

    /**

     * longest common substring

     * @param str1 string字符串 the string

     * @param str2 string字符串 the string

     * @return string字符串

     */

    public String LCS (String str1, String str2) {

        int len1 = str1.length(), len2 = str2.length();

        int[][] dp = new int[len1 + 1][len2 + 1];

        int max = 0;

        int index  = 0;

        for(int i = 0; i < len1; i++) {

            for(int j = 0; j < len2; j++) {

                if(str1.charAt(i) == str2.charAt(j)) {

                    dp[i + 1][j + 1] = dp[i][j] + 1;

                }

                if(dp[i + 1][j + 1] > max) {

                    max = dp[i + 1][j + 1];

                    index = i;

                }

            }

        }

        return str1.substring(index - max + 1, index + 1);

    }

}

 

3、最小代价爬楼梯

思路：每个台阶对应一个cost体力值，目标是花费最低，dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i]

class Solution {

    public int minCostClimbingStairs(int[] cost) {

        if (cost == null || cost.length == 0) {

            return 0;

        }

        if (cost.length == 1) {

            return cost[0];

        }

        int[] dp = new int[cost.length];

        dp[0] = cost[0];

        dp[1] = cost[1];

        for (int i = 2; i < cost.length; i++) {

            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];

        }

        //最后一步，如果是由倒数第二步爬，则最后一步的体力花费可以不用算

        return Math.min(dp[cost.length - 1], dp[cost.length - 2]);

    }

}

 

4、网格不同路径

方法1：DFS回溯

class Solution {

private:

    int dfs(int i, int j, int m, int n) {

        if (i > m || j > n) return 0; // 越界了

        if (i == m && j == n) return 1; // 找到一种方法，相当于找到了叶子节点

        return dfs(i + 1, j, m, n) + dfs(i, j + 1, m, n);

    }

public:

    int uniquePaths(int m, int n) {

        return dfs(1, 1, m, n);

    }

};

 

方法2：动态规划

/**

     * 1. 确定dp数组下表含义 dp[i][j] 到每一个坐标可能的路径种类

     * 2. 递推公式 dp[i][j] = dp[i-1][j] dp[i][j-1]

     * 3. 初始化 dp[i][0]=1 dp[0][i]=1 初始化横竖就可

     * 4. 遍历顺序 一行一行遍历

     * 5. 推导结果 。。。。。。。。

     *

     * @param m

     * @param n

     * @return

     */

    public static int uniquePaths(int m, int n) {

        int[][] dp = new int[m][n];

        //初始化

        for (int i = 0; i < m; i++) {

            dp[i][0] = 1;

        }

        for (int i = 0; i < n; i++) {

            dp[0][i] = 1;

        }

 

        for (int i = 1; i < m; i++) {

            for (int j = 1; j < n; j++) {

                dp[i][j] = dp[i-1][j]+dp[i][j-1];

            }

        }

        return dp[m-1][n-1];

    }

 

5、有障碍物不同路径

class Solution {

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {

        int n = obstacleGrid.length, m = obstacleGrid[0].length;

        int[][] dp = new int[n][m];

        dp[0][0] = 1 - obstacleGrid[0][0];

        for (int i = 1; i < m; i++) {

            if (obstacleGrid[0][i] == 0 && dp[0][i - 1] == 1) {

                dp[0][i] = 1;

            }

        }

        for (int i = 1; i < n; i++) {

            if (obstacleGrid[i][0] == 0 && dp[i - 1][0] == 1) {

                dp[i][0] = 1;

            }

        }

        for (int i = 1; i < n; i++) {

            for (int j = 1; j < m; j++) {

                if (obstacleGrid[i][j] == 1) continue;

                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];

            }

        }

        return dp[n - 1][m - 1];

    }

}

 

6、斐波那契数列

方法1：带备忘录的递归（自顶向下）

class Solution {

    //初始化备忘录为0

    int[] mome;

    public int fib(int n) {

        mome  = new int[n+1];

        if(n < 1) return 0;

        return comput(mome,n);

    }

    public int comput(int []mome,int n){

        if(n == 1 || n == 2) return 1;

        if(mome[n]!=0) return mome[n];

        mome[n] = comput(mome, n-1) + comput(mome, n-2);

        return mome[n];

    }

}

 

方法2：自底向上的dp数组

class Solution {

    public int fib(int n) {

        if(n < 1) return 0;

        if(n == 1 || n ==2) return 1;

        int[] arr = new int[n+1]; //Java默认将数组初始化为0

        arr[1] = arr[2] = 1;

        for(int i = 3; i <= n; i++){

            arr[i] =arr[i-1] +arr[i-2];

        }

        return arr[n];

    }

}

 

方法3：状态压缩

class Solution {

    public int fib(int n) {

        if(n < 1) return 0;

        if(n==1 || n==2) return 1;

        int prev=1,curr=1,sum;

        for(int i=3;i<=n;i++){

            sum = prev + curr;

            prev = curr;

            curr = sum;

        }

        return curr;

    }

}

 

7、凑零钱

含义：使用不同面值零钱凑出指定数值

思路：初始条件、状态、选择、dp数组

class Solution {

    public int coinChange(int[] coins, int amount) {

        if(amount < 0) return -1;

        int[] dp = new int[amount+1];

        Arrays.fill(dp,amount+1);

        dp[0] = 0;

        for(int i = 0; i < dp.length; i++){

            for(int coin:coins){

                if(i -coin < 0) continue;

                dp[i] = Math.min(dp[i],1+dp[i-coin]);

            }

        }

        return dp[amount] == amount + 1 ? - 1 : dp[amount];

    }

}

 

 

8、≤数的二进制中1的个数

思路：n个数，返回长度为n的数组

package com.iflytek;

 

import java.util.Arrays;

 

public class DP_bin_1 {

    public static void main(String[] args) {

        int[] count = testDp(5);

        //Arrays.asList(count).forEach(System.out::println); --只适用于对象类型的数组

        Arrays.stream(count).forEach(System.out::println);

    }

    public static int[] testIntegerBitCount(int n){

 

　　　　 int[] ans = new int[n+1];

        for (int i = 0; i <= n; i ++){

            ans[i] = Integer.bitCount(i);

        }

        return ans;

 

    }

    public static int[] testDp(int n){

        int[] dp = new int[n+1]; // java默认赋初值

        for (int i = 0; i < n/2; i++) {

            dp[2*i] = dp[i];

            if (2*i + 1 < n){

                dp[2*i+1] = dp[i] + 1;

            }

        }

        return dp;

    }

}

 

9、接雨水

思路：左右最小-当前值并累加

方法1：双指针

import java.util.*;

public class Solution {

    /**

     * max water

     * @param arr int整型一维数组 the array

     * @return long长整型

     */

    //双指针

    public long maxWater (int[] arr) {

        long res = 0;

        int left = 0, right = arr.length - 1;

        int leftMax = 0, rightMax = 0;

        while(left < right) {

            leftMax = Integer.max(leftMax, arr[left]);

            rightMax = Integer.max(rightMax, arr[right]);

            if(leftMax < rightMax) {

                res += leftMax - arr[left];

                left++;

            } else {

                res += rightMax - arr[right];

                right--;

            }

        }

        return res;

    }

}

 

方法2：动态规划

import java.util.*;

public class Solution {

    /**

     * max water

     * @param arr int整型一维数组 the array

     * @return long长整型

     */

    //双指针

    public long maxWater (int[] arr) {

        long res = 0;

        int n = arr.length;

        int[] leftMax = new int[n];

        leftMax[0] = arr[0];

        for(int i = 1; i < n; i++) {

            leftMax[i] = Math.max(leftMax[i - 1], arr[i]);

        }

        int[] rightMax = new int[n];

        rightMax[n - 1] = arr[n - 1];

        for(int i = n - 2; i >= 0; i--) {

            rightMax[i] = Math.max(rightMax[ i + 1], arr[i]);

        }

        for(int i = 0; i < n; i++) {

            res += Math.min(leftMax[i], rightMax[i]) - arr[i];

        }

        return res;

    }

}

 

10、最大子序和

含义：连续子数组的最大和，可以使用贪心/动态规划解决

// 动态规划

class Solution {

    public int maxSubArray(int[] nums) {

        int fi = 0, maxRes = nums[0]; //初始化

        for(int x : nums) {

            fi = Math.max(x, fi + x);

            maxRes = Math.max(maxRes, fi);

        }

        return maxRes;

    }

}

 

//贪心

class Solution {

    public int maxSubArray(int[] nums) {

        int maxRes = nums[0];

        int sum = 0;

        for(int x : nums) {

            if(sum > 0) {

                sum += x;

            } else {

                sum = x; // 等于x而不等于0

            }

            maxRes = Math.max(maxRes, sum);

        }

        return maxRes;

    }

}

 

11、最长上升子序列长度

思路：最长递增子序列（longest increasing subsequence），简称LIS，贪心/动态规划

方法1：贪心+二分

import java.util.*;

 

public class Solution {

    /**

     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可

     * 给定数组的最长严格上升子序列的长度。

     * @param arr int整型一维数组 给定的数组

     * @return int整型

     */

    public int LIS (int[] arr) {

        int len = 1, n = arr.length;

        if(n == 0) {

            return 0;

        }

        int[] lisArr = new int[n + 1];

        lisArr[len] = arr[0];

        for(int i = 1; i < n; i++) {

            //len代表lisArr中的最后一个元素

            if(lisArr[len] < arr[i]) {

                lisArr[++len] = arr[i];

            } else {

                //二分，在lisArr数组中找比arr[i]小的，最靠后的位置pos

                //未找到，即lisArr数组中所有元素均大于arr[i]

                //需要更新lisArr数组的位置，为何不设为1呢？

                int l = 1,r = len, pos = 0;

                while(l <= r) {

                    //int mid = l + (r - l) >> 1;是错误的，原因是优先级导致的

                    int mid = l + ((r - l) >> 1);//位运算是为了避免溢出

                    //int mid = (l + r) >> 1;

                    if(lisArr[mid] < arr[i]) {

                        //更新指针

                        l = mid + 1;

                        pos = mid;

                    } else {

                        r = mid - 1;

                    }

                }

                //循环结束，找到了pos

                lisArr[pos + 1] = arr[i];

                //pos是最后一个位置，len不变

                //pos是中间位置，len仍不变，元素继续往后填

                //所以没有必要更新len位置

            }

        }

        return len;

    }

}

方法2：动态规划

import java.util.*;

 

public class Solution {

    /**

     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可

     * 给定数组的最长严格上升子序列的长度。

     * @param arr int整型一维数组 给定的数组

     * @return int整型

     */

    public int LIS (int[] arr) {

        //动态规划实现

        //最长子序列应当使用max值记录

        int n = arr.length;

        if(n == 0) {

            return 0;

        }

        int[] dp = new int[n];

        Arrays.fill(dp, 1);

        int maxLen = Integer.MIN_VALUE;

        for(int i = 0; i < n; i++) {

            for(int j = 0; j < i; j++) {

                if(arr[j] < arr[i]) {

                    dp[i] = Math.max(dp[i], dp[j] + 1);

                }

                maxLen = Math.max(maxLen, dp[i]);

            }

        }

        return maxLen;

    }

}

 

12、最长上升子序列（三）

思路：动态规划+二分，避免超时

import java.util.*;

 

 

public class Solution {

    /**

     * retrun the longest increasing subsequence

     * @param arr int整型一维数组 the array

     * @return int整型一维数组

     */

    public int[] LIS (int[] arr) {

        int n = arr.length;

        int[] dp = new int[n];

        int[] tail = new int[n + 1];

        int end = 0;

        tail[0] = Integer.MIN_VALUE; //存储对应位置元素的值

        for(int i = 0; i < n; i++) {

            int num = arr[i];

            if(tail[end] < num) {

                end++;

                tail[end] = num;

                dp[i] = end;

            } else {

                int site = Arrays.binarySearch(tail, 1, end, arr[i]);

                if(site >= 0) {

                    continue;

                }

                int ins = -(site + 1);

                tail[ins] = arr[i];

                dp[i] = ins;

            }

        }

        int[] res = new int[end];

        int len = end;

        for(int i = n - 1; i >= 0; i--) {

            if(dp[i] == len) {

                res[len - 1] = arr[i];

                len--;

            }

        }

        return res;

    }

}

 

13、最长公共子序列的长度

思路：相等时为对角线+1，不相等时为左上最大值

class Solution {

    public int longestCommonSubsequence(String text1, String text2) {

        int len1= text1.length(), len2= text2.length();

        int[][] dp = new int[len1 + 1][len2 + 1];

        for(int i = 1; i <= len1; i++) {

            char c1 = text1.charAt(i - 1);

            for(int j = 1; j <= len2; j++) {

                char c2= text2.charAt(j - 1);

                if(c1 == c2) {

                    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[len1][len2];

    }

}

 

14、最长公共子序列

思路：知道长度后，倒着寻找

import java.util.*;

 

 

public class Solution {

    /**

     * longest common subsequence

     * @param s1 string字符串 the string

     * @param s2 string字符串 the string

     * @return string字符串

     */

    public String LCS (String s1, String s2) {

        int row = s1.length(), col = s2.length();

        int[][] dp = new int[row + 1][col + 1];

        for(int i = 1; i <= row; i++) {

            for(int j = 1; j <= col; j++) {

                if(s1.charAt(i - 1) == s2.charAt(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]);

                }

            }

        }

        if(dp[row][col] == 0) {

            return "-1";

        }

        //数组大小为公共子串的长度

        char[] lcs = new char[dp[row][col]];

        int cur = lcs.length - 1;

        while(true) {

            //什么时候把元素添加到结果中，应该倒序添加

            if(s1.charAt(row - 1) == s2.charAt(col - 1)) {

                lcs[cur--] = s1.charAt(row - 1);

                if(cur < 0) {

                    return new String(lcs);

                }

                row--;

                col--;

                

            } else {

                if(dp[row][col - 1] > dp[row - 1][col]) {

                    col--;

                } else {

                    row--;

                }

            }

        }

    }

}

 

15、编辑距离

思路：类似求公共子序列

//动态规划

//dp[len1][len2]

//初始化、值相等、不相等

class Solution {

    public int minDistance(String word1, String word2) {

        int len1 = word1.length();

        int len2 = word2.length();

        int[][] dp = new int[len1 + 1][len2 + 1];

        for(int i = 0; i <= len1; i++) { //到len

            dp[i][0] = i;

        }

        for(int j = 0; j <= len2; j++) { //到len

            dp[0][j] = j;

        }

        for(int i = 1; i <= len1; i++) {

            for(int j = 1; j <= len2; j++) { //到len

                if(word1.charAt(i - 1) == word2.charAt(j - 1)) { //字符是-1

                    dp[i][j] = dp[i - 1][j - 1];

                } else {

                    dp[i][j] = 1 + Math.min(dp[i - 1][j], Math.min(dp[i][j - 1], dp[i - 1][j - 1]));

                }

            }

        }

        return dp[len1][len2];

    }

}