一、什么是环形DP
环形动态规划（Circular Dynamic Programming）是处理环形结构数据的一类特殊DP问题。与线性DP不同，环形DP中第一个元素和最后一个元素相邻，形成一个闭环。这种结构导致起点和终点可以相互影响，增加了问题的复杂性。
1.1环形DP的核心
-
循环依赖：首尾元素相互影响，难以确定起点
-
状态转移复杂：需要考虑跨越首尾边界的情况
-
解空间扩大：最优解可能出现在环上的任意位置
1.2环形问题的通用解法
破环成链法：将环形结构转化为线性结构处理
-
复制原始序列并接在其尾部
-
在长度为2N的新序列上进行线性DP
-
计算结果时，枚举所有长度为N的区间
-
二、经典问题1：环形石子合并
2.1问题描述
将 n堆石子绕圆形操场排放，现要将石子有序地合并成一堆。规定每次只能选相邻的两堆合并成新的一堆，并将新的一堆的石子数记做该次合并的得分请编写一个程序，读入堆数n及每堆的石子数，并进行如下计算 1、选择一种合并石子的方案，使得做 n-1次合并得分总和最大。 2、选择一种合并石子的方案，使得做 n-1次合并得分总和最小
输入格式： 输入第一行一个整数 n，表示有 n堆石子, 第二行 n个整数，表示每堆石子的数量。
输出格式： 输出共两行 第一行为合并得分总和最小值，第二行为合并得分总和最大值,
输入样例： 4 4 5 9 4
输出样例： 43 54
对于100%的数据，有1≤n≤200
2.2 破环成链
int a[201]; // 原始石子数组
int sum[202]; // 前缀和数组
// 复制序列
for(int i = 1; i <= n; i++) {
cin >> a[i];
a[n+i] = a[i]; // 复制一份接在尾部
}
// 计算前缀和
for(int i = 1; i <= 2*n; i++) {
sum[i] = sum[i-1] + a[i];
}
2.3 状态定义
f[i][j]：合并区间[i,j]内石子的最小代价
2.4 状态转移方程
f[i][j] = min(f[i][j], dfs_min(i, j) + dfs_min(i + 1, j) + sum[j] - sum[i - 1]);
2.5 记忆化搜索实现
int dfs(int begin, int end) {
if(f[begin][end]) return f[begin][end]; // 记忆化
if(begin >= end) return 0; // 边界条件
int ret = MAX_INT;
for(int k = begin; k < end; k++) {
int cost = dfs(begin, k) + dfs(k+1, end) + sum[end] - sum[begin-1];
ret = min(ret, cost);
}
f[begin][end] = ret; // 存储结果
return ret;
}
2.6 完整代码
#include <iostream>
using namespace std;
int sum[202], a[101]; // 声明存储石子总数的数组sum和存储每堆石子数量的数组a
int n; // 存储石子堆数量
int f[202][202]; // 用于存储最小得分的动态规划数组
int fmax[202][202]; // 用于存储最大得分的动态规划数组
// 计算任意两点之间的最小合并分数和
int dfs_min(int s, int e)
{
if (s >= e)
return 0;
if (f[s][e])
return f[s][e];
int ans = 0x3f3f3f3f; // 初始化ans为一个较大的值
for (int k = s; k < e; k++)
ans = min(ans, dfs_min(s, k) + dfs_min(k + 1, e) + sum[e] - sum[s - 1]);
f[s][e] = ans;
return ans;
}
// 计算任意两点之间的最大合并分数和
int dfs_max(int s, int e)
{
if (s >= e)
return 0;
if (fmax[s][e])
return fmax[s][e];
int ans = 0;
for (int k = s; k < e; k++)
ans = max(ans, dfs_max(s, k) + dfs_max(k + 1, e) + sum[e] - sum[s - 1]);
fmax[s][e] = ans;
return ans;
}
int main()
{
cin >> n; // 输入石子堆数量
for (int i = 1; i <= n; i++)
{
cin >> a[i]; // 输入每堆石子数量
sum[i] = sum[i - 1] + a[i]; // 计算前缀和，表示前i堆石子总数
}
// 将前缀和连接成2n-1的链，用于求解任意两点之间的合并分数和
for (int i = 1; i <= n - 1; i++)
{
sum[n + i] = sum[n + i - 1] + a[i];
}
// 求链上任意两点的最小合并分数和和最大合并分数和
dfs_min(1, 2 * n - 1);
dfs_max(1, 2 * n - 1);
int ansmin = 0x3f3f3f3f; // 初始化最小值
int ansmax = 0; // 初始化最大值
// 枚举链上长度为n的区间，找出其中的最小值和最大值
for (int i = 1; i <= n; i++)
{
ansmin = min(ansmin, f[i][i + n - 1]);
ansmax = max(ansmax, fmax[i][i + n - 1]);
}
// 输出最小得分和最大得分
cout << ansmin << endl << ansmax;
return 0;
}
三、经典问题2：能量项链
3.1 问题描述
环形排列的能量珠，每颗珠子有头尾标记。合并相邻珠子释放能量：m*r*n，其中m为前珠头标记，r为前珠尾标记（后珠头标记），n为后珠尾标记。
3.2 破环成链
int lace[201]; // 存储头标记
cin >> n;
for(int i = 1; i <= n; i++) {
cin >> lace[i];
lace[n+i] = lace[i]; // 复制序列
}
3.3 状态定义
f[i][j]：合并区间[i,j]内珠子释放的最大能量
3.4 状态转移方程
f[i][j] = max(maxn, search(i, k) + search(k+1, j) + lace[i] * lace[k+1] * lace[j+1]);
3.5 记忆化搜索实现
int search(int i, int j) {
if(f[i][j]) return f[i][j]; // 记忆化
if(i >= j) return 0; // 边界条件
int maxn = 0;
for(int k = i; k < j; k++) {
int energy = search(i, k) + search(k+1, j)
+ lace[i] * lace[k+1] * lace[j+1];
maxn = max(maxn, energy);
}
f[i][j] = maxn; // 存储结果
return maxn;
}
3.6 完整代码
#include <iostream>
using namespace std;
int n; // 存储项链上珠子的个数
int lace[201]; // 存储珠子的标记
int f[202][202]; // 用来存储动态转移方程中的结果
// 函数search：搜索从第i到第j颗珠子聚合后释放的能量的最大值
int search(int i, int j)
{
if(f[i][j]) // 如果f[i][j]已经计算过，则直接返回结果
return f[i][j];
if(i >= j) // 如果i大于等于j，说明没有珠子可聚合，返回0
return 0;
int maxn = 0; // 用来记录搜索过程中的最大能量值
for(int k = i; k < j; k++) // 循环遍历所有可能的分割点k
maxn = max(maxn, search(i, k) + search(k+1, j) + lace[i] * lace[k+1] * lace[j+1]);
// 更新maxn为当前的最大能量值
f[i][j] = maxn; // 将计算得到的结果存入f数组中
return maxn; // 返回从第i到第j颗珠子聚合后释放的能量的最大值
}
int main()
{
cin >> n; // 输入项链上珠子的个数n
for(int i = 1; i <= n; i++) // 循环读入每颗珠子的标记
{
cin >> lace[i]; // 输入第i颗珠子的头标记
lace[n+i] = lace[i]; // 将尾标记设置为与头标记相同
}
// 将前缀和连接成2n-1的链，用于求解任意两点之间的能量和
search(1, 2*n-1); // 调用search函数计算能量释放的最大值
int maxn = 0; // 记录最终的最大能量值
for(int i = 1; i <= n; i++) // 遍历所有可能的起始位置
maxn = max(maxn, f[i][i+n-1]); // 更新maxn为当前的最大能量值
cout << maxn;
return 0;
}
四、环形DP特点总结
4.1. 状态定义
-
区间型DP：
dp[i][j]表示区间[i,j]的最优解 -
状态含义与线性DP相似，但区间长度需考虑环状特性
4.2. 状态转移
-
枚举分割点k，将区间分为[i,k]和[k+1,j]
-
合并代价包含三部分：左区间代价 + 右区间代价 + 当前合并代价
4.3. 环形处理关键
// 序列复制
for(int i = 1; i <= n; i++) {
arr[n+i] = arr[i];
}
// 结果枚举
for(int i = 1; i <= n; i++) {
ans = min/max(ans, dp[i][i+n-1]);
}
4.4. 时间复杂度
-
状态数：O(N²)
-
每个状态转移：O(N)
-
总时间复杂度：O(N³)
五、环形DP扩展应用
5.1. 环形子数组最大和
int maxSubarraySumCircular(vector<int>& nums) {
int n = nums.size();
vector<int> arr(2*n);
// 复制数组
for(int i = 0; i < n; i++) {
arr[i] = arr[i+n] = nums[i];
}
// DP求解
int maxSum = INT_MIN;
vector<int> dp(2*n);
for(int i = 0; i < 2*n; i++) {
if(i == 0) dp[i] = arr[i];
else dp[i] = max(arr[i], dp[i-1] + arr[i]);
if(i >= n-1) maxSum = max(maxSum, dp[i]);
}
return maxSum;
}
5.2. 环形房屋盗窃
int robCircular(vector<int>& nums) {
int n = nums.size();
if(n == 0) return 0;
if(n == 1) return nums[0];
// 分两种情况：偷第一间和不偷第一间
return max(robRange(nums, 0, n-2), robRange(nums, 1, n-1));
}
int robRange(vector<int>& nums, int start, int end) {
int dp0 = 0, dp1 = 0;
for(int i = start; i <= end; i++) {
int temp = max(dp1, dp0 + nums[i]);
dp0 = dp1;
dp1 = temp;
}
return dp1;
}
六、环形DP优化技巧
6.1. 单调队列优化
对于某些环形问题，可以使用单调队列将时间复杂度优化到O(N)
// 环形滑动窗口最大值
vector<int> maxSlidingWindowCircular(vector<int>& nums, int k) {
int n = nums.size();
vector<int> arr(2*n);
for(int i = 0; i < 2*n; i++) {
arr[i] = nums[i % n];
}
deque<int> dq;
vector<int> result;
for(int i = 0; i < 2*n; i++) {
// 维护单调递减队列
while(!dq.empty() && arr[dq.back()] <= arr[i]) {
dq.pop_back();
}
dq.push_back(i);
// 移除超出窗口的元素
if(dq.front() <= i - k) {
dq.pop_front();
}
// 获取窗口最大值
if(i >= k-1) {
result.push_back(arr[dq.front()]);
}
}
return result;
}
6.2. 状态压缩
对于某些特殊环形问题，可以压缩状态空间
// 环形染色问题
int circleColor(int n) {
// dp[i]表示i个位置环形染色的方案数
vector<long> dp(n+1);
dp[1] = 3; // 三种颜色
dp[2] = 6; // 3*2
for(int i = 3; i <= n; i++) {
// 状态转移：考虑首尾颜色关系
dp[i] = dp[i-1] + 2 * dp[i-2];
}
return dp[n];
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
