区间DP | 2：环上的合并石子 —— 例题：合并石子（环形）

最新推荐文章于 2024-06-28 07:37:06 发布
最新推荐文章于 2024-06-28 07:37:06 发布
阅读量442 收藏 4
点赞数 1
分类专栏： # ④ 动态规划 文章标签： 动态规划 合并石子 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43787043/article/details/104994756
版权

本文是在区间DP | 1：矩阵链乘问题（含优化） —— 例题：矩阵链乘、合并石子 上的升级（建议先看链接文章）。从链到环的改变，但本质还是区间dp问题，将环的区间任然解析成链即可。

环上的合并石子问题：环形排列着N堆石子，现在要将石子合并成一堆。规定如下：每次只能将相邻的两堆石子合并，合并两堆石子所花费的时间为两堆石子的数量和。求将N堆石子合并成一堆最小花费的时间。（石子分为n堆，石子的数量存储在数组p[0..n-1]中）

若将此题的环一条条转成线来机械的运算：考虑为 n 个线型的合并石子，时间复杂度上必将增加一个幂次，不够划算，下面有更好的方法。（其实仔细想想，n次调用线型的合并石子的模型，其实存在大量重复计算）

本文目录

方法一：直接刚！将数组环形考虑 —— 时间复杂度O(n^3)

方法二：化圆为直 —— 时间复杂度O(n^3)

         方法三： 化圆为直优化版 —— 时间复杂度\bg_white O(n^2)

end 

方法一：直接刚！将数组环形考虑 —— 时间复杂度O(n^3)

既然是环形的，我们将数组环形地去考虑即可，只是因为各种临界问题，代码比较复杂，要注意细节~（实在是太琐碎了！写了两个小时才把bug清理完，流下了惨痛的泪水，所以后又改进了方法，详见方法二）

相较于原方法，核心部分是三层循环，但是由于环形的两端连接问题，第2、3层循环均需要改动：

  • 第一层循环：长度 l = 2..n
  • 第二层循环：讨论每个长度为 l 的石子堆 p_{i..j}：i = 1..n， j = ( i + l + 1 ) % n（此循环体内计算sum也是复杂了些，建议单独写出一个calcSum函数计算）
  • 第三层循环：确定最优分割点 k = i..j-1

两种方法对应的ans数组的填充也是不同的： 

代码实现：

注意临界问题！注意琐碎的临界问题！十分注意琐碎的临界问题！！！

#define N 100

#include <cstdio>
#include <algorithm>
#include <climits>
using namespace std;

/* 合并石子问题：环形排列着N堆石子，现在要将石子合并成一堆。
 * 规定如下：每次只能将相邻的两堆石子合并，合并两堆石子所花费的时间为两堆石子的数量和。
 * 求将N堆石子合并成一堆最小花费的时间。（石子分为n堆，石子的数量存储在数组p[0..n-1]中）*/

int ans[N][N] = {0};
int s = 0;  //所有石子堆的总和（提前计算好）

/* 计算p[i..j]的石子总和 (由于是环形，j可以小于i)*/
int calcSum(int p[], int l, int r, int n) {
    /* 特殊考虑完整（包含了全部石堆）的情况 */
    if (l - r == 1 || r - l + 1 == n)
        return s;
    /* 正常计算 */
    int sum = 0;
    for (int i = l; i != (r + 1) % n; i = (i + 1) % n)
        sum += p[i];
    return sum;
}

int MergeStone(int p[], int n) {

    int min_ans = INT_MAX;
    /* 石子堆的个数：从1到n */
    for (int l = 2; l <= n; l++) {
        /* 讨论l个石子的石子堆 p[i..j](由于是环形，j可以小于i) */
        for (int i = 0; i < n; i++) {
            int j = (i + l - 1) % n;
            int sum = calcSum(p, i, j, n);
            ans[i][j] = INT_MAX;
            /* 依次讨论每一个分割点d:将石子堆p[i..j]分成p[i..k]和 A[k+1..j] */
            for (int k = i; k != j; k = (k + 1) % n)
                ans[i][j] = min(ans[i][k] + ans[(k + 1) % n][j] + sum, ans[i][j]);
            /* l = n 即我们需要的答案范围，找出最小值 */
            if(l == n) {
                min_ans = min(ans[i][j], min_ans);
            }
        }
    }
    return min_ans;
}

int main() {
    int n = 4;
    int p[] = {4, 2, 3, 4};
    for (int i = 0; i < n; i++)
        s += p[i];
    printf("%d\n", MergeStone(p, n));
}

方法二：化圆为直 —— 时间复杂度O(n^3)

为方便遍历，可以考虑化圆为直：把圆形剪开 —— 假设石子堆为1、2、3，那么剪开的石子堆为1、2、3、1、2，那么如果原数组 p 长度为 n， 那么经过我们的剪开操作，长度变为 2n - 1。接下来就是和线型的合并石子问题一样了。

唯一的区别是：对于线型的2n - 1 个石子堆，我们的结果不是选取 L = 2n - 1的，而是 L= n 中所有结果的最小值。

代码实现：

（在未改进的线形合并石子问题上改的，故时间复杂度也为O(n^3)）

#define MAX 100

#include <cstdio>
#include <climits>
#include <algorithm>

using namespace std;
/* 合并石子问题：环形排列着N堆石子，现在要将石子合并成一堆。
 * 规定如下：每次只能将相邻的两堆石子合并，合并两堆石子所花费的时间为两堆石子的数量和。
 * 求将N堆石子合并成一堆最小花费的时间。（石子分为n堆，石子的数量存储在数组p[0..n-1]中）*/
int ans[2 * MAX][2 * MAX] = {0};

/* 将环形的石子化为线形 */
void GetList(int p[], int n) {
    int j = 0;
    for (int i = n; i < 2 * n - 1; i++)
        p[i] = p[j++];
}

int MergeStone(int p[], int n) {

    GetList(p, n);  //化圆为直
    int min_ans = INT_MAX;
    int N = 2 * n - 1;// 线形中石子堆个数看做 2n - 1
    /* 石子堆的个数：从1到n */
    for (int l = 2; l <= n; l++) {
        /* 讨论l个石子的石子堆 p[i..j] */
        for (int i = 0; i < N - l + 1; i++) {
            int j = i + l - 1;
            /* 计算石子堆p[i..j]的总数 */
            int sum = 0;
            for (int t = i; t <= j; t++)
                sum += p[t];

            /* 依次讨论每一个分割点d:将石子堆p[i..j]分成p[i..k]和 A[k+1..j] */
            ans[i][j] = INT_MAX;
            for (int k = i; k < j; k++)
                ans[i][j] = min(ans[i][k] + ans[k + 1][j] + sum, ans[i][j]);
            /* l = n 即我们需要的答案范围，找出最小值 */
            if (l == n) {
                min_ans = min(ans[i][j], min_ans);
            }
        }
    }
    return min_ans;
}

方法三： 化圆为直优化版 —— 时间复杂度\bg_white O(n^2)

同区间DP | 1：矩阵链乘问题（含优化） —— 例题：矩阵链乘、合并石子中的改进方法，新增最优决策点，存储于divide数组中。

代码实现：

#define MAX 100

#include <cstdio>
#include <climits>
#include <algorithm>

using namespace std;
/* 合并石子问题：环形排列着N堆石子，现在要将石子合并成一堆。
 * 规定如下：每次只能将相邻的两堆石子合并，合并两堆石子所花费的时间为两堆石子的数量和。
 * 求将N堆石子合并成一堆最小花费的时间。（石子分为n堆，石子的数量存储在数组p[0..n-1]中）*/

// 改进版2！！！！！
int ans[2 * MAX][2 * MAX] = {0};
int divide[2 * MAX][2 * MAX] = {0};

/* 将环形的石子化为线形 */
void GetList(int p[], int n) {
    int j = 0;
    for (int i = n; i < 2 * n - 1; i++)
        p[i] = p[j++];
}

void initDivideArray(int n) {
    for (int i = 0; i < n; i++)
        divide[i][i] = i;
}

int MergeStone(int p[], int n) {

    GetList(p, n);  //化圆为直
    int min_ans = INT_MAX;
    int N = 2 * n - 1;// 线形中石子堆个数看做 2n - 1
    initDivideArray(N);  //初始化divide数组

    /* 石子堆的个数：从1到n */
    for (int l = 2; l <= n; l++) {
        /* 讨论l个石子的石子堆 p[i..j] */
        for (int i = 0; i < N - l + 1; i++) {
            int j = i + l - 1;
            /* 计算石子堆p[i..j]的总数 */
            int sum = 0;
            for (int t = i; t <= j; t++)
                sum += p[t];

            /* 依次讨论每一个分割点d:将石子堆p[i..j]分成p[i..k]和 A[k+1..j] */
            ans[i][j] = INT_MAX;
            for (int temp, k = divide[i][j - 1]; k <= divide[i + 1][j]; k++) {
                temp = ans[i][k] + ans[k + 1][j] + sum;
                if (temp < ans[i][j]) {
                    ans[i][j] = temp;
                    divide[i][j] = k;
                }
            }

            /* l = n 即我们需要的答案范围，找出最小值 */
            if (l == n) {
                min_ans = min(ans[i][j], min_ans);
            }
        }
    }
    return min_ans;
}

增加一点点难度  —— 同时求最大最小

石子合并问题

成绩10开启时间2020年03月24日 星期二 23:15
折扣0.8折扣时间2020年04月21日 星期二 23:55
允许迟交否关闭时间2020年04月21日 星期二 23:55

问题描述: 在一个圆形操场的四周摆放着n堆石子. 现在要将石子有次序地合并成一堆. 规定每次只能选相邻的2堆石子合并成一堆, 并将新的一堆石子数记为该次合并的得分. 试设计一个算法, 计算出将n堆石子合并成一堆的最小得分和最大得分.

算法设计: 对于给定n堆石子, 计算合并成一堆的最小得分和最大得分.

数据输入: 第1行是正整数n, 1<=n<=100, 表示有n堆石子. 第2行有n个数, 分别表示n堆石子的个数.

结果输出: 第1行是最小得分, 第2行是最大得分.

 测试输入期待的输出时间限制内存限制额外进程
测试用例 1 
  1. 36↵
  2. 53 49 2 9 9 30 2 35 1 46 39 46 42 33 13 41 35 57 38 59 15 40 18 6 46 30 53 31 34 57 41 20 1 42 59 46 45 ↵
以文本方式显示
  1. 5913↵
  2. 24595↵
1秒64M0

上面我们只讨论了最小的情况，本题需要将最大、最小情况输出。其实最大、最小的套路是一摸一样的，只是在比较的时候改变一下符号而已。且：在求最大的情况下，上面针对求最小时的四边形不等式的优化不可用，需要老老实实遍历。

直接附上AC代码：

//
// Created by A on 2020/3/20.
//
#include <cstdio>
#include <cmath>
#include <climits>
#include <algorithm>

#define MAX 300

using namespace std;
/* 合并石子问题：环形排列着N堆石子，现在要将石子合并成一堆。
 * 规定如下：每次只能将相邻的两堆石子合并，合并两堆石子所花费的时间为两堆石子的数量和。
 * 求将N堆石子合并成一堆最小花费的时间。（石子分为n堆，石子的数量存储在数组p[0..n-1]中）*/

// 改进版2！！！！！
int min_ans[2 * MAX][2 * MAX] = {0};
int max_ans[2 * MAX][2 * MAX] = {0};
int min_divide[2 * MAX][2 * MAX] = {0};
int max_divide[2 * MAX][2 * MAX] = {0};


/* 将环形的石子化为线形 */
void GetList(int p[], int n) {
    int j = 0;
    for (int i = n; i < 2 * n - 1; i++)
        p[i] = p[j++];
}

void initDivideArray(int n) {
    for (int i = 0; i < n; i++) {
        min_divide[i][i] = i;
        max_divide[i][i] = i;
    }

}

void MergeStone(int p[], int n) {

    GetList(p, n);  //化圆为直
    int N = 2 * n - 1;// 线形中石子堆个数看做 2n - 1
    initDivideArray(N);  //初始化divide数组

    /* 石子堆的个数：从1到n */
    for (int l = 2; l <= n; l++) {
        /* 讨论l个石子的石子堆 p[i..j] */
        for (int i = 0; i < N - l + 1; i++) {
            int j = i + l - 1;
            /* 计算石子堆p[i..j]的总数 */
            int sum = 0;
            for (int t = i; t <= j; t++)
                sum += p[t];

            /* 依次讨论每一个分割点d:将石子堆p[i..j]分成p[i..k]和 A[k+1..j] */
            min_ans[i][j] = INT_MAX;
            for (int temp, k = min_divide[i][j - 1]; k <= min_divide[i + 1][j]; k++) {
                temp = min_ans[i][k] + min_ans[k + 1][j] + sum;
                if (temp < min_ans[i][j]) {
                    min_ans[i][j] = temp;
                    min_divide[i][j] = k;
                }
            }
            max_ans[i][j] = INT_MIN;
            for (int temp, k = i; k < j; k++) {
                temp = max_ans[i][k] + max_ans[k + 1][j] + sum;
                if (temp > max_ans[i][j]) {
                    max_ans[i][j] = temp;
                    max_divide[i][j] = k;
                }
            }
        }
    }
}

int main() {
    int n, p[MAX];
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
        scanf("%d", &p[i]);

    MergeStone(p, n);
    int maxResult = INT_MIN, minResult = INT_MAX;
    for (int i = 0, j = n - 1; i < n; i++, j++) {
        maxResult = max(maxResult, max_ans[i][j]);
        minResult = min(minResult, min_ans[i][j]);
    }
    printf("%d\n%d\n", minResult, maxResult);
}

有任何问题欢迎评论交流，如果本文对您有帮助不妨点点赞，嘻嘻~  

end 

欢迎关注个人公众号“ 鸡翅编程 ”，这里是认真且乖巧的码农一枚。

---- 做最乖巧的博客er，做最扎实的程序员 ----

旨在用心写好每一篇文章，平常会把笔记汇总成推送更新~

在这里插入图片描述

贝贝今天AC了吗
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划——区间dp [石子合并]
小天狼星_布莱克 的博客
07-06 2367
动态规划（dp）是一种通过将问题分解为子问题，并利用已解决的子问题的解来求解原问题的方法。适用于具有重叠子问题和最优子结构性质的优化问题。通过定义状态和状态转移方程，动态规划可以在避免重复计算的同时找到问题的最优解，是一种高效的求解方法，常用于解决各种问题，如最短路径、背包问题、序列比对等。区间dp是一种dp的应用，用于解决涉及区间的问题。它将问题划分为若干个子区间，并通过定义状态和状态转移方程来求解每个子区间的最优解，最终得到整个区间的最优解。
算法讲解之Dynamic Programing —— 区间DP [变形：环形DP]
skysys的研究小屋
08-16 4928
对区间DP和其变式环形DP的总结。 首先先来例题。 codevs.cn 1048 石子归并 题目描述 Description 有n堆石子排成一列，每堆石子有一个重量w[i], 每次合并可以合并相邻的两堆石子，一次合并的代价为两堆石子的重量和w[i]+w[i+1]。问安排怎样的合并顺序，能够使得总合并代价达到最小。 输入描述 Input Description
石子合并之二
最新发布
bz02_2023f2的博客
06-28 211
在一个环形跑道上有N堆石子，每次取相邻两堆进行合并最终合并成为一堆。请问将每次合并后的代价进行累加其总和最少为多少。
线性区间 dp 与环形区间 dp
oscar1224的博客
05-19 1602
区间dp就是在区间上进行动态规划，求解一段区间上的最优解；该问题的求解思路主要是通过合并小区间的最优解进而得出整个大区间上最优解的dp算法。（实际上还是通过子问题的解来求出原问题的解）
石子合并+环形石子合并+能量项链+凸多边形的划分——区间DP
心如冰清，天塌不惊
02-15 2461
第二行是 N 个用空格隔开的正整数，所有的数均不超过 1000，第 i 个数为第 i 颗珠子的头标记，当 i<N 时，第 i 颗珠子的尾标记应该等于第 i+1 颗珠子的头标记，第 N 颗珠子的尾标记应该等于第 1 颗珠子的头标记。如果前一颗能量珠的头标记为 m，尾标记为 r，后一颗能量珠的头标记为 r，尾标记为 n，则聚合后释放的能量为 m×r×n（Mars 单位），新产生的珠子的头标记为 m，尾标记为 n。例如：设 N=4，4 颗珠子的头标记与尾标记依次为 (2，3)(3，5)(5，10)(10，2)。
区间DP —— 石子合并
qq_45949914的博客
08-12 174
区间DP的经典例题，有三种题型 本篇博客借鉴了了两位大佬的博客。 博客1、博客2 一、任意合并 问题： N堆石子，现要将石子有序的合并成一堆。每次只能移动任意的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。 思路： 贪心，每次把最小的两堆合并即可，可以使用stl中的优先队列来实现。 代码： #include<iostream> #include<queue> #define ll long long using namespace s
区间DP入门——石子合并问题
我在浪里
05-03 496
石子合并问题是最经典的DP问题。首先它有如下3种题型： (1)有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动任意的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。 分析：当然这种情况是最简单的情况，合并的是任意两堆，直接贪心即可，每次选择最小的两堆合并。本问题实际上就是哈夫曼的变形。
(区间dp) (经典例题) 石子合并
cuber-lotus的博客
08-31 876
P1775 石子合并（弱化版） 环形石子合并 Dire Wolf - hdu5115 石子合并是区间dp的一道经典例题。各种变形也是层出不穷，最经典的就是"环形石子合并"，而解决思路就是破环成链石子合并和最长回文子序列这类区间dp的最大不同在于有分割[i, j]区间的思想，因此时间复杂度是O(n^3)，一般能过1e2量级的题目，而到了1e3量级的就需要四边形不等式优化来处理
四边形不等式优化（区间DP）例题_石子合并问题
weixin_43791787的博客
08-01 217
在动态规划中，经常遇到形如下式的状态转移方程： 　　　　m(i,j)=min{m(i,k-1),m(k,j)}+w(i,j)(i≤k≤j)（min也可以改为max） 　　上述的m(i,j)表示区间[i,j]上的某个最优值。w(i,j)表示在转移时需要额外付出的代价。该方程的时间复杂度为O(N3) 　　 　　下面我们通过四边形不等式来优化上述方程，首先介绍什么是“区间包含的单调性”和“四边...
区间DP小结(附经典例题)
热门推荐
Dust_heart的博客
08-13 2万+
——这篇文章主要想总结下区间DP的经典题目，同时给自己复习巩固这方面知识点。 区间DP 一、定义 区间DP，顾名思义是在区间上DP，它的主要思想就是先在小区间进行DP得到最优解，然后再利用小区间的最优解合并求大区间的最优解。 二、实现思路 下面给出区间DP最简单形式的伪代码(具体要根据题目修改) //mst(dp,0) 初始化DP数组 for......
shizihebing.rar_石子合并
09-24
在这个问题中，我们可以定义一个二维数组dp[i][j]表示前i堆石子合并到只剩j堆时的最小能量消耗。状态转移方程可以表示为： dp[i][j] = min(dp[i-1][k] + abs(a[i] - a[k])) for k in range(i) 其中，a[i]表示第i堆...
石子合并问题共1页.pdf.zip
11-22
对于石子合并问题，我们可以创建一个二维数组dp，其中dp[i][j]表示剩余i堆石子且当前玩家能取走j个石子时，当前玩家是否能赢得游戏。 然后，我们可以通过以下步骤构建动态规划表： 1. 初始化：当只剩下一堆石子时，...
算法设计与分析：石子合并问题
12-06
在这个问题中，我们面临一个圆形操场上的n堆石子，目标是通过相邻两堆石子的合并，最终形成一堆。每次合并会产生一个得分，即新堆的石子数量。任务是计算合并过程中的最小得分和最大得分。 首先，我们需要理解问题...
9动态规划算法2-石子合并.doc
05-07
我们可以使用一个二维数组dp来存储状态转移方程的结果，dp[i][j] 表示将前i个石子合并成一个石子时的最大价值。我们可以使用以下公式来计算dp[i][j]： dp[i][j] = max(dp[i-1][j-1] + value[i], dp[i-1][j]) 最后...
区间DP | 1：矩阵链乘问题（含优化） —— 例题：矩阵链乘、合并石子
weixin_43787043的博客
03-19 4069
矩阵链乘法问题：给定 n 个矩阵的链 <A1, A2, A3, ..., An>，矩阵 Ai 的规模为。求完全括号化方案，使得计算乘积A1A2...An所需要标量的乘法次数最少。 两个矩阵 A 和 B 只有相容，即 A 的列数等于 B 的行数时，才能相乘。如果 A 是 p×q 矩阵，B 是 q×r 矩阵，那么乘积 C 是 p× r 矩阵。计算 C 的进行了 pqr 次乘法...
树形DP | 1：—— 例题：小游戏
weixin_43787043的博客
03-19 1605
小游戏 成绩 10 开启时间 2020年03月10日 星期二 07:55 折扣 0.8 折扣时间 2020年04月7日 星期二 23:55 允许迟交 否 关闭时间 2020年04月7日 星期二 23:55 某人很喜欢玩计算机游戏，特别是战略游戏，但是有时他不能尽快找到解所以常常感到很沮丧。现在面临如下问题：他必须在一个中世纪的城堡...
入门DP | 2：租用游艇问题
weixin_43787043的博客
03-25 1549
租用游艇问题 成绩 10 开启时间 2020年03月24日 星期二 23:15 折扣 0.8 折扣时间 2020年04月21日 星期二 23:55 允许迟交 否 关闭时间 2020年04月21日 星期二 23:55 问题描述: 长江游艇俱乐部在长江上设置了n个游艇出租站1,2,…,n. 游客可在这些游艇出租站租用游艇, 并在下游的...
区间DP详解：从石子合并到最长回文串
本文将详细讲解C++中的区间动态规划（区间DP）及其应用，包括如何理解和解决典型的问题，如石子合并和最长回文串。 一、区间动态规划 区间DP是一种特殊的动态规划方法，它以区间长度作为状态的阶段。在这个过程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值