刷题：动态规划（三）

1.LeetCode1130
注意：
1).写循环条件时：
错误写法：

for(int i = 0 ; i + 2 < size ; i ++) {
    for(int j = i + 2 ; j < size ; j ++) {
        dp[i][j] = 1<<30 ;
        for(int k = i ; k < j ; k ++) dp[i][j] = min(dp[i][j] , dp[i][k] + dp[k + 1][j] + mx(arr , i , k) * mx(arr , k + 1 , j)) ;
    }
}

正确写法：

for(int j = 2 ; j < size ; j ++) {
    for(int i = 0 ; i + j < size ; i ++) {
        dp[i][i + j] = 1<<30 ;
        for(int k = i ; k < i + j ; k ++) dp[i][i + j] = min(dp[i][i + j] , dp[i][k] + dp[k + 1][i + j] + mx(arr , i , k) * mx(arr , k + 1 , i + j)) ;
    }
}

动态规划是自顶向下的，所以正确写法的顺序是：（初始化距离为0、1的子问题）先写距离为2的子问题，再写距离为3、……的子问题（原料是小子问题）；而我的错误写法的顺序是先写左端为0，距离为2、3、……，再写左端为1，距离为2、3、……；
代码：

class Solution {
public:
    int mx(vector<int>& arr , int i , int j) {
        if(i == j) return arr[i] ;
        int max = arr[i] ;
        for(int n = i ; n <= j ; n ++) {
            if(arr[n] > max) max = arr[n] ;
        }
        return max ;
    }
    int mctFromLeafValues(vector<int>& arr) {
        int size = arr.size() ;
        vector<vector<int>> dp(size , vector<int>(size)) ;
        for(int i = 0 ; i < size - 1 ; i ++) {
            dp[i][i] = 0 ;
            dp[i][i + 1] = arr[i] * arr[i + 1] ;
        }
        dp[size - 1][size - 1] = 0 ;
        for(int j = 2 ; j < size ; j ++) {
            for(int i = 0 ; i + j < size ; i ++) {
                dp[i][i + j] = 1<<30 ;
                for(int k = i ; k < i + j ; k ++) dp[i][i + j] = min(dp[i][i + j] , dp[i][k] + dp[k + 1][i + j] + mx(arr , i , k) * mx(arr , k + 1 , i + j)) ;
            }
        }
        return dp[0][size - 1] ;
    }
};

2.LeetCode96
思路：
一开始我想用dp[i][j]表示从 i 到 j 可以组成的树的种类，但是正确答案是用dp[i]表示 i 个数可以组成的树的种类，因为之后的过程与数值无关，只与数的个数有关；
代码：

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1 , 0) ;
        dp[0] = 1 ;
        dp[1] = 1 ;
        for(int i = 2 ; i <= n ; i ++) {
            for(int k = 0 ; k < i ; k ++) dp[i] += dp[k] * dp[i - k - 1] ;
        }
        return dp[n] ;
    }
};

3.LeetCode1039
思路：写循环时可以把第一个或者第二个的状态转移方程列出来，看怎么写条件；
代码：

class Solution {
public:
    int minScoreTriangulation(vector<int>& A) {
        vector<vector<int>> dp(A.size() , vector<int>(A.size() , INT_MAX)) ;
        for(int i = 0 ; i < A.size() - 1 ; i ++) dp[i][i + 1] = 0 ;
        for(int i = 0 ; i < A.size() - 2 ; i ++) dp[i][i + 2] = A[i] * A[i + 1] * A[i + 2] ;
        for(int j = 3 ; j < A.size() ; j ++) {
            for(int i = j - 2 ; i >= 0 ; i --) {
                for(int k = i + 1 ; k < j ; k ++) dp[i][j] = min(dp[i][j] , dp[i][k] + dp[k][j] + A[i] * A[k] * A[j]) ;
            }
        }
        return dp[0][A.size() - 1] ;
    }
};

4.LeetCode375
代码：

class Solution {
public:
    int getMoneyAmount(int n) {
        vector<vector<int>> dp(n + 1 , vector<int>(n + 1 , INT_MAX)) ;
        for(int i = 1 ; i <= n ; i ++) dp[i][i] = 0 ;
        for(int j = 2 ; j <= n ; j ++) {
            for(int i = j - 1 ; i >= 1 ; i --) {
                for(int k = i ; k <= j ; k ++) {
                    if(k == i) dp[i][j] = min(dp[i][j] , i + dp[k + 1][j]) ;
                    else if(k == j) dp[i][j] = min(dp[i][j] , j + dp[i][k - 1]) ;
                    else dp[i][j] = min(dp[i][j] , k + max(dp[i][k - 1] , dp[k + 1][j])) ;
                }
            }
        }
        return dp[1][n] ;
    }
};