《程序员代码面试指南》第四章递归和动态规划

最新推荐文章于 2020-04-25 10:08:10 发布

remixone

最新推荐文章于 2020-04-25 10:08:10 发布

阅读量326

点赞数

分类专栏：程序员代码面试指南文章标签：程序员代码面试指南动态规划

本文链接：https://blog.csdn.net/remixone/article/details/78534361

版权

程序员代码面试指南专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、斐波那契系列问题的递归和动态规划

2、矩阵的最小路径和

给定一个矩阵m，从左上角开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，返回所有的路径中最小的路径和。

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

3、换钱的最少货币数

class Solution {
    public int coinChange(int[] coins, int amount) {
        final int n = coins.length, max = Integer.MAX_VALUE;
        int dp[][] = new int[n][amount+1];
        for (int j=1;j<=amount;++j){
            dp[0][j]=max;
            if(j>=coins[0]&&dp[0][j-coins[0]]!=max)dp[0][j]=dp[0][j-coins[0]]+1;
        }
        for(int i=1;i<n;++i){
            for(int j=1;j<=amount;++j){
                int left=max;
                if(j>=coins[i]&&dp[i][j-coins[i]]!=max){
                    left=dp[i][j-coins[i]]+1;
                }
                dp[i][j]=Math.min(dp[i-1][j],left);
            }
        }
        return dp[n-1][amount]==max?-1:dp[n-1][amount];
    }
}

class Solution {
    public int coinChange(int[] coins, int amount) {
        final int n = coins.length, max = Integer.MAX_VALUE;
        int[] dp = new int[amount+1];
        for(int i=1;i<=amount;++i)dp[i]=(i-coins[0]>=0&&dp[i-coins[0]]!=max)?(dp[i]=dp[i-coins[0]]+1):max;
        for(int i=1;i<n;++i)for(int j=1;j<=amount;++j)dp[j]=Math.min(dp[j],(j-coins[i]>=0&&dp[j-coins[i]]!=max)?dp[j-coins[i]]+1:max);
        return dp[amount]==max?-1:dp[amount];
    }
}

class Main {
    public static int minCoins(int[] arr, int aim) {
        int[][] dp = new int[arr.length][aim+1];
        final int MAX = Integer.MAX_VALUE;
        for(int i=1;i<=aim;++i)dp[0][i]=MAX;
        if(arr[0]<=aim)dp[0][arr[0]]=1;
        for(int i=1;i<arr.length;++i){
            for(int j=1;j<=aim;++j){
                dp[i][j]=Math.min((j-arr[i]>=0&&(dp[i-1][j-arr[i]]!=MAX))?dp[i-1][j-arr[i]]+1:MAX,dp[i-1][j]);
            }
        }
        return dp[arr.length-1][aim]==MAX?-1:dp[arr.length-1][aim];
    }
    public static void main(String[] args) {
        System.out.println("Hello World!");
        int[] arr={5,2,5,3};
        System.out.println(minCoins(arr,10));
    }
}

class Main {
    public static int minCoins(int[] arr, int aim) {
        int[] dp = new int[aim+1];
        final int MAX=Integer.MAX_VALUE;
        for(int i=1;i<=aim;++i)dp[i]=MAX;
        if(arr[0]<=aim)dp[arr[0]]=1;
        for(int i=1;i<arr.length;++i){
            for(int j=1;j<=aim;++j){
                dp[j]=Math.min(dp[j],(j-arr[i]>=0&&dp[j-arr[i]]!=MAX)?dp[j-arr[i]]+1:MAX);
            }
        }
        return dp[aim]==MAX?-1:dp[aim];
    }
    public static void main(String[] args) {
        System.out.println("Hello World!");
        int[] arr={5,2,5,3};
        System.out.println(minCoins(arr,10));
    }
}

5、最长递增子序列

6、汉诺塔问题

7、最长公共子序列问题

8、最长公共子串问题

9、最小编辑代价

class Solution {
public:
    int minDistance(string word1, string word2) {
        if (word1.size()==0) return word2.size();
        if (word2.size()==0) return word1.size();
        vector<vector<int>> dp(word1.size()+1, vector<int>(word2.size()+1, 0));
        for (int i = 0; i <= word2.size(); ++i) dp[0][i] = i;
        for (int i = 0; i <= word1.size(); ++i) dp[i][0] = i;
        for (int i = 1; i <= word1.size(); ++i) {
            for (int j = 1; j <= word2.size(); ++j) {
                if (word1[i-1] == word2[j-1]) dp[i][j] = dp[i-1][j-1];
                else dp[i][j] = dp[i-1][j-1]+1;
                dp[i][j] = min(dp[i][j], dp[i][j-1]+1);
                dp[i][j] = min(dp[i][j], dp[i-1][j]+1);
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

10、字符串的交错组成

11、龙与地下城游戏问题

class Solution {
public:
    int calculateMinimumHP(vector<vector<int>>& dungeon) {
        int m = dungeon.size(), n = dungeon[0].size();
        int **dp = new int*[m];
        for (int i = 0; i < m; ++i) dp[i] = new int[n];
        for (int i = 0; i < m; ++i) for (int j = 0; j < n; ++j) dp[i][j] = 0;
        if (dungeon[m-1][n-1] >= 0) dp[m-1][n-1] = 1;
        else dp[m-1][n-1] = 1-dungeon[m-1][n-1];
        if (m == 1 && n == 1) return dp[0][0];
        if (m == 1 && n > 1) goto n1;

        m1:
        for (int i = m-2; i >= 0; --i) {
            int rst = dp[i+1][n-1] - dungeon[i][n-1];
            if (rst <= 0) rst = 1;
            dp[i][n-1] = rst;
        }
        if (n == 1 && m > 1) return dp[0][0];


        n1:
        for (int i = n-2; i >= 0; --i) {
            int rst = dp[m-1][i+1] - dungeon[m-1][i];
            if (rst <= 0) rst = 1;
            dp[m-1][i] = rst;
        }
        if (m == 1 && n > 1) return dp[0][0];


        for (int i = m-2; i >= 0; --i) {
            for (int j = n-2; j >= 0; --j) {
                dp[i][j] = min(dp[i+1][j], dp[i][j+1]) - dungeon[i][j];
                if (dp[i][j] <= 0) dp[i][j] = 1;
            }
        }

        return dp[0][0];
    }

};