【算法】动态规划专题⑫ —— 环形区间DP python

---

前置知识

【算法】动态规划专题⑪ —— 区间DP python

---

引入

环形区间动态规划（Circular Interval Dynamic Programming）是传统区间DP的一种扩展，它处理的问题场景中输入数据或问题结构呈现环状。
这意味着第一个元素和最后一个元素是相邻的，形成一个闭合的圈。这种特性使得一些原本适用于线性序列上的区间DP技术需要进行适当的调整才能应用到环形结构上。

核心挑战

在环形结构中，最大的挑战是如何处理首尾相连的情况。对于传统的区间DP而言，状态转移方程通常假设区间的两个端点是独立的，但在环形结构中，这不再成立。因此，直接套用普通的区间DP方法可能会导致错误的结果。

解决方案

解决这一问题的一个常见策略是将原问题分解成两个子问题来避免环形结构的影响：

1. 断开环：想象将环形结构在某个位置“切开”，使其变成一个线性的序列。这样就可以使用标准的区间DP算法。
2. 考虑所有可能的切割点：由于不知道在哪里“切开”最为合适，因此需要尝试每一个可能的位置，并从中选择最优解。

具体步骤如下：

1. 扩大数组范围：为了方便处理，可以将原始数组复制一份接到自身后面，形成一个长度为原数组两倍的新数组。这样做是为了模拟环形结构中从任意一点开始遍历整个环的效果。

2. 执行标准区间DP：在这个扩大的数组上执行标准的区间DP算法，但需要注意的是，当计算dp[i][j]时，如果j-i >= n（n是原始数组的长度），则该区间实际上跨越了我们虚拟的“切割点”。

3. 寻找最优解：遍历所有可能的起点（即原数组中的每个元素作为起点），并根据区间DP的结果找到全局最优解。

示例应用

• 环形石子合并问题：给定一圈石子堆，每次可以合并相邻的两堆，合并的代价等于这两堆石子的数量之和。求最小化总合并代价。

  在这个问题中，可以采用上述方法，首先将环形结构转化为线性结构，然后通过区间DP计算出最小合并代价。

---

进入正题

P1880 [NOI1995] 石子合并

题目描述

在一个圆形操场的四周摆放 $N$ 堆石子，现要将石子有次序地合并成一堆，规定每次只能选相邻的 $2$ 堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。

试设计出一个算法,计算出将 $N$ 堆石子合并成 $1$ 堆的最小得分和最大得分。

输入格式

数据的第 $1$ 行是正整数 $N$，表示有 $N$ 堆石子。

第 $2$ 行有 $N$ 个整数，第 $i$ 个整数 $a_i$ 表示第 $i$ 堆石子的个数。

输出格式

输出共 $2$ 行，第 $1$ 行为最小得分，第 $2$ 行为最大得分。

输入

4
4 5 9 4

输出

43
54

说明/提示

$1\le N\le 100$，$0\le a_i\le 20$。

题解code：

n = int(input())
a = list(map(int, input().split()))
a += a  # 复制数组以处理环形结构

dp = [[0] * (2 * n) for _ in range(2 * n)]

# 计算前缀和
pre_sum = [0] * (2 * n + 1)
for i in range(1, 2 * n + 1):
    pre_sum[i] = pre_sum[i - 1] + a[i - 1]

for len in range(2, n + 1):
    for i in range(2 * n - len + 1):
        j = i + len - 1
        dp[i][j] = 10 ** 9
        for k in range(i, j):
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + pre_sum[j + 1] - pre_sum[i])

# 寻找最优解
min_cost = float('inf')
for i in range(n):
    min_cost = min(min_cost, dp[i][i + n - 1])
print(min_cost)

for len in range(2, n + 1):
    for i in range(2 * n - len + 1):
        j = i + len - 1
        for k in range(i, j):
            dp[i][j] = max(dp[i][j], dp[i][k] + dp[k + 1][j] + pre_sum[j + 1] - pre_sum[i])

max_cost = float('-inf')
for i in range(n):
    max_cost = max(max_cost, dp[i][i + n - 1])
print(max_cost)

---

好了，实际运用的时候到了

实战演练

P1063 [NOIP 2006 提高组] 能量项链

题目描述

在 Mars 星球上，每个 Mars 人都随身佩带着一串能量项链。在项链上有 $N$ 颗能量珠。能量珠是一颗有头标记与尾标记的珠子，这些标记对应着某个正整数。并且，对于相邻的两颗珠子，前一颗珠子的尾标记一定等于后一颗珠子的头标记。因为只有这样，通过吸盘（吸盘是 Mars 人吸收能量的一种器官）的作用，这两颗珠子才能聚合成一颗珠子，同时释放出可以被吸盘吸收的能量。如果前一颗能量珠的头标记为 $m$，尾标记为 $r$，后一颗能量珠的头标记为 $r$，尾标记为 $n$，则聚合后释放的能量为 $m\times r\times n$（Mars 单位），新产生的珠子的头标记为 $m$，尾标记为 $n$。

需要时，Mars 人就用吸盘夹住相邻的两颗珠子，通过聚合得到能量，直到项链上只剩下一颗珠子为止。显然，不同的聚合顺序得到的总能量是不同的，请你设计一个聚合顺序，使一串项链释放出的总能量最大。

例如：设 $N=4$，$4$ 颗珠子的头标记与尾标记依次为 $(2,3)(3,5)(5,10)(10,2)$。我们用记号 $\oplus$ 表示两颗珠子的聚合操作，$(j\oplus k)$ 表示第 $j,k$ 两颗珠子聚合后所释放的能量。则第 $4$，$1$ 两颗珠子聚合后释放的能量为：

$(4\oplus 1)=10\times 2\times 3=60$。

这一串项链可以得到最优值的一个聚合顺序所释放的总能量为：

$(((4\oplus 1)\oplus 2)\oplus 3)=10\times 2\times 3+10\times 3\times 5+10\times 5\times 10=710$。

输入格式

第一行是一个正整数 $N$（$4\le N\le 100$），表示项链上珠子的个数。第二行是 $N$ 个用空格隔开的正整数，所有的数均不超过 $1000$。第 $i$ 个数为第 $i$ 颗珠子的头标记（$1\le i\le N$），当 $i<N$ 时，第 $i$ 颗珠子的尾标记应该等于第 $i+1$ 颗珠子的头标记。第 $N$ 颗珠子的尾标记应该等于第 $1$ 颗珠子的头标记。

至于珠子的顺序，你可以这样确定：将项链放到桌面上，不要出现交叉，随意指定第一颗珠子，然后按顺时针方向确定其他珠子的顺序。

输出格式

一个正整数 $E$（$E\le 2.1\times 10^9$），为一个最优聚合顺序所释放的总能量。

样例输入

4
2 3 5 10

样例输出

710

说明/提示

NOIP 2006 提高组 第一题

思路：

题目要求我们找到一种最优的聚合顺序，使得一串项链释放出的总能量最大。
每颗珠子有两个标记：头标记和尾标记。相邻两颗珠子可以合并，合并时会释放一定的能量，新产生的珠子的头标记为前一颗珠子的头标记，尾标记为后一颗珠子的尾标记。
我们需要通过动态规划来求解这个问题。

1. 数组扩展：通过将数组扩展一倍，我们可以避免复杂的环形边界条件处理。
2. 动态规划：使用 dp[l][r] 表示从第 l 颗珠子到第 r 颗珠子的最大能量，并通过状态转移方程更新最大能量。
3. 寻找最大值：遍历所有可能的起点 i，找出从 i 开始的最长子串（长度为 n）的最大能量。

题解code：

n = int(input())
a = list(map(int, input().split()))
# 将数组扩展一倍以处理环形结构
a += a

dp = [[0] * 2 * n for _ in range(2 * n)]
# dp[l][r] 表示从第 l 颗珠子到第 r 颗珠子（包含 l 和 r）的最大能量
for len in range(2, n + 1):
    for l in range(2 * n):
        r = l + len - 1
        if r >= 2 * n:  # 右端点超出范围
            break
        # k 是切割点，尝试在每个可能的位置 k 进行切割
        for k in range(l, r):
            if r + 1 >= 2 * n: 
                break
            dp[l][r] = max(dp[l][r], dp[l][k] + dp[k + 1][r] + a[l] * a[k + 1] * a[r + 1])

ans = 0
# 遍历所有可能的起点 i，找出从 i 开始的子串（长度为 n）的最大能量
for i in range(n):
    ans = max(ans, dp[i][i + n - 1])
print(ans)

---

总结

环形区间DP的核心在于如何有效地处理首尾相连的特殊结构。
通过巧妙地将问题转换为已知的形式，利用区间DP技术，我们可以有效地解决这类问题。
理解这种方法的关键在于认识到可以通过适当的变换，使环形问题转化为更容易解决的线性问题。

---

END
如果有更多问题或需要进一步的帮助，可以在评论区留言讨论哦！
如果喜欢的话，请给博主点个关注 谢谢