九章算法 - 零、动态规划入门 669. 114. 116.

669.Coin Change

给出不同面额的硬币以及一个总金额. 写一个方法来计算给出的总金额可以换取的最少的硬币数量. 如果已有硬币的任意组合均无法与总金额面额相等, 那么返回 -1

提示：最后一步为最优策略中使用的最后一枚硬币，子问题为最少硬币拼出更小的面值27-ak。

            转移方程f[X] = min{f[X-2]+1, f[X-5]+1, f[X-7]+1}

答案：

class Solution {
public:
    /**
     * @param coins: a list of integer
     * @param amount: a total amount of money amount
     * @return: the fewest number of coins that you need to make up
     */
    //dp[i] - the fewest number of coins you need to make up amount i
    //dp[i]  = min(dp[i-1], dp[i-2], dp[i-5])+1, 前提 i-coins[j] > 0 && dp[i-coins[j]] != -1
    int coinChange(vector<int> &coins, int amount) {
        // write your code here
        vector<int> dp(amount+1, -1);
        dp[0] = 0;
        for(int i = 1; i<=amount; ++i) {
            for(int j = 0; j<coins.size(); ++j) {
                int v = i-coins[j];
                if(v >= 0 && dp[v] != -1) {
                    if(dp[i] == -1 || dp[v]+1<dp[i]) {
                        dp[i] = dp[v]+1;
                    }
                }
            }
        }
        return dp[amount];
    }
};

114.Unique Paths

机器人位于m x n网格的左上角。机器人只能在任何时间点向下或向右移动。机器人正试图到达网格的右下角。有多少可能的独特路径？

提示：初始化边界，方式数等于上面与左面的和。

答案：

class Solution {
public:
    /**
     * @param m: positive integer (1 <= m <= 100)
     * @param n: positive integer (1 <= n <= 100)
     * @return: An integer
     */
    int uniquePaths(int m, int n) {
        // write your code here
        vector<vector<int>> f(m,vector<int>(n));
        
        for(int i = 0; i < m; i++)
           for(int j = 0; j < n; j++){
               if(i == 0 || j == 0){
                   f[i][j] = 1;
               }
               else
               {
                   f[i][j] = f[i-1][j] + f[i][j-1];
               }
           }
        return f[m-1][n-1];    
    }
};

 

116.Jump Game

给出一个非负整数数组，你最初定位在数组的第一个位置。　　　

数组中的每个元素代表你在那个位置可以跳跃的最大长度。　　　　

判断你是否能到达数组的最后一个位置。

提示：动态规划不如贪心，可能出现过不了的情况

           动态规划遍历1到A.size()-1,对于每个i遍历其前面的点，如果有一个可以到达i那么就将其设为true。

           贪心算法遍历1到A.size()-1,设置一个变量记录目前遍历到的最大值，一旦i>tmpMax就返回false,不断更新tmpMax。

答案：

class Solution {
public:
    bool canJump(vector<int> A) {
        int tmpMax = 0;
        int n = A.size();
        for (int i = 0; i < n; i++) {
            if (i > tmpMax) return false;
            if (tmpMax < i + A[i])
                tmpMax = i + A[i];
        }
        return true;
    }
};