区间&环形动态规划

最新推荐文章于 2024-02-09 22:18:14 发布
最新推荐文章于 2024-02-09 22:18:14 发布
阅读量510 收藏 3
点赞数 1
分类专栏： # 动态规划 文章标签： 动态规划 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiahonghao2002/article/details/113882857
版权

区间&环形动态规划

区间动态规划

主要思路：定义数组 d p [ i ] [ j ] dp[i][j] dp[i][j]为子区间 [ i , j ] [i,j] [i,j]的最优解，然后建立动态规划方程，枚举的变量一般为距离，也就是 j − i + 1 j-i+1 j−i+1。

区间DP根据不同的类型也分不同的种类。

区间分段点DP

此类区间DP在状态转移的时候需要枚举子区间的分段点，把子区间分成两个部分合并求解。

例题：P1880 石子合并

#include <bits/stdc++.h>

#define FR freopen("in.txt","r",stdin);

using namespace std;

typedef long long ll;

int raw[250];

ll dp[250][250];
ll dp1[250][250];
ll psum[250];
int main()
{
    int n;
    cin >> n;

    for(int i = 1; i<=n; i++)
    {
        cin >> raw[i];
        psum[i] = raw[i] + psum[i-1];
    }
    // copy
    for(int i = 1; i<=n; i++)
    {
        raw[i + n] = raw[i];
        psum[i + n] = raw[i] + psum[i + n-1];
    }


    // dp

    for(int len = 2; len <= n; len++)
        for(int s = 1; s+len-1 <= 2 * n; s++)
        {
            dp1[s][s+len-1] = LONG_LONG_MAX;
            for(int k = s; k<s+len-1; k++)
            {
                dp[s][s+len-1] = max(dp[s][s+len-1],dp[s][k] + dp[k+1][s+len-1] + psum[s+len-1] - psum[s-1]);
                dp1[s][s+len-1] = min(dp1[s][s+len-1],dp1[s][k] + dp1[k+1][s+len-1] + psum[s+len-1] - psum[s-1]);
            }
        }
    ll ans1 = 0,ans2 = LONG_LONG_MAX;
    for(int i = 1; i+n-1<=2 * n; i++)
    {
        ans1 = max(ans1,dp[i][i+n-1]);
        ans2 = min(ans2,dp1[i][i+n-1]);
    }
    cout << ans2 << endl << ans1;
    return 0;
}

P1220

关路灯，经典的区间分段点DP问题。即枚举掉头的位置即可。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define FR freopen("in.txt", "r", stdin)
#define FW freopen("out.txt", "w", stdout)

ll pos[55];
ll wi[55];

ll dp[55][55];

ll ti[55][55];

int main()
{
    int n, c;
    scanf("%d %d", &n, &c);

    for (int i = 1; i <= n; i++)
    {
        scanf("%lld %lld", pos + i, wi + i);
    }

    for (int i = 0; i < 55; i++)
        for (int j = 0; j < 55; j++)
            dp[i][j] = INT_MAX;

    for (int i = 0; i < 55; i++)
    {
        dp[i][i] = 0;
    }
    ll pp = 0;
    ll sum = 0;
    dp[c][c] = 0;
    ti[c][c] = 0;
    for (int i = c + 1; i <= n; i++)
    {
        pp += pos[i] - pos[i - 1];
        sum += pp * wi[i];
        dp[c][i] = sum;
        ti[c][i] = 2 * pp;
    }
    if (c != 1)
        for (int len = 2; len <= n; len++)
        {
            int st = 0;

            if (len + c - 2 <= n)
            {
                st = c - 1;
            }
            else
            {
                st = n - len + 1;
            }

            for (int ed = st + len - 1; ed >= c && st >= 1; st--, ed--)
            {
                for (int r = c; r <= ed; r++)
                {
                    ll tim = 0;
                    ll cost = 0;
                    tim = ti[st + 1][r] + pos[st + 1] - pos[st];
                    cost = dp[st + 1][r] + tim * wi[st];
                    if (r != ed)
                    {
                        tim += pos[r] - pos[st];
                        for (int j = r + 1; j <= ed; j++)
                        {
                            tim += pos[j] - pos[j - 1];
                            cost += tim * wi[j];
                        }
                        tim += pos[ed] - pos[st];
                    }

                    if (cost < dp[st][ed])
                    {
                        dp[st][ed] = cost;
                        ti[st][ed] = tim;
                    }
                }
            }
        }

    printf("%lld", dp[1][n]);

    return 0;
}

回文消除：有点思维的区间分段点DP

CF607B

我们考虑 d p [ i ] [ j ] dp[i][j] dp[i][j]为区间 [ i , j ] [i,j] [i,j]的最小花费，若 a [ i ] = a [ j ] a[i]=a[j] a[i]=a[j]那么两端的一定可以在中间消除到最后一步的时候顺带消除，但这并不一定是最优的，还需继续考虑下面的情况。一般情况（包括 a [ i ] = a [ j ] a[i]=a[j] a[i]=a[j]），那么我们考虑将两端由谁和谁组合消除，那么我们枚举分段点即可。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define FR freopen("in.txt", "r", stdin)
#define FW freopen("out1.txt", "w", stdout)

int arr[505];

int dp[505][505];

int main()
{
    int n;
    scanf("%d", &n);

    for (int i = 1; i <= n; i++)
    {
        scanf("%d", arr + i);
    }

    for (int i = 0; i < 505; i++)
    {
        for (int j = 0; j < 505; j++)
        {
            dp[i][j] = 1000000000;
        }
    }

    for (int i = 1; i <= n; i++)
    {
        dp[i][i] = 1;
    }

    for (int i = 1; i < n; i++)
    {
        if (arr[i] == arr[i + 1])
        {
            dp[i][i + 1] = 1;
        }
        else
        {
            dp[i][i + 1] = 2;
        }
    }

    for (int l = 3; l <= n; l++)
    {
        for (int st = 1; st + l - 1 <= n; st++)
        {
            int ed = st + l - 1;
            if (arr[st] == arr[ed])
            {
                dp[st][ed] = dp[st + 1][ed - 1];
            }
            for (int k = st; k < ed; k++)
            {
                dp[st][ed] = min(dp[st][ed], dp[st][k] + dp[k + 1][ed]);
            }
        }
    }

    printf("%d", dp[1][n]);
    return 0;
}

涂色、打印机：

LeetCode 664

P4170

如果左端点和右端点相同，那么左端点可以被涂右端点的时候带过，或者右端点可以被涂左端点的时候带过，如果不相同，那么就枚举分段点。

class Solution
{
public:
    int dp[105][105];
    int strangePrinter(string s)
    {
        for (int i = 0; i < 105; i++)
        {
            for (int j = 0; j < 105; j++)
            {
                dp[i][j] = 1000000000;
            }
        }

        for (int i = 0; i < 105; i++)
        {
            dp[i][i] = 1;
        }
        for (int l = 2; l <= s.size(); l++)
        {
            for (int st = 0; st + l - 1 < s.size(); st++)
            {
                int ed = st + l - 1;
                if (s[st] == s[ed])
                {
                    dp[st][ed] = min(dp[st][ed], min(dp[st][ed - 1], dp[st + 1][ed]));
                }
                for (int k = st; k < ed; k++)
                {
                    dp[st][ed] = min(dp[st][ed], dp[st][k] + dp[k + 1][ed]);
                }
            }
        }
        return dp[0][s.size() - 1];
    }
};

LeetCode 375

用区间DP构造最优的二叉树。

class Solution
{
public:
    int getMoneyAmount(int n)
    {
        vector<vector<int>> dp(205, vector<int>(205));
        for (int len = 2; len <= n; len++)
        {
            for (int st = 1; st + len - 1 <= n; st++)
            {
                int ed = st + len - 1;
                dp[st][ed] = 100000000;
                for (int k = st; k <= ed; k++)
                {
                    dp[st][ed] = min(dp[st][ed], max(dp[st][k - 1], dp[k + 1][ed]) + k);
                }
            }
        }
        return dp[1][n];
    }
};

区间掐头尾DP

有一类区间DP的状态为 d p [ l ] [ r ] [ 0 / 1 ] dp[l][r][0/1] dp[l][r][0/1]，其中最后一维状态与区间的首尾有关系，此类区间DP叫做区间掐头尾DP。

P3205

我们发现，给定一个期望序列，能做尾元素的只有当前的尾元素和头元素。因此定义 d p [ l ] [ r ] [ 0 / 1 ] dp[l][r][0/1] dp[l][r][0/1]为当头/尾元素做尾元素的时候的方案数。

那么状态转移方程如下：

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define FR freopen("in.txt", "r", stdin)
#define FW freopen("out1.txt", "w", stdout)

int arr[1005];

ll dp[1005][1005][2];

#define MOD 19650827

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", arr + i);
    }

    if (n == 1)
    {
        printf("1");
        return 0;
    }

    for (int i = 1; i < n; i++)
    {
        if (arr[i] < arr[i + 1])
        {
            dp[i][i + 1][0] = dp[i][i + 1][1] = 1;
        }
    }

    for (int len = 3; len <= n; len++)
        for (int st = 1; st + len - 1 <= n; st++)
        {
            int ed = st + len - 1;

            if (arr[ed] > arr[ed - 1])
            {
                dp[st][ed][1] = (dp[st][ed][1] + dp[st][ed - 1][1]) % MOD;
            }

            if (arr[ed] > arr[st])
            {
                dp[st][ed][1] = (dp[st][ed][1] + dp[st][ed - 1][0]) % MOD;
            }

            if (arr[st] < arr[ed])
            {
                dp[st][ed][0] = (dp[st][ed][0] + dp[st + 1][ed][1]) % MOD;
            }

            if (arr[st] < arr[st + 1])
            {
                dp[st][ed][0] = (dp[st][ed][0] + dp[st + 1][ed][0]) % MOD;
            }
        }

    printf("%lld", (dp[1][n][0] + dp[1][n][1]) % MOD);
    return 0;
}

由此可AC该题。

当时我读错了题意，以为比较大小和当前正在排序的队列的尾元素比较大小，得到了以下AC代码，变成了经典的区间割点DP，一道题双倍经验。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define FR freopen("in.txt", "r", stdin)
#define FW freopen("out1.txt", "w", stdout)

int arr[1005];

ll dp[1005][1005];
bool mono[1005][1005];

#define MOD 19650827

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", arr + i);
    }

    for (int i = 1; i <= n; i++)
    {
        dp[i][i] = 1;
        mono[i][i] = true;
    }

    for (int len = 2; len <= n; len++)
        for (int st = 1; st + len - 1 <= n; st++)
        {
            int ed = st + len - 1;
            mono[st][ed] = mono[st][ed - 1] && arr[ed] > arr[ed - 1];
            if (mono[st][ed])
            {
                dp[st][ed] = (dp[st][ed] + 1) % MOD;
            }

            for (int k = st + 1; k <= ed; k++)
            {
                if (arr[st] < arr[k] && mono[k][ed])
                {
                    dp[st][ed] = (dp[st][ed] + dp[st + 1][k]) % MOD;
                }
            }
        }

    printf("%lld", dp[1][n]);
    return 0;
}

环形动态规划

主要思路：定义数组 d p [ i ] [ j ] dp[i][j] dp[i][j]为子区间 [ i , j ] [i,j] [i,j]的最优解，然后建立动态规划方程，枚举的变量一般为距离，也就是 j − i + 1 j-i+1 j−i+1。与区间动态规划不同的是，通常将一个环剪开变成一个区间，然后重复这个区间两次，解决这个大区间上的问题，可以避免环的接头处理。

即一个有 n n n个元素的环，可以等价于 2 n 2n 2n个区间处理，即可转换为区间DP问题。

例题：P1880 石子合并

爱寂寞的时光
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划的一些简单问题课件
11-02
动态规划初步，包括引入，01背包，分组背包，完全背包，线性dp，树形dp，区间dp，环形dp
【动态规划】 石子合并问题（环形） （ssl 1597)
ssllyf的博客
12-22 1808
石子合并问题石子合并问题石子合并问题 Description 在一个圆形操场的四周摆放着n 堆石子。现要将石子有次序地合并成一堆。规定每次只能选相邻的2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。 编程任务： 对于给定n堆石子,编程计算合并成一堆的最小得分和最大得分。 Input 输入包括多组测试数据，每组测试数据包...
【动态规划】环形处理 环形动态规划
最新发布
2302_80811345的博客
02-09 371
破n环为2*n链，答案在每个长度为n的区间选择出最值。
动态规划——环形数组的连续子数组最大和
memory_MM_forever的博客
04-18 630
题目 题解 求最大和可以反过来先求最小和，最大和跟最小和的数组必定首尾相连，中间不可能有空位，分成两个数组，如果最小和是从尾部跳到首部，那最大和就在数组中间，就是正常的dpmax，如果最大和是从尾部跳到首部，那最小和就在数组中间，就是正常的dpmin，sum-dpmin就是最大和；特殊情况，如果dpmin=sum就代表全是负数，也是正常的dpmax； n = int(input()) a = list(map(int,input().split())) dpmax = [0] * n dpmax[0] =
区间（环形）dp总结篇【施工中】
weixin_62528401的博客
08-15 156
区间dp总结
特殊类型动归--区间动归与环形动归
信息学奥赛学案
07-01 289
区间DP与环形DP
Leetcode题解-算法-动态规划（python版）
桑凯旋的博客
05-07 1250
1、最长回文子序列 确定状态 dp[i][j]：以下标 i 为起始点，下标 j 为结束点的子串的最长回文子序列长度。 状态转移方程 当 s[i] == s[j] 时，dp[i][j] = dp[i+1][j-1] + 2 当 s[i] != s[j] 时，dp[i][j] = max(dp[i+1, j], dp[i, j-1]) 算法流程 初始 dp[][] = 0 dp[i][i] = 1 返回：return dp[0][n-1] 从最后一行开始计算，每行从左向右计算 516. 最长
动态规划之环形处理
qq_42376883的博客
06-17 550
在许多环形结构的问题中，我们都能通过枚举法，选择一个位置把环断开，变成线性结构从而进行求解，但是往往这种枚举的方式时间复杂度比较大，所以在动态规划问题中往往用二次DP法，断环为链法来避免枚举...
环形结构上的动态规划问题的基本处理方式
hnjzsyjyj的专栏
09-02 1075
环形结构上的动态规划问题，是一种特殊的区间动态规划问题。由于存在“环形后效性”，所以不满足动态规划算法的“无后效性”约束条件。故常将环形结构上的动态规划问题，通过“断环为链”策略转化为线性动态规划问题求解。所谓“无后效性”，即“未来与过去无关”。所谓“断环为链”策略，即“把环断开为链，然后复制一倍接在末尾”。示意图如下： ...
Leetcode918.环形子数组的最大和
人生就是一场修行
08-18 262
Leetcode918.环形子数组的最大和 给定一个由整数数组 A 表示的环形数组 C，求 C 的非空子数组的最大可能和。 在此处，环形数组意味着数组的末端将会与开头相连呈环状。（形式上，当0 <= i < A.length 时 C[i] = A[i]，且当 i >= 0 时 C[i+A.length] = C[i]） 此外，子数组最多只能包含固定缓冲区 A 中的每个元素一次。（形式上，对于子数组 C
[Java解法]洛谷-P1063能量项链-环形动态规划讲解
Headphone_Sang的博客
06-30 201
Java代码讲解洛谷P1063能量项链,环形动态规划-区间动态规划
行业文档-设计装置-环形车站与区间教学模型.zip
09-11
行业文档-设计装置-环形车站与区间教学模型
Axure制作驾驶舱原型时，方便实用的统计图表元件 内容包括：饼状图、柱状图、折线图、环形图，区间图，甘特图，面积图，色块图，玫
07-28
Axure制作驾驶舱原型时，方便实用的统计图表...内容包括：饼状图、柱状图、折线图、环形图，区间图，甘特图，面积图，色块图，玫瑰图，仪表盘，水波图，雷达图，漏斗图，k线图，散点图，气泡图，双轴图等，非常实用。
掺Yb3 +环形光纤激光器的双波长可调谐特性 (2012年)
06-11
通过构建基于非线性偏振旋转机理的掺Yb3 +环形光纤激光器,获得了等幅和非等幅两种双波长输出状态,分别测量其输出功率.结果表明,由于不同波段激光增益的差别较大,因此不同波长的转换效率相差较大.分析了双波长输出的...
环形套管内非牛顿流体非定常旋转流动谱方法研究 (2009年)
06-05
采用在区间[1，m]上的Chebbyshev多项式为基底的谱方法，研究了环形套管内上随体Maxwen非牛顿流体由一类定常流动状态向另一类定常流动状态的非定常旋转流动的速度场分布，把该问题的高阶偏微分方程的边、初值问题降阶...
字符串字典序
jiahonghao2002的博客
10-31 2236
字符串字典序 设字母集为∑\sum∑（通常为小写字母），∑∗\sum^*∑∗ 为表示包含所有有限长度的字符串的集合，该字符串是由字母表∑\sum∑中字符组成的，而字典序是定义在∑∗\sum^*∑∗上的一个偏序关系。 设两个字符串为aaa与bbb，则两个字符串的大小关系为： 令i=1i=1i=1。 若i≤min⁡{∣a∣,∣b∣}i \leq \min\{|a|,|b|\}i≤min{∣a∣,∣b∣}比较a[i]a[i]a[i]和b[i]b[i]b[i]之间的关系，若a[i]<b[i]a[i] &lt
数位DP
jiahonghao2002的博客
04-06 525
数位DP 数位DP通常适用于以下问题： 给定一个区间[l,r][l,r][l,r]，给定一个条件函数C(n)C(n)C(n)，若数nnn满足条件CCC，则C(n)C(n)C(n)的值为111，否则为000。求在这个区间满足条件CCC的数的个数有几个？ 数位DP，顾名思义，就是在数的个位，十分位，百分位，……上做DP。 我们定义： dp(pos,pre,limit)dp(pos,pre,limit)dp(pos,pre,limit)表示从低位开始算起，计算第pospospos位的值符合条件的数的数量。 其
动态规划——不重复子序列DP法
jiahonghao2002的博客
08-14 423
动态规划——不重复子序列DP法 考虑一个基本模型： 给定一个字符串SSS，请问SSS中有多少个不重复的子序列。这里的子序列指，删掉SSS中某些字符，剩下的字符按照原有的顺序拼成的字符串。 容易想到一个基本的DP解法： 设dpidp_idpi​为以SiS_iSi​结尾（必选）的S[1,i]S[1,i]S[1,i]中的子序列的数量。特别的，设dp0=0dp_0=0dp0​=0，对应一个空字符串。那么有如下转移方程： dpi=∑j=0i−1dpj dp_i = \sum_{j = 0}^{i-1}dp_j d
环形石子合并问题动态规划思路
01-05
环形石子合并问题可以使用动态规划来解决。下面是解决该问题的动态规划思路： 1. 定义状态：设dp[i][j]表示合并第i堆到第j堆石子所能得到的最小得分和最大得分。 2. 状态转移方程：对于dp[i][j]，可以考虑最后一次...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值