leetcode——区间类DP

最新推荐文章于 2022-06-05 16:05:32 发布

原创最新推荐文章于 2022-06-05 16:05:32 发布 · 699 阅读

1 ·

CC 4.0 BY-SA版权

基础算法专栏收录该内容

28 篇文章

订阅专栏

本文深入探讨了多种经典动态规划算法的应用与实现，包括最长回文子序列、最长回文串、回文子串等，并提供了详细的代码示例。同时，文章还介绍了预测赢家、扰乱字符串、戳气球等问题的解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

最长回文子序列

$\begin{cases} dp[i+1][j-1]+2,\ S[i]==S[j]\\ \ max\{dp[i+1][j],dp[i,j-1]\},\ S[i]!=S[j]\\ \end{cases}$
边界
$d p [i] [i] = 1$ 在这里插入图片描述

public int LongestPalindromeSubseq(string s) {
    var len = s.Length;
    var dp = new int[len, len];
    for(var i=len-1;i>=0;i--){
        dp[i,i] = 1;
        for(var j=i+1;j<len;j++){
            if(s[i]==s[j]){
                dp[i,j] = dp[i+1,j-1] + 2;
            }
            else{
                dp[i,j] = Math.Max(dp[i+1,j], dp[i,j-1]);
            }
        }
    }
    return dp[0,len-1];
}

最长回文串

这道题是顺道写上的，这题是让从给定s中构造一个回文串，顺序不规定，相当于给提供了一些char，构造一个回文串，返回能构造出来的最长的回文串的长度。

public int LongestPalindrome(string s) {
    if(string.IsNullOrEmpty(s)){
        return 0;
    }
    var chars = new int[128];
    foreach(var c in s){
        chars[c]++;
    }
    var ans = 0;
    foreach(var c in chars){
        ans += c/2 * 2;
        if(c%2==1 && ans%2==0){
            ans++;
        }
    }
    return ans;
}

最长回文子串

public string LongestPalindrome(string s) {
    if(string.IsNullOrEmpty(s)) return s;
    var max = 0;
    var start = 0;
    var end = 0;
    var dp = new bool[s.Length,s.Length];
    for(var i = s.Length-1;i>=0;i--){
        for(var j=i;j<s.Length;j++){
            if(j==i) dp[i,j] = true;
            else if(j==i+1) dp[i,j] = s[i]==s[j];
            else{
                if(s[i]==s[j]){
                    dp[i,j] = dp[i+1,j-1];
                }
                else{
                    dp[i,j] = false;
                }
            }
            if(dp[i,j]&&j-i+1>max){
                max = j-i+1;
                start = i;
                end = j;
            }
        }
    }
    
    return s.Substring(start,end-start+1);
}

回文子串

上一题翻版

public int CountSubstrings(string s) {
    if(string.IsNullOrEmpty(s)) return 0;
    var count = 0;
    var dp = new bool[s.Length,s.Length];
    for(var i = s.Length-1;i>=0;i--){
        for(var j=i;j<s.Length;j++){
            if(j==i) dp[i,j] = true;
            else if(j==i+1) dp[i,j] = s[i]==s[j];
            else{
                if(s[i]==s[j]){
                    dp[i,j] = dp[i+1,j-1];
                }
                else{
                    dp[i,j] = false;
                }
            }
            if(dp[i,j]){
                count++;
            }
        }
    }

    return count;
}

预测赢家

在这个里面：博弈DP系列

扰乱字符串

题解区一个大神的解法：https://leetcode-cn.com/problems/scramble-string/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-1-2/

public bool IsScramble(string s1, string s2) {
    if (s1.Length != s2.Length) {
        return false;
    }
    if (s1.Equals(s2)) {
        return true;
    }

    int[] letters = new int[26];
    for (int i = 0; i < s1.Length; i++) {
        letters[s1[i] - 'a']++;
        letters[s2[i] - 'a']--;
    }
    for (int i = 0; i < 26; i++) {
        if (letters[i] != 0) {
            return false;
        }
    }

    int length = s1.Length;
    bool[,,] dp = new bool[length + 1,length,length];
    //遍历所有的字符串长度
    for (int len = 1; len <= length; len++) {
        //S1 开始的地方
        for (int i = 0; i + len <= length; i++) {
            //S2 开始的地方
            for (int j = 0; j + len <= length; j++) {
                //长度是 1 无需切割
                if (len == 1) {
                    dp[len,i,j] = s1[i] == s2[j];
                } else {
                    //遍历切割后的左半部分长度
                    for (int q = 1; q < len; q++) {
                        dp[len,i,j] = dp[q,i,j] && dp[len - q,i + q,j + q]
                            || dp[q,i,j + len - q] && dp[len - q,i + q,j];
                        //如果当前是 true 就 break，防止被覆盖为 false
                        if (dp[len,i,j]) {
                            break;
                        }
                    }
                }
            }
        }
    }
    return dp[length,0,0];
}

戳气球

有 n 个气球，编号为0 到 n-1，每个气球上都标有一个数字，这些数字存在数组 nums 中。

现在要求你戳破所有的气球。每当你戳破一个气球 i 时，你可以获得 nums[left] * nums[i] * nums[right] 个硬币。这里的 left 和 right 代表和 i 相邻的两个气球的序号。注意当你戳破了气球 i 后，气球 left 和气球 right 就变成了相邻的气球。

求所能获得硬币的最大数量。

说明:

你可以假设 nums[-1] = nums[n] = 1，但注意它们不是真实存在的所以并不能被戳破。
0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100
示例:

输入: [3,1,5,8]
输出: 167
解释: nums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []
coins = 315 + 358 + 138 + 181 = 167

【思路】题目之所以说假设 nums[-1] = nums[n] = 1，是因为如果到了最后三个气球的时候，戳破中间那个，相邻两个存在的话才能算金币数，否则不存在题意就不成立，所以解题的时候需要根据题意构造一个n+2长度的数组a[]，而且后续都用这个新构造好的a[]，旧的就不用管了。所以dp[i,j]表示在区间[i+1,j-1]之间以某种方法戳破所有气球，i和j不能动，有点像矩阵链式相乘的划分，对于区间[i+1,j-1]内的某个k号气球，如果两边邻居就只剩下i和j了，则说明在这之前，[i+1,k-1]和[k+1,j-1]的气球已经全都被戳破了，所以戳破k号气球后，累计得到的金币数就是dp[i,k]+dp[k,j]+a[k]*a[i]*a[j]，从i+1开始到j-1遍历这个k，然后取最大的dp[i,j]。

public int MaxCoins(int[] nums) {
    var d=new int[nums.Length+2,nums.Length+2];
    var a=new int[nums.Length+2];
    for(int i=1;i<a.Length-1;i++){
        a[i]=nums[i-1];
    }
    a[0]=1;
    a[a.Length-1]=1;
    //以上对a的构造是结合题目意思，把nums[-1]=1和nums[n]=1体现出来
    for(int i=2;i<a.Length;i++){
        for(int j=0;j<a.Length-i;j++){
            for(int k=j+1;k<j+i;k++){
                d[j,j+i]=Math.Max(d[j,j+i],d[j,k]+d[k,j+i]+a[j]*a[k]*a[j+i]);
            }
        }
    }
    return d[0,a.Length-1];
}