Leetcode算法题总结之区间dp

Leetcode算法题总结之区间dp

1. 312 戳气球

https://leetcode-cn.com/problems/burst-balloons/

class Solution {
public:
    int maxCoins(vector<int>& nums) {
        nums.insert(nums.begin(), 1);
        nums.push_back(1);
        int size = nums.size();
        vector<vector<int>> dp(size, vector<int>(size, 0));
        dp[0][0] = 1;
        for(int i = size - 2; i >= 0; i--){
            for(int j = i + 2; j < size; j ++){
                for(int k = i + 1; k < j; k ++){
                    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j] + nums[i] * nums[j] * nums[k] );
                }
            }
        }
        return dp[0][size-1];
    }
};

2. 1547 切棍子的最小成本

https://leetcode-cn.com/problems/minimum-cost-to-cut-a-stick/

class Solution {
public:
    int minCost(int n, vector<int>& cuts) {
        cuts.push_back(0);
        cuts.push_back(n);
        sort(cuts.begin(), cuts.end());
        int size = cuts.size();
        vector<vector<int>> dp(size, vector<int>(size, 0x3f3f3f3f));
        dp[0][0] = 0;
        for(int i = 1; i < size; i++){
            dp[i][i] = 0; dp[i-1][i] = 0;
        }
        for(int i = size - 2; i >= 0; i--){
            for(int j = i + 2; j < size; j++){
                for(int k = i + 1; k < j; k++){
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + cuts[j]-cuts[i]);
                }
            }
        }
        return dp[0][size-1];
    }
};

3. 1000 合并石头的最低成本

https://leetcode-cn.com/problems/minimum-cost-to-merge-stones/

class Solution {
public:
    int mergeStones(vector<int>& stones, int K) {
        int size = stones.size();
        if(size == 1) return 0;
        if((size - 1) % (K - 1)) return -1;
        vector<int> sums(size+1, 0);
        vector<vector<int>> dp(size, vector<int>(size, 0));
        sums[1] = stones[0];
        for(int i = 2; i <= size; i++)
            sums[i] = sums[i-1] + stones[i-1];
        for(int i = size - K + 1; i >= 0; i--){
            for(int j = i + K - 1; j < size; j++){
                dp[i][j] = 0x3f3f3f3f;
                for(int k = i; k < j; k += (K-1))
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j]);
                if((j - i) % (K - 1) == 0) dp[i][j] += sums[j+1] - sums[i];
            }
        }
        return dp[0][size - 1];
    }
};

4. 813 最大平均值和的分组

https://leetcode-cn.com/problems/largest-sum-of-averages/

class Solution {
public:
    double largestSumOfAverages(vector<int>& A, int K) {
        int size = A.size();
        vector<vector<double>> dp(size+1, vector<double>(K+1, 0));
        vector<int> sums(size + 1, 0);
        for(int i = 1; i <= size; i ++){
            sums[i] = sums[i-1] + A[i-1];
            dp[i][1] = sums[i] * 1.0 / i;
        }
        for(int k = 2; k <= K; k ++){
            for(int i = k; i <= size; i ++){
                for(int j = k-1; j < i; j++){
                    dp[i][k] = max(dp[i][k], dp[j][k-1] + (sums[i] - sums[j]) * 1.0 / (i - j));
                }
            }
        }
        return dp[size][K];
    }
};

5. 647 回文子串

https://leetcode-cn.com/problems/palindromic-substrings/

class Solution {
public:
    bool dp[1000][1000];
    int countSubstrings(string s) {
        int size = s.size();
        dp[0][0] = true;
        for(int i = 1; i < size; i++){
            dp[i][i] = true;
            if(s[i-1] == s[i]){
                dp[i-1][i] = true;
            }
        }
        for(int len = 2; len < size; len ++){
            for(int i = 0; i < size - len; i++){
                int j = i + len;
                dp[i][j] = dp[i+1][j-1] && s[i] == s[j];
            }
        }
        int sum = 0; //用 accumulate 函数计算总和
        for(const auto & v : dp)
            sum = accumulate(v, v + size, sum);
        return sum;
    }
};

6. 730 统计不同回文子序列

https://leetcode-cn.com/problems/count-different-palindromic-subsequences/

class Solution {
public:
    int dp[1000][1000];
    int countPalindromicSubsequences(string S) {
        int size = S.size();
        dp[0][0] = 1;
        for(int i = 1; i < size; i++){
            dp[i][i] = 1;
            dp[i-1][i] = 2;
        }
        for(int len = 2; len < size; len++){
            for(int i = 0; i < size - len; i ++){
                int j = i + len;
                if(S[i] != S[j]) 
                    dp[i][j] = dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1];
                else{
                    dp[i][j] = 2 * dp[i+1][j-1];
                    int left = i + 1, right = j - 1;
                    while(left <= right && S[left] != S[i]) left ++;
                    while(left <= right && S[right] != S[i]) right --;
                    if(left == right) dp[i][j] += 1;
                    else if(left > right) dp[i][j] += 2;
                    else
                        dp[i][j] -= dp[left+1][right-1];
                }
                dp[i][j] = dp[i][j] < 0 ? dp[i][j] + 1000000007 : dp[i][j] % 1000000007;
            }
        }
        return dp[0][size-1];
    }
};

7. 87 扰乱字符串

https://leetcode-cn.com/problems/scramble-string/submissions/

class Solution {
public:
    bool dp[100][100][101];
    bool isScramble(string s1, string s2) {
        int size = s1.size();
        // vector<vector<vector<bool>>> dp(size, vector<vector<bool>>(size, vector<bool>(size+1, false)));
        for(int i = 0; i < size; i++)
            for(int j = 0; j < size; j++)
                dp[i][j][1] = (s1[i] == s2[j]);
        for(int len = 2; len <= size; len++){
            for(int i = 0; i <= size - len; i++){
                for(int j = 0; j <= size-len; j++){
                    for(int k = 1; !dp[i][j][len] && k < len; k ++){
                        dp[i][j][len] = (dp[i][j][k] && dp[i+k][j+k][len-k]) || (dp[i][j+len-k][k] && dp[i+k][j][len-k]);
                        // if(dp[i][j][len]) break;
                    }
                }
            }
        }
        return dp[0][0][size];
    }
};

8. 5 最长回文串

https://leetcode-cn.com/problems/longest-palindromic-substring/

class Solution {
public:
    bool dp[1001][1001];
    string longestPalindrome(string s) {
        int size = s.size();
        string res = s.substr(0,1);
        dp[0][0] = true;
        // for(int i = 1; i < size; i++){
        //     dp[i][i] = true;
        //     dp[i-1][i] = (s[i-1] == s[i]);
        //     if(dp[i-1][i]) res = s.substr(i-1, 2);
        // }
        for(int len = 0; len < s.size(); len++){
            for(int start = 0; start < s.size() - len; start ++){
                int end = start + len;
                if(len == 0) dp[start][end] = 1;
                else if(len == 1) dp[start][end] = (s[start] == s[end]);
                else dp[start][end] = (dp[start+1][end-1] && (s[start] == s[end]));
                if(dp[start][end] && len + 1 > res.size())
                    res = s.substr(start, len + 1);
            }
        }
        return res;
    }
};

9. 516 最长回文子序列

https://leetcode-cn.com/problems/longest-palindromic-subsequence/

class Solution {
public:
    int dp[1000][1000];
    int longestPalindromeSubseq(string s) {
        int size = s.size();
        for(int i = size - 1; i >= 0; i--){
            dp[i][i] = 1;
            for(int j = i + 1; j < size; j++){
                if(s[i] == s[j]) dp[i][j] = dp[i+1][j-1] + 2;
                else dp[i][j] = max(dp[i+1][j], dp[i][j-1]);
            }
        }
        return dp[0][size-1];
    }
};

10. 1246 删除回文子数组

https://leetcode-cn.com/problems/palindrome-removal/

class Solution {
public:
    int dp[100][100];
    int minimumMoves(vector<int>& arr) {
        memset(dp, 0x3f3f3f3f, sizeof(dp));
        int size = arr.size();
        dp[0][0] = 1;
        for(int i = 1; i < size; i++){
            dp[i][i] = 1;
            dp[i-1][i] = (arr[i-1] == arr[i] ? 1 : 2);
        }
        
        // for(int len = 2; len < size; len++){
        //     for(int i = 0; i < size - len; i++){
        //         int j = i + len;
        //         for(int k = i; k < j; k++){
        //             dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j]);
        //         }
        //         if(arr[i] == arr[j]) dp[i][j] = min(dp[i][j], dp[i+1][j-1]);
        //     }
        // }

        for(int i = size - 2; i >= 0; i--){
            for(int j = i + 1; j < size; j++){
                for(int k = i; k < j; k++)
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j]);
                if(arr[i] == arr[j]) dp[i][j] = min(dp[i][j], dp[i+1][j-1]);
            }
        }
        return dp[0][size-1];
    }
};