[动态规划] 区间DP

已于 2022-07-20 11:23:28 修改
阅读量244 收藏
点赞数
分类专栏： 动态规划 文章标签： 动态规划 算法
于 2022-07-18 23:14:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Joker15517/article/details/125862382
版权

区间DP

石子合并问题

题目链接

https://www.acwing.com/problem/content/description/284/

状态表示和状态转移

f [ i ] [ j ] f[i][j] f[i][j] 表示合并区间 [ i , j ] [i, j] [i,j] 所有方案中花费代价的最小值
f [ i ] [ j ] = m i n { f [ i ] [ k ] + f [ k + 1 ] [ j ] + s [ j ] − s [ i − 1 ] } ( k = i , . . . , j − 1 ) f[i][j] = min\{f[i][k] + f[k+1][j] + s[j] - s[i-1]\} (k=i, ..., j-1) f[i][j]=min{f[i][k]+f[k+1][j]+s[j]−s[i−1]}(k=i,...,j−1)
a n s w e r = f [ 1 ] [ n ] answer = f[1][n] answer=f[1][n]

C++ 代码

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;
 

/*
    f[i][j] 表示合并区间 [i, j] 所有方案中花费代价的最小值
    f[i][j] = min{f[i][k] + f[k+1][j] + s[j] - s[i-1]} (k=i, ..., j-1)
    answer = f[1][n]
*/

const int N = 310;
int f[N][N];
int s[N];
int n;

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++) {
        scanf("%d", &s[i]);
        s[i] += s[i-1];
    }
    memset(f, 0x3f, sizeof f);
    for (int i = 0; i <= n; i ++) f[i][i] = 0;

    for (int len = 2; len <= n; len ++) {
        for (int i = 1; i + len - 1 <= n; i ++) {
            int j = i + len - 1;
            for (int k = i; k < j; k ++) {
                f[i][j] = min(f[i][j], f[i][k] + f[k+1][j] + s[j] - s[i - 1]);
            }
        }
    }
    printf("%d\n", f[1][n]);
    return 0;
}

环形石子合并

题目链接

https://www.acwing.com/problem/content/description/1070/

状态表示和状态转移

思路整体和上题类似
不同之处在于环形的处理上，采用复制法获得环形效果，减小时间复杂度

C++ 代码

#include <iostream>
#include <algorithm>
#include <cstring>
 
using namespace std;

const int N = 410, INF = 0x3f3f3f3f;
int s[N], a[N];
int f[N][N], g[N][N];
int n;

inline int read(){
    int num = 0;
    char c;
    bool flag = false;
    while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
    if (c == '-') flag = true;
    else num = c - '0';
    while (isdigit(c = getchar()))
    num = num * 10 + c - '0';
    return (flag ? -1 : 1) * num;
}

int main() {
    n = read();
    for (int i = 1; i <= n; i ++) {
        s[i+n] = s[i] = read();
    }
    memset(f, 0x3f, sizeof f);
    memset(g, -0x3f, sizeof g);
    for (int i = 1; i <= 2*n; i ++) s[i] += s[i-1];
    for (int i = 0; i <= 2*n; i ++) {
        f[i][i] = g[i][i] = 0;
    }
    for (int len = 2; len <= n; len ++) {
        for (int i = 1; i + len - 1 <= 2*n; i ++) {
            int j = i + len - 1;
            for (int k = i; k < j; k ++) {
                f[i][j] = min(f[i][j], f[i][k] + f[k+1][j] + s[j] - s[i-1]);
                g[i][j] = max(g[i][j], g[i][k] + g[k+1][j] + s[j] - s[i-1]);
            }
        }
    }
    int maxv = -INF, minv = INF;
    for (int i = 1; i <= n; i ++) {
        maxv = max(maxv, g[i][i+n-1]);
        minv = min(minv, f[i][i+n-1]);
    }
    printf("%d\n%d\n", minv, maxv);
    return 0;
}

凸多边形的划分

题目链接

https://www.acwing.com/problem/content/1071/

状态表示和状态转移

f[i][j] = min{f[i][k] + f[k][j] + a[i] * a[k] * a[j]} (k = i+1, ..., j-1)
answer = f[1][n]

在这里插入图片描述

C++ 代码

#include <iostream>
#include <algorithm>
#include <cstring>
 
using namespace std;
typedef long long ll;
const int N = 55, M = 40, INF = 0x3f3f3f3f;
int n, a[N];
int f[N][N][M];
inline int read(){
    int num = 0;
    char c;
    bool flag = false;
    while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
    if (c == '-') flag = true;
    else num = c - '0';
    while (isdigit(c = getchar()))
    num = num * 10 + c - '0';
    return (flag ? -1 : 1) * num;
}

void add(int a[], int b[]) {
    static int res[M];
    memset(res, 0, sizeof res);
    int t = 0;
    for (int i = 0; i < M; i ++) {
        t += a[i] + b[i];
        res[i] = t % 10;
        t /= 10;
    }
    memcpy(a, res, sizeof res);
}

void mul(int a[], int b) {
    static int res[M];
    memset(res, 0, sizeof res);
    ll t = 0;
    for (int i = 0; i < M; i ++) {
        t += (ll)a[i] * b;
        res[i] = t % 10;
        t /= 10;
        // cout << t << endl;
    }
    // for (int i = 0; i < M; i ++) cout << res[i];
    // cout << endl;
    memcpy(a, res, sizeof res);
    // puts("");
}

int cmp(int a[], int b[]) {
    for (int i = M-1; i >= 0; i --) {
        if (a[i] > b[i]) return 1;
        else if (a[i] < b[i]) return -1;
    }
    return 0;
}

void print(int a[]) {
    int k = M-1;
    while(k && !a[k]) k --;
    while(k >= 0) printf("%d", a[k--]);
    puts("");
}


int main(int argc, char const *argv[])
{
    n = read();
    for (int i = 1; i <= n; i ++) a[i] = read();
    int tmp[M];
    for (int len = 3; len <= n; len ++) {
        for (int i = 1; i + len - 1 <= n; i ++) {
            int j = i + len - 1;
            f[i][j][M-1] = 1;

            for (int k = i+1; k < j; k ++) {
                memset(tmp, 0, sizeof tmp);
                tmp[0] = 1;
                mul(tmp, a[i]);
                mul(tmp, a[k]);
               
                mul(tmp, a[j]);
           
                add(tmp, f[i][k]);

                add(tmp, f[k][j]);
 
                if (cmp(f[i][j], tmp) > 0) memcpy(f[i][j], tmp, sizeof tmp);
            }
        }
    }
    print(f[1][n]);
    return 0;
}

注意点

在计算高精度函数内，需要执行memcpy进行数组拷贝操作，第三个参数设置时需要注意
不能是 sizeof a, 应该是sizeof res
因为 a 作为参数是指针类型，大小为8个字节，在拷贝时，只会拷贝前两个数

加分二叉树

题目链接

https://www.acwing.com/problem/content/481/

思路

对区间[l, r]按照根的位置进行划分

得到状态转移方程如下:
f[l][r] = max{f[l][k-1] * f[k+1][r] + a[k]} (k = l, l+1, ..., r)
端点处需特殊处理

C++代码

#include <iostream>
#include <algorithm>
#include <cstring>
 
using namespace std;

const int N = 40;

int f[N][N], g[N][N]; //g[i][j] 记录区间[i, j]中的根结点
inline int read(){
    int num = 0;
    char c;
    bool flag = false;
    while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
    if (c == '-') flag = true;
    else num = c - '0';
    while (isdigit(c = getchar()))
    num = num * 10 + c - '0';
    return (flag ? -1 : 1) * num;
}
int n, a[N];

void dfs(int l, int r) {
    if (l > r) return;
    int root = g[l][r];
    printf("%d ", root);
    dfs(l, root-1);
    dfs(root+1, r);
}

int main()
{
    n = read();
    for (int i = 1; i <= n; i ++) f[i][i] = a[i] = read(), g[i][i] = i;

    for (int len = 2; len <= n; len ++) {
        for (int i = 1; i + len - 1 <= n; i ++) {
            int j = i + len - 1;
            for (int k = i; k <= j; k ++) {
                int left = i == k ? 1 : f[i][k-1];
                int right = j == k ? 1 : f[k+1][j];
                if (f[i][j] < left * right + a[k]) {
                    f[i][j] = left * right + a[k];
                    g[i][j] = k;
                }
            }
        }
    }
    printf("%d\n", f[1][n]);
    dfs(1, n);
    return 0;
}

棋盘分割

题目链接

https://www.acwing.com/problem/content/description/323/

思路

题意+分析

将棋盘切 n − 1 n-1 n−1 刀，得到 n n n 块小区域，使得 n n n 块区域权重之和的均方差最小，由于n固定，均方差和方差的单调性相同，在分析时只考虑方差能简化运算，最后求和之后再算均值开方即得到答案

切分之后，左右或上下两部分是独立的，可以分别考虑。另外注意，切分后保留的一部分继续切分，而舍弃的一部分直接计算

分割方案

在这里插入图片描述

状态表示

f[k][x1][y1][x2][y2] 表示进行第k-1次划分时, 选择对角坐标为[(x1, y1), (x2, y2)]的矩形的各部分与均值差值的平方之和最小值

状态计算

对于每一层状态，考虑上述四种分割分割方案，保留差值平方之和最小值

C++ 代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>

using namespace std;

const int N = 16;

double f[N][N][N][N][N];
int s[N][N];
int n, m = 8;
double X;

inline int read(){
    int num = 0;
    char c;
    bool flag = false;
    while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
    if (c == '-') flag = true;
    else num = c - '0';
    while (isdigit(c = getchar()))
    num = num * 10 + c - '0';
    return (flag ? -1 : 1) * num;
}

double get(int x1, int y1, int x2, int y2) {
    double x = s[x2][y2] - s[x1-1][y2] - s[x2][y1-1] + s[x1-1][y1-1] - X;
    return x * x;
}

double dp(int k, int x1, int y1, int x2, int y2) { // 求 (xi - X)^2
    double &v = f[k][x1][y1][x2][y2];
    if (v >= 0) return v;
    if (k == n) return v = get(x1, y1, x2, y2);
    double t = 1e9;
    for (int i = y1; i < y2; i ++) {
        t = min(t, dp(k+1, x1, y1, x2, i) + get(x1, i+1, x2, y2));
        t = min(t, dp(k+1, x1, i+1, x2, y2) + get(x1, y1, x2, i));
    }

    for (int i = x1; i < x2; i ++) {
        t = min(t, dp(k+1, x1, y1, i, y2) + get(i+1, y1, x2, y2));
        t = min(t, dp(k+1, i+1, y1, x2, y2) + get(x1, y1, i, y2));
    }
    return v = t;
}

int main() {
    memset(f, -1, sizeof f);
    n = read();
    for (int i = 1; i <= m; i ++) {
        for (int j = 1; j <= m; j ++) {
            s[i][j] = read() + s[i-1][j] + s[i][j-1] - s[i-1][j-1];
        }
    }
    X = (double)s[m][m] / n; 
    printf("%.3lf\n", sqrt(dp(1, 1, 1, m, m) / n));
    return 0;
}

注意点

double memset 为-1代表负无穷
青铜世纪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划动态规划.zip
10-25
一、动规分类 1.线性模型 2.区间模型 3.背包模型 4.树形DP 5.数位DP 6.状态压缩DP 7.概率DP 8.图上动规 9.数据结构上动规 8.插头DP(6的一种) 9.记忆化搜索(优化)
动态规划之区间DP详解
晨的博客
09-08 1067
区间DP
动态规划区间DP
2302_79519348的博客
04-01 787
动态规划区间DP包含普通区间dp，环形dp
动态规划入门（九） 区间DP
热门推荐
Hello World!
05-03 5万+
顾名思义，区间dp就是在区间上进行动态规划，求解一段区间上的最优解；该问题的求解思路主要是通过合并小区间的最优解进而得出整个大区间上最优解的dp算法。
动态规划--区间DP
一只IT小小鸟
03-25 584
动态规划--区间DP所谓区间dp，顾名思义就是在一段区间上的动态规划。它既要满足dp问题的最优子结构和无后效性外，还应该符合在区间上操作的特点。我的理解是往往会对区间进行合并操作。亦或是单个元素（可看成一个小区间）跨区间进行操作。例如括号匹配问题，石子合并问题（通过多次的相邻合并，最后实质上会产生跨区间的合并，如果你把其中的石子看作参考系的话就很容易感觉出来），还有在整数中插入运算符号的问题（利用...
动态规划——区间dp [石子合并]
小天狼星_布莱克 的博客
07-06 2231
动态规划（dp）是一种通过将问题分解为子问题，并利用已解决的子问题的解来求解原问题的方法。适用于具有重叠子问题和最优子结构性质的优化问题。通过定义状态和状态转移方程，动态规划可以在避免重复计算的同时找到问题的最优解，是一种高效的求解方法，常用于解决各种问题，如最短路径、背包问题、序列比对等。区间dp是一种dp的应用，用于解决涉及区间的问题。它将问题划分为若干个子区间，并通过定义状态和状态转移方程来求解每个子区间的最优解，最终得到整个区间的最优解。
区间类型动态规划
08-18
区间类型动态规划 -长沙雅礼中学著名教练 朱全民
NOI/NOIP中的DP（动态规划）类型
11-14
这类题是属于徘徊在DP与递归之间得一类题，本质是类似于记忆化搜索的一种填表，有很强的数学味。 7、线段覆盖问题 改版：Tom的烦恼（TOJ）等。经常利用到离散化等技巧辅助。 8、 ……………… ………………
richenyunqi#code-templates#区间动态规划1
07-25
边界条件：$dp[i][i]=0$算法的时间复杂度为$O(n^3)$C++代码：++len) { //枚举区间长度++left) { //枚举左端点//右端点。
【算法】二分算法——x的平方根
2302_79031646的博客
05-17 789
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
未来就在脚下。
05-20 496
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
力扣62 不同路径 Java版本
m0_47066863的博客
05-20 186
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。从左上角开始，总共有 3 条路径可以到达右下角。题目数据保证答案小于等于 2 * 109。输入：m = 3, n = 7。输入：m = 3, n = 2。输入：m = 7, n = 3。输入：m = 3, n = 3。问总共有多少条不同的路径？
【二叉树算法题记录】从中序与后序遍历序列构造二叉树，从前序与中序遍历序列构造二叉树
weixin_43627638的博客
05-15 379
这样我们就能确定整棵树的根节点在。
技艺高超的魔法师：Java运算符
epitomizelu的专栏
05-14 791
Java运算符是构建复杂程序的基础，掌握它们的使用和优先级对于写出高效、清晰的代码至关重要。通过本文的介绍和实例，希望能帮助读者更好地理解和运用这些运算符，让代码表达更加精准和高效。记住，实践是学习的最好方式，不断编写代码并探索不同的场景，你会越来越熟练地掌握它们。
力扣：209. 长度最小的子数组
icbbm的博客
05-17 388
如果不存在符合条件的子数组，返回。是该条件下的长度最小的子数组。找出该数组中满足其总和大于等于。个正整数的数组和一个正整数。
用c语言实现简易三子棋
最新发布
m0_62646213的博客
05-21 161
用C语言实现简易三子棋，初学者也可以看懂
22. 括号生成
编程SHARE的博客
05-20 214
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
leetCode-hot100-位运算专题
m0_49074706的博客
05-13 634
位运算专题-LeetCode-hot100
python动态规划最大区间和
11-30
以下是使用动态规划实现Python最大区间和的方法： ```python def maxSubArray(nums): """ :type nums: List[int] :rtype: int """ if not nums: return 0 n = len(nums) dp = [0] * n dp[0] = nums[0] for i in range(1, n): dp[i] = max(dp[i - 1] + nums[i], nums[i]) return max(dp) ``` 以上代码中，我们使用了动态规划的思想，通过dp数组来记录当前位置的最大子序和。具体实现中，我们遍历整个数组，对于每个位置，我们都计算出以该位置为结尾的最大子序和，并将其存储在dp数组中。最后，我们返回dp数组中的最大值即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值