刷题：动态规划（一）

状态转移方程：
routes[i] = min( routes[i-1] , … , routes[i-k] ) + cost[i] ；
1.LeetCode746
代码：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int size = cost.size() ;
        int dp[size + 1] ;
        cost.push_back(0) ;
        dp[0] = cost[0] ;
        dp[1] = cost[1] ;
        for(int i = 2 ; i <= size ; i ++) dp[i] = min(dp[i - 1] , dp[i - 2]) + cost[i] ;
        return dp[size] ;
    }
};

2.LeetCode64
代码：

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size() ;
        int n = grid[0].size() ;
        int dp[m][n] ;
        for(int i = 0 ; i < m ; i ++) {
            dp[i][0] = 0 ;
            for(int j = 0 ; j <= i ; j ++) dp[i][0] += grid[j][0] ;
        }
        for(int i = 0 ; i < n ; i ++) {
            dp[0][i] = 0 ;
            for(int j = 0 ; j <= i ; j ++) dp[0][i] += grid[0][j] ;
        }
        for(int r = 1 ; r < m ; r ++) {
            for(int c = 1 ; c < n ; c ++) dp[r][c] = min(dp[r - 1][c] , dp[r][c - 1]) + grid[r][c] ;
        }
        return dp[m - 1][n - 1] ;
    }
};

3.LeetCode322
代码：

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int size = coins.size() ;
        int dp[amount + 1] ;
        if(amount == 0) return 0 ;
        dp[0] = 0 ;
        for(int i = 1 ; i <= amount ; i ++) {
            dp[i] = 1<<30 ;
            for(int j = 0 ; j < size ; j ++) {
                if(i - coins[j] >= 0) dp[i] = min(dp[i] , dp[i - coins[j]] + 1) ;
            }
        }
        if(dp[amount] < 1<<30) return dp[amount] ;
        else return -1 ;
    }
};

4.LeetCode931
代码：

class Solution {
public:
    int minFallingPathSum(vector<vector<int>>& A) {
        int size = A.size() ;
        int dp[size][size] ;
        for(int i = 0 ; i < size ; i ++) dp[0][i] = A[0][i] ;
        for(int r = 1 ; r < size ; r ++) {
            for(int c = 0 ; c < size ; c ++) {
                dp[r][c] = dp[r - 1][c] + A[r][c] ;
                if(c - 1 >= 0) dp[r][c] = min(dp[r][c] , dp[r - 1][c - 1] + A[r][c]) ;
                if(c + 1 < size) dp[r][c] = min(dp[r][c] , dp[r - 1][c + 1] + A[r][c]) ;
            }
        }
        int ans = 1<<30 ;
        for(int i = 0 ; i < size ; i ++) {
            ans = min(dp[size - 1][i] , ans) ;
        }
        return ans ;
    }
};

5.LeetCode983
注意：
1).dp[i]有两种不同表示方式
代码：

class Solution {
public:
    int trans(int a) {
        if(a < 0) return 0 ;
        else return a ;
    }
    int mincostTickets(vector<int>& days, vector<int>& costs) {
        int size = days.back() ;
        vector<bool> travel(size + 1 , false) ;
        for(int i = 0 ; i < days.size() ; i ++) {
            travel[days[i]] = true ;
        }
        int dp[size + 1] ;
        dp[0] = 0 ;
        for(int i = 1 ; i <= size ; i ++) {
            if(travel[i] == false) dp[i] = dp[i - 1] ;
            else dp[i] = min(min(dp[i - 1] + costs[0] , dp[trans(i - 7)] + costs[1]) , dp[trans(i - 30)] + costs[2]) ;
        }
        return dp[size] ;
    }
};

6.LeetCode650
思路：
状态转移方程：dp[i] = dp[i的因数] + 倍数；
代码：

class Solution {
public :
    int minSteps(int n) {
        int dp[n + 1] ;
        dp[1] = 0 ;
        for(int i = 2 ; i <= n ; i ++) {
            dp[i] = 1<<30 ;
            for(int j = 1 ; j < n ; j ++) {
                if(i % j != 0) continue ;
                dp[i] = min(dp[i] , dp[j] + i / j) ;
            }
        }
        return dp[n] ;
    }
};

7.LeetCode279
代码：

class Solution {
public:
    int numSquares(int n) {
       int dp[n + 1] ;
       dp[0] = 0 ;
       dp[1] = 1 ;
       for(int i = 2 ; i <= n ; i ++) {
           dp[i] = 1<<30 ;
           for(int j = 1 ; j * j <= i ; j ++) dp[i] = min(dp[i] , dp[i - j * j] + 1) ;
       }
       return dp[n] ;
    }
};