区间DP

注：本文是笔者在学习区间DP时，基于左程云、NotOnlySuccess、灵茶山艾府老师们的教学视频记录的学习笔记，这里特列出各位老师，以表对各位老师付出的感谢。另外，目前本文的是AI基于笔者想法产出，内容经过笔者审核，后续会进行人工更新。

1. 定义与核心思想

区间DP将大范围的问题拆分成若干小范围的问题来求解。它适用于"一段区间上的最优解可由其内部更小区间的最优解合并得到"的场景。

状态设计：dp[i][j] 表示区间 [i, j] 上的最优解（最大值 / 最小值 / 方案数等）。

核心转移框架：按区间长度从小到大递推。

// 基础区间DP框架 O(n^3)
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++) {          // 枚举划分点
            dp[i][j] = merge(dp[i][k], dp[k+1][j]);
        }
    }
}

实际编码中更常用"倒序枚举左端点 l，正序枚举右端点 r"的写法，配合二维 vector 实现，简洁不易出错。

时间复杂度：通常是 \(O(n^{3})\)（长度 × 左端点 × 划分点），部分题目可优化到 \(O(n^{2})\)（四边形不等式、或只需端点转移）。

与划分DP的关系：区间DP可以看作划分DP的一种特例——划分点 k 将 [i, j] 拆成 [i, k] 和 [k+1, j] 两个子区间。但区间DP的转移方式更丰富，不限于枚举划分点，还可以从端点扩展。

2. 分类讨论

区间DP根据状态如何从小范围扩展到大范围的方式，分为以下类别。

2.1 单边区间DP

特征：每次只从区间的一端取元素。当前区间 [i, j] 的状态，由去掉最左元素 [i+1, j] 或去掉最右元素 [i, j-1] 转移而来。

洛谷 P2858 Treats for the Cows G/S

题目描述：有 n 个零食排成一行，每天可以卖最左或最右的一个。第 k 天卖的零食价值为 v × k，求最大总价值。

题目解析：本质和 P1005 相同，只不过倍率是线性的而非指数。dp[l][r] 表示卖完 [l, r] 的最大收入，day = n - (r - l) 为当前是第几天。

int n;
cin >> n;
vector<int> v(n);
for (auto &x : v) cin >> x;
vector<vector<int>> dp(n, vector<int>(n, INT_MAX));
for (int l = n - 1; l >= 0; l--) {
    dp[l][l] = v[l] * n;  // 最后一天卖（第 n 天）
    for (int r = l + 1; r < n; r++) {
        int day = n - (r - l);
        dp[l][r] = max(dp[l + 1][r] + v[l] * day,
                       dp[l][r - 1] + v[r] * day);
    }
}
cout << dp[0][n - 1] << endl;

复杂度：\(O(n^{2})\)。

2.2 左右区间DP（基于两侧端点讨论）

特征：基于两侧端点的选或不选展开——讨论区间两端元素在最终序列中的角色，通常需要加一维记录"当前在区间的哪一侧"。

2.3 划分DP（基于中间划分点枚举）

特征：枚举选哪个划分点 k，将 [i, j] 拆成两个或多个子区间，合并子区间答案。这是区间DP最经典的形式。

CF1771D Hossam and (sub-)palindromic tree

题目描述：给定一棵树，每个节点有一个字母。从起点到终点沿最短路径走，途经的字符形成一个字符串。求整棵树中最长的回文子序列的长度。

题目解析：用 DFS 将树上的路径压成类似欧拉序的序列（每个节点在进入和离开子树时各记录一次），然后在序列上做最长回文子序列的区间DP。dp[l][r] = max(dp[l+1][r], dp[l][r-1])，若 s[l]==s[r] 则还可以从 dp[l+1][r-1] + 2 转移。由于每对字符在序列中被算了两次，答案需除以 2。

int T; cin >> T;
while (T--) {
    int n; cin >> n;
    string str; cin >> str;
    vector<vector<int>> g(n);
    for (int i = 1; i < n; i++) {
        int u, v; cin >> u >> v; u--, v--;
        g[u].push_back(v); g[v].push_back(u);
    }
    string s = " ";
    auto dfs = [&](auto &&dfs, int u, int fa) -> void {
        s += str[u];
        for (auto v : g[u]) {
            if (v == fa) continue;
            dfs(dfs, v, u);
            s += str[u];  // 回溯时也记录
        }
    };
    dfs(dfs, 0, -1);
    n = s.size() - 1;
    vector<vector<int>> dp(n + 2, vector<int>(n + 1));
    for (int l = n; l >= 1; l--) {
        for (int r = l; r <= n; r++) {
            dp[l][r] = max(dp[l+1][r], dp[l][r-1]);
            if (s[l] == s[r])
                dp[l][r] = max(dp[l][r], dp[l+1][r-1] + 2);
        }
    }
    cout << dp[1][n] / 2 << endl;
}

复杂度：\(O(n^{2})\)。

UVA10304 Optimal Binary Search Tree

题目描述：给定 n 个键的访问频率，构造一棵最优二叉搜索树，使期望搜索代价最小。每次访问的代价为 (深度+1) × 频率。

题目解析：经典的 OBST 问题。dp[l][r] 表示用 [l, r] 构建 OBST 的最小代价，枚举根节点 k。代价为 dp[l][k-1] + dp[k+1][r] + sum(l, r) - a[k]。用 opt[l][r] 记录最优 k，利用四边形不等式优化：opt[l][r-1] ≤ opt[l][r] ≤ opt[l+1][r]。

// O(n^3) 基础写法
int n;
while (cin >> n) {
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i++) cin >> a[i];
    vector<int> sum(n + 1);
    partial_sum(a.begin(), a.end(), sum.begin());
    vector<vector<int>> dp(n + 2, vector<int>(n + 2));
    for (int l = n; l >= 1; l--) {
        dp[l][l] = 0;
        for (int r = l + 1; r <= n; r++) {
            dp[l][r] = INT_MAX;
            for (int k = l; k <= r; k++)
                dp[l][r] = min(dp[l][r],
                    dp[l][k-1] + dp[k+1][r] + sum[r] - sum[l-1] - a[k]);
        }
    }
    cout << dp[1][n] << endl;
}

// O(n^2) 四边形不等式优化
vector<vector<int>> opt(n + 2, vector<int>(n + 2));
for (int l = n; l >= 1; l--) {
    dp[l][l] = 0; opt[l][l] = l;
    for (int r = l + 1; r <= n; r++) {
        dp[l][r] = INT_MAX;
        for (int k = opt[l][r-1]; k <= opt[l+1][r]; k++) {
            int v = dp[l][k-1] + dp[k+1][r] + sum[r] - sum[l-1] - a[k];
            if (v < dp[l][r]) dp[l][r] = v, opt[l][r] = k;
        }
    }
}

复杂度：基础 \(O(n^{3})\)，四边形不等式优化到 \(O(n^{2})\)。

CF2074G Game With Triangles: Season 2

题目描述：环形数组上，每次可以选择三个位置 i<j<k 且 i,k 不相邻，计算 a[i]×a[j]×a[k] 并删除中间元素（或选择跳过）。求最大总分。

题目解析：破环成链（将数组复制一倍） + 区间DP。dp[l][r] 表示区间 [l, r] 的最大得分。转移：(1) 跳过端点；(2) 在中间某点 k 处划分；(3) 选 a[l], a[k], a[r] 构成三角形，消除 [l+1, k-1] 和 [k+1, r-1] 的内部后得到三角形分数。

int T; cin >> T;
while (T--) {
    int n; cin >> n;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i++) cin >> a[i];
    a.insert(a.end(), a.begin() + 1, a.end());  // 破环成链
    n *= 2;
    vector<vector<i64>> dp(n + 2, vector<i64>(n + 2));
    for (int l = n; l >= 1; l--) {
        for (int r = l; r <= n; r++) {
            dp[l][r] = max(dp[l][r-1], dp[l+1][r]);
            for (int k = l + 1; k < r; k++) {
                dp[l][r] = max(dp[l][r], dp[l][k] + dp[k+1][r]);
                dp[l][r] = max(dp[l][r],
                    dp[l+1][k-1] + dp[k+1][r-1] + a[l]*a[k]*a[r]);
            }
        }
    }
    n /= 2;
    i64 ans = 0;
    for (int i = 1; i <= n; i++)
        ans = max(ans, dp[i][i + n - 1]);
    cout << ans << endl;
}

复杂度：\(O(n^{3})\)。

2.4 环形区间DP

特征：序列是环形的。核心技巧——破环成链：将原数组复制一份接到末尾，得到 2n 的数组，区间DP后滑动窗口统计 ans = max/min(dp[i][i+n-1])。

2.5 二维区间DP

特征：状态定义为矩形区域的四个顶点 dp[x1][x2][y1][y2]。沿行或列切分，每次将矩形切成两个小矩形。

洛谷 P1436 棋盘分割

题目描述：8×8 棋盘，切成 n 块矩形。每块的分数为该块内数字之和的平方。求各块分数之和的最小值（等价于最小化均方差）。

题目解析：dp[l][r][d][u][k] 表示子矩形切成 k 块的最小分数。枚举切第 k-1 刀的位置：竖切或横切，左边/上边保留 k-1 块或右边/下边保留 k-1 块。

int n; cin >> n;
int s[9][9] = {};
for (int i = 1; i <= 8; i++)
    for (int j = 1; j <= 8; j++) {
        cin >> s[i][j];
        s[i][j] += s[i-1][j] + s[i][j-1] - s[i-1][j-1];  // 二维前缀和
    }
auto calc = [&](int x1, int x2, int y1, int y2) {
    int v = s[x2][y2] - s[x1-1][y2] - s[x2][y1-1] + s[x1-1][y1-1];
    return v * v;
};
int dp[9][9][9][9][16];
for (int l = 8; l >= 1; l--) {
    for (int r = l; r <= 8; r++) {
        for (int d = 8; d >= 1; d--) {
            for (int u = d; u <= 8; u++) {
                dp[l][r][d][u][1] = calc(l, r, d, u);
                for (int k = 2; k <= n; k++) {
                    dp[l][r][d][u][k] = INT_MAX / 2;
                    for (int i = l; i < r; i++) {  // 竖切
                        dp[l][r][d][u][k] = min(dp[l][r][d][u][k],
                            dp[l][i][d][u][k-1] + calc(i+1, r, d, u));
                        dp[l][r][d][u][k] = min(dp[l][r][d][u][k],
                            dp[i+1][r][d][u][k-1] + calc(l, i, d, u));
                    }
                    for (int i = d; i < u; i++) {  // 横切
                        dp[l][r][d][u][k] = min(dp[l][r][d][u][k],
                            dp[l][r][d][i][k-1] + calc(l, r, i+1, u));
                        dp[l][r][d][u][k] = min(dp[l][r][d][u][k],
                            dp[l][r][i+1][u][k-1] + calc(l, r, d, i));
                    }
                }
            }
        }
    }
}
cout << dp[1][8][1][8][n] << '\n';

复杂度：\(O(8^{4} \cdot n) = O(n)\)（因为棋盘大小固定为 8×8）。

2.6 非完全区间DP

特征：答案并非求 [1, n] 整段区间的最优解，而是由若干个互不重叠的子区间组成。

方法：结合线性DP + 区间DP——先用区间DP算出每个连续段的内部最优解，再用线性DP从前缀中选择不重叠段。

洛谷 P6701 Genotype

题目描述：POI 1997。有若干基因变换规则（两个字母变成一个新字母）。给定字符串，问最少能化简为几个字母（每个字母必须是 'S'），或判断无解。

题目解析：区间DP判断每个区间能否化简为某个字母（用位掩码）。然后线性DP统计最少段数。

int T; cin >> T;
vector<vector<int>> trans(26, vector<int>(26));
while (T--) {
    string s; cin >> s;
    trans[s[1]-'A'][s[2]-'A'] |= 1 << (s[0]-'A');
}
int Q; cin >> Q;
while (Q--) {
    string s; cin >> s;
    int n = s.size();
    vector<vector<int>> dp(n, vector<int>(n));
    for (int l = n - 1; l >= 0; l--) {
        dp[l][l] = 1 << (s[l] - 'a');
        for (int r = l + 1; r < n; r++) {
            for (int k = l; k < r; k++) {
                for (int i = 0; i < 26; i++) {
                    if ((dp[l][k] >> i & 1) == 0) continue;
                    for (int j = 0; j < 26; j++) {
                        if ((dp[k+1][r] >> j & 1) == 0) continue;
                        dp[l][r] |= trans[i][j];
                    }
                }
            }
        }
    }
    vector<int> f(n + 1, INT_MAX / 2);
    f[0] = 0;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= i; j++)
            if (dp[j-1][i-1] >> ('S' - 'A') & 1)
                f[i] = min(f[i], f[j-1] + 1);
    if (f[n] == INT_MAX / 2) cout << "NIE" << endl;
    else cout << f[n] << endl;
}

复杂度：区间DP \(O(n^{3} \cdot 26^{2})\)，线性DP \(O(n^{2})\)。

2.7 统计类区间DP

特征：不求最优值，统计方案数。常见于括号序列计数、树的形态计数等。

2.8 线段类区间DP

特征：以线段/区间覆盖为背景，先对坐标离散化，然后对离散化后的位置做区间DP。

2.9 祖玛类区间DP（消除类）

特征：消除游戏背景，核心是相邻相同颜色/元素可以合并或消除。这是区间DP中最复杂的一类。通常需要额外维度记录"相同元素连续多少个"，复杂度可达 \(O(n^{4})\)。

核心模式：f[l][r][c] 记录前缀信息（与 a[l] 同色的元素个数），核心转移为 f[l][r][c] ← f[l][k][c-1] + dp[k+1][r-1]（满足 a[l]a[k]a[r]），然后 dp[l][r] ← f[l][r][c] + cost(c)。

洛谷 P5336 成绩单

题目描述：THUSC 2016。n 次考试成绩，每次可取走连续若干张成绩单，代价为 a + b×(max-min)^2。求取走全部的最小代价。

题目解析：dp[l][r] 表示取走 [l, r] 的最小代价。f[l][r][min][max] 表示 [l, r] 中取走一部分后，剩余成绩单的最小值和最大值分别为 min 和 max（离散化后的下标）时的最小代价。将 w 离散化以减小状态。

int n, a, b; cin >> n >> a >> b;
vector<int> w(n+1);
for (int i = 1; i <= n; i++) cin >> w[i];
auto ww = w;
sort(ww.begin(), ww.end());
ww.erase(unique(ww.begin(), ww.end()), ww.end());
for (int i = 1; i <= n; i++)
    w[i] = lower_bound(ww.begin(), ww.end(), w[i]) - ww.begin();
int m = ww.size();
const int inf = INT_MAX / 2;
vector<vector<int>> dp(n+2, vector<int>(n+1));
int f[52][51][51][51];
for (int l = n; l >= 1; l--) {
    for (int r = l; r <= n; r++) {
        dp[l][r] = inf;
        for (int k = l; k < r; k++)
            dp[l][r] = min(dp[l][r], dp[l][k] + dp[k+1][r]);
        memset(f[l][r], 0x7f, sizeof(f[l][r]));
        if (l == r) f[l][r][w[l]][w[l]] = a;
        for (int k = l; k < r; k++) {
            for (int i = 1; i < m; i++) {
                for (int j = 1; j < m; j++) {
                    auto &v = f[l][r][min(i, w[r])][max(j, w[r])];
                    v = min(v, f[l][k][i][j] + dp[k+1][r-1]);
                }
            }
        }
        for (int i = 1; i < m; i++)
            for (int j = 1; j < m; j++)
                dp[l][r] = min(dp[l][r],
                    f[l][r][i][j] + a + b * (ww[i]-ww[j]) * (ww[i]-ww[j]));
    }
}
cout << dp[1][n] << endl;

复杂度：\(O(n^{3} \cdot m^{2})\)，m 为离散化后 w 的取值数。

CF1107E Vasya and Binary String

题目描述：01 串，消除连续相同字符。消除长度为 len 的连续段的得分为 w[len]。求最大得分。

题目解析：和 UVA10559 类似。dp[l][r] 表示删除 [l, r] 的最大得分。f[l][r][c] 表示 [l, r] 处理后留下 c 个与 s[l] 相同字符（作为前缀）的最大得分。

int n; string str;
cin >> n >> str;
str.insert(str.begin(), ' ');
vector<int> w(n+1);
for (int i = 1; i <= n; i++) cin >> w[i];
vector<vector<i64>> dp(n+1, vector<i64>(n+1));
i64 f[101][101][101];
for (int l = n; l >= 1; l--) {
    for (int r = l; r <= n; r++) {
        for (int k = l; k < r; k++)
            dp[l][r] = max(dp[l][r], dp[l][k] + dp[k+1][r]);
        memset(f[l][r], 0x80, sizeof(f[l][r]));
        if (str[l] == str[r]) {
            if (l == r) f[l][r][1] = 0;
            for (int k = l; k < r; k++)
                if (str[k] == str[l])
                    for (int i = 2; i <= n; i++)
                        f[l][r][i] = max(f[l][r][i], f[l][k][i-1] + dp[k+1][r-1]);
            for (int i = 1; i <= n; i++)
                dp[l][r] = max(dp[l][r], f[l][r][i] + w[i]);
        }
    }
}
cout << dp[1][n] << endl;

复杂度：\(O(n^{4})\)。

洛谷 P2145 祖玛

题目描述：JSOI 2007。经典祖玛：≥3 个同色自动消失。给定初始序列，问最少插入珠子数。黑题。

题目解析：先压缩连续同色为 (color, cnt) 对。dp[l][r] 表示消除压缩后 [l, r] 的最小插入数，f[l][r][c] 表示消除后剩余 c (c<3) 个与 color[l] 同色珠子的最小代价。注意 cnt[r] 是否等于 1 对状态转移的影响：若 cnt[r]==1，前缀扩展直接 c+1；若 cnt[r]>1 且 c<2，跳跃到 3（因为两个连续珠子会合并）。

// 压缩：连续同色 → (color, cnt)
vector<int> color(1), cnt(1);
for (int i = 1; i <= n; i++)
    if (i == 1 || a[i] != a[i-1]) color.push_back(a[i]), cnt.push_back(1);
    else cnt.back()++;
n = color.size() - 1;
const int inf = INT_MAX / 2;
vector<vector<int>> dp(n+1, vector<int>(n+1));
vector<vector<array<int, 4>>> f(n+1, vector<array<int, 4>>(n+1, {inf,inf,inf,inf}));
for (int l = n; l >= 1; l--) {
    f[l][l][cnt[l] != 1] = 0;  // cnt[l]==1→剩余1个色，cnt[l]>1→剩余0个色
    dp[l][l] = max(1, 3 - cnt[l]);
    for (int r = l+1; r <= n; r++) {
        dp[l][r] = inf;
        for (int k = l; k < r; k++)
            dp[l][r] = min(dp[l][r], dp[l][k] + dp[k+1][r]);
        if (color[l] == color[r])
            for (int k = l; k < r; k++)
                if (color[k] == color[l])
                    for (int c = 0; c <= 2; c++) {
                        if (cnt[r] == 1)
                            f[l][r][c+1] = min(f[l][r][c+1], f[l][k][c] + dp[k+1][r-1]);
                        else if (c != 2)
                            f[l][r][3] = min(f[l][r][3], f[l][k][c] + dp[k+1][r-1]);
                    }
        for (int c = 0; c <= 3; c++)
            dp[l][r] = min(dp[l][r], f[l][r][c] + max(2 - c, 0));
    }
}
cout << dp[1][n] << endl;

复杂度：\(O(n^{3})\)（颜色压缩后 n 变小）。

洛谷 P1389 一个关于序列的游戏

题目描述：给定序列，每次可以删除一个区间，要求该区间内的值是"先递增再递减"的形状，并获得对应长度权值的分数。求最大总得分。

题目解析：dp[l][r] 表示删除 [l, r] 的最大得分。用 inc[l][r] 和 dec[l][r] 分别记录内部消除后只剩下递增/递减序列的最大收益。对于每个可能的山顶位置 k，合并 inc[l][k] + dec[k][r]。最后非完全线性DP。

int n; cin >> n;
vector<int> w(n+1), a(n+1);
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++) cin >> a[i];
const int inf = INT_MIN / 2;
vector<vector<int>> dp(n+1, vector<int>(n+1));
auto inc = dp, dec = dp;
for (int l = n; l >= 1; l--) {
    dp[l][l] = w[1]; inc[l][l] = dec[l][l] = 0;
    for (int r = l+1; r <= n; r++) {
        dp[l][r] = inc[l][r] = dec[l][r] = inf;
        for (int k = l; k < r; k++)
            dp[l][r] = max(dp[l][r], dp[l][k] + dp[k+1][r]);
        for (int k = l; k < r; k++) {
            if (inc[l][k] != inf && a[k]+1 == a[r])
                inc[l][r] = max(inc[l][r], inc[l][k] + dp[k+1][r-1]);
            if (dec[l][k] != inf && a[k]-1 == a[r])
                dec[l][r] = max(dec[l][r], dec[l][k] + dp[k+1][r-1]);
        }
        for (int k = l; k <= r; k++) {
            if (inc[l][k] == inf || dec[k][r] == inf) continue;
            int remainLen = a[k]-a[l] + a[k]-a[r] + 1;
            dp[l][r] = max(dp[l][r], w[remainLen] + inc[l][k] + dec[k][r]);
        }
    }
}
vector<int> linear(n+1);
for (int i = 1; i <= n; i++) {
    linear[i] = max(0, linear[i-1]);
    for (int j = 1; j <= i; j++)
        linear[i] = max(linear[i], linear[j-1] + dp[j][i]);
}
cout << linear[n] << '\n';

复杂度：区间DP \(O(n^{3})\)，线性DP \(O(n^{2})\)。

2.10 特殊划分

特征：字符串压缩/折叠、区间合并等特殊规则，灵活程度高。

洛谷 P2470 压缩

题目描述：SCOI 2007。压缩字符串：用 M 标记重复开始，用 R 标记重复前面的内容。求压缩后的最短长度。

题目解析：comp[l][r] 表示 [l, r] 压缩后的最短长度。如果 [l, r] 可以由前半段重复两次得到，则用 M+R 压缩。最后线性DP合并不重叠段。

string str; cin >> str;
int n = str.size();
vector<vector<int>> comp(n, vector<int>(n, INT_MAX));
for (int l = 0; l < n; l++) {
    for (int r = l; r < n; r++) {
        for (int k = l + 1; k <= r; k += 2) {
            int len = k - l + 1;
            int half = len / 2;
            bool same = true;
            for (int i = 0; i < half; i++)
                if (str[l+i] != str[l+half+i]) { same = false; break; }
            if (!same) continue;
            comp[l][r] = min(comp[l][r], min(half, comp[l][l+half-1]) + 1 + r - k);
        }
    }
}
vector<int> f(n);
for (int i = 0; i < n; i++) {
    f[i] = min(i + 1, comp[0][i]);
    for (int j = 1; j <= i; j++)
        if (comp[j][i] != INT_MAX)
            f[i] = min(f[i], f[j-1] + comp[j][i] + 1);
}
cout << f[n-1] << endl;

复杂度：\(O(n^{3})\)。

洛谷 P4302 字符串折叠

题目描述：SCOI 2003。将重复子串折叠成 数字(内容) 的形式。求最短折叠后长度。

题目解析：dp[l][r] 表示 [l, r] 折叠后的最短长度。检查每个可能的循环节长度 len，若 [l, r] 由 [l, l+len-1] 重复组成，则可折叠。

string str;
while (cin >> str) {
    int n = str.size();
    const int inf = INT_MAX / 2;
    vector<vector<int>> dp(n, vector<int>(n, inf));
    for (int l = n-1; l >= 0; l--) {
        dp[l][l] = 1;
        for (int r = l+1; r < n; r++) {
            for (int k = l; k < r; k++)  // 划分
                dp[l][r] = min(dp[l][r], dp[l][k] + dp[k+1][r]);
            for (int len = 1; len <= (r-l+1)/2; len++) {
                if ((r-l+1) % len) continue;
                bool ok = true;
                for (int i = l+len; i+len-1 <= r; i += len)
                    for (int j = 0; j < len; j++)
                        if (str[l+j] != str[i+j]) { ok = false; break; }
                if (!ok) continue;
                int rep = (r-l+1) / len;
                int cnt = 2 + dp[l][l+len-1];  // () + 内容本身
                if (rep >= 100) cnt += 3;
                else if (rep >= 10) cnt += 2;
                else cnt += 1;
                dp[l][r] = min(dp[l][r], cnt);
            }
        }
    }
    cout << dp[0][n-1] << endl;
}

复杂度：\(O(n^{3})\)（检查循环节可用 KMP 优化到 \(O(n^{2})\)）。

UVA1630 Folding

题目描述：与 P4302 类似，但需要输出折叠后的方案。紫题。

题目解析：在 dp 基础上增加 opt[l][r] 记录决策（>0为划分点，<0为折叠周期长度的负数）。用 KMP 的 prefix function 高效检测循环节。

string str;
while (cin >> str) {
    int n = str.size();
    const int inf = INT_MAX / 2;
    vector<vector<int>> dp(n, vector<int>(n, inf));
    vector<vector<int>> opt(n, vector<int>(n));
    for (int i = 0; i < n; i++) dp[i][i] = 1;
    for (int l = n-1; l >= 0; l--) {
        for (int r = l; r < n; r++) {
            int len = r - l + 1;
            // 划分
            for (int k = l; k < r; k++)
                if (dp[l][k] + dp[k+1][r] < dp[l][r])
                    dp[l][r] = dp[l][k] + dp[k+1][r], opt[l][r] = k;
            // KMP 找循环节
            vector<int> pi(len);
            for (int i = l+1, p = 0; i <= r; i++) {
                while (p && str[i] != str[l+p]) p = pi[l+p-1];
                if (str[i] == str[l+p]) pi[i] = ++p;
            }
            if (pi[r] != 0 && len % (len - pi[r]) == 0) {
                int subLen = len - pi[r];
                int rep = len / subLen;
                int cnt = 2 + dp[l][l+subLen-1];
                if (rep >= 100) cnt += 3;
                else if (rep >= 10) cnt += 2;
                else cnt += 1;
                if (cnt < dp[l][r]) dp[l][r] = cnt, opt[l][r] = -subLen;
            }
        }
    }
    auto output = [&](auto &self, int l, int r) {
        if (l == r) { cout << str[l]; return; }
        if (opt[l][r] < 0) {
            int cnt = (r-l+1) / -opt[l][r];
            cout << cnt << '(';
            self(self, l, l - opt[l][r] - 1);
            cout << ')';
            return;
        }
        self(self, l, opt[l][r]);
        self(self, opt[l][r]+1, r);
    };
    output(output, 0, n-1);
    cout << endl;
}

复杂度：\(O(n^{2})\)（KMP 优化循环节检测）。

洛谷 P4805 合并饭团

题目描述：CCC 2016。合并连续区间，两端的和需等于中间的和。问最大能合并出多大的值。

题目解析：dp[l][r] 表示 [l, r] 能否合并（1/0）。双指针收缩检查两端和是否相等且中间可合并。

int n; cin >> n;
vector<int> a(n+1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<int> sum(n+1);
partial_sum(a.begin(), a.end(), sum.begin());
vector<vector<int>> dp(n+1, vector<int>(n+1));
int ans = 0;
for (int l = n; l >= 1; l--) {
    dp[l][l] = 1; ans = max(ans, a[l]);
    for (int r = l+1; r <= n; r++) {
        int ll = l, rr = r;
        while (ll < rr) {
            int left_sum = sum[ll] - sum[l-1];
            int right_sum = sum[r] - sum[rr-1];
            if (left_sum == right_sum) {
                if (dp[l][ll] && dp[rr][r] && (dp[ll+1][rr-1] || ll+1 == rr)) {
                    dp[l][r] = 1; break;
                }
                ll++, rr--;
            } else if (left_sum < right_sum) ll++;
            else rr--;
        }
        if (dp[l][r]) ans = max(ans, sum[r] - sum[l-1]);
    }
}
cout << ans << endl;

复杂度：\(O(n^{3})\)。

洛谷 P9746 合并序列

题目描述：KDOI-06-S。给定序列，执行操作：选择相邻三个元素 a,b,c，替换为 (a xor b xor c)，代价为 max(a,b,c)。可以操作多次，问能否变为单个元素；若能，输出方案。紫题。

题目解析：dp[l][r] 记录 [l, r] 可合并为的异或值 k。用 sub[l][k]（以 l 为左端点的最小右端点）、suf[r][k]（以 r 为右端点的最大左端点）、comb[l][k]（双区间合并的最远端点）来高效判定。本质是"三层嵌套"的区间DP。

const int limit = 512; int T; cin >> T;
while (T--) {
    int n; cin >> n;
    vector<int> arr(n+1), sum(n+1);
    for (int i = 1; i <= n; i++) cin >> arr[i];
    for (int i = 1; i <= n; i++) sum[i] = sum[i-1] ^ arr[i];
    const int invalid = INT_MAX;
    vector<vector<int>> sub(n+1, vector<int>(limit, invalid));
    vector<vector<int>> comb(n+1, vector<int>(limit, invalid));
    vector<vector<int>> suf(n+1, vector<int>(limit, INT_MIN));
    vector<vector<int>> dp(n+1, vector<int>(n+1, invalid));
    for (int l = n; l >= 1; l--) {
        dp[l][l] = -1;
        for (int r = l; r <= n; r++) {
            int xor_sum = sum[r] ^ sum[l-1];
            for (int k = 0; k < limit; k++)
                if (comb[l][k] < suf[r][k]) { dp[l][r] = k; break; }
            if (dp[l][r] != invalid) {
                suf[r][xor_sum] = max(suf[r][xor_sum], l);
                sub[l][xor_sum] = min(sub[l][xor_sum], r);
                if (r != n)
                    for (int k = 0; k < limit; k++)
                        comb[l][k] = min(comb[l][k], sub[r+1][k ^ xor_sum]);
            }
        }
        if (l != n)
            for (int k = 0; k < limit; k++)
                sub[l][k] = min(sub[l][k], sub[l+1][k]);
    }
    if (dp[1][n] == invalid) cout << "Shuiniao" << '\n';
    else {
        cout << "Huoyu" << '\n';
        // 递归输出方案（省略）
    }
}

复杂度：\(O(n^{2} \cdot limit)\)。

3. 代码模版

3.1 基础区间DP框架 (\(O(n^{3})\))

// dp[l][r] = [l, r] 区间的最优解
for (int l = n; l >= 1; l--) {
    dp[l][l] = init_val;  // 初始化单元素区间
    for (int r = l + 1; r <= n; r++) {
        dp[l][r] = INF;
        for (int k = l; k < r; k++) {
            dp[l][r] = min(dp[l][r], dp[l][k] + dp[k+1][r] + cost(l, r, k));
        }
    }
}
answer = dp[1][n];

3.2 环形区间DP框架

// 破环成链
for (int i = 1; i <= n; i++) a[n + i] = a[i];
// 区间DP
for (int l = 2 * n; l >= 1; l--)
    for (int r = l + 1; r <= 2 * n; r++)
        for (int k = l; k < r; k++)
            dp[l][r] = min(dp[l][r], dp[l][k] + dp[k+1][r] + cost(l, r, k));
// 滑动窗口统计
for (int i = 1; i <= n; i++)
    ans = min(ans, dp[i][i + n - 1]);

3.3 非完全区间DP框架

// Step 1: 区间DP — 计算每个连续段内部的最优解
for (int l = n; l >= 1; l--)
    for (int r = l; r <= n; r++)
        for (int k = l; k < r; k++)
            dp[l][r] = merge(dp[l][k], dp[k+1][r]);

// Step 2: 线性DP — 从前缀中选择不重叠段
for (int i = 1; i <= n; i++) {
    f[i] = f[i-1] + single_cost(i);
    for (int j = 1; j <= i; j++)
        if (can_form(j, i))
            f[i] = min(f[i], f[j-1] + dp[j][i]);
}
answer = f[n];

4. 技巧总结

区间DP答案不一定在 dp[1][n]：环形DP的答案在滑动窗口中取最值，非完全DP的答案在 f[n] 中。
破环成链是处理环形问题的标准技巧，将长度翻倍后做区间DP，再取长度为 n 的窗口的最值。
四边形不等式优化：当 cost 函数满足四边形不等式时，划分点 k 有决策单调性（opt[l][r-1] ≤ opt[l][r] ≤ opt[l+1][r]），可将 \(O(n^{3})\) 优化到 \(O(n^{2})\)。典型题：UVA10304。
输出方案：用 opt[l][r] 记录 dp[l][r] 的决策（划分点或折叠方式），最后递归输出。
迭代 vs 记忆化：迭代（l 倒序、r 正序）常数更小；状态复杂的题目（如多维消除类）记忆化搜索代码更简洁。
祖玛类通用模式：f[l][r][c] 记录前缀信息（与 a[l] 同色的元素个数），核心转移 f[l][r][c] ← f[l][k][c-1] + dp[k+1][r-1]（需 a[l]a[k]a[r]），然后用 dp[l][r] = min(f[l][r][c] + cost(c)) 一起消除。
环形+祖玛：破环成链后做消除类区间DP，答案取滑动窗口最小值。典型题：AT_abc400_f。

posted @ 2026-05-26 12:13 Tangzy0121 阅读(16) 评论(1) 收藏举报

刷新页面返回顶部

区间DP

1. 定义与核心思想

2. 分类讨论

2.1 单边区间DP

2.2 左右区间DP（基于两侧端点讨论）

2.3 划分DP（基于中间划分点枚举）

2.4 环形区间DP

2.5 二维区间DP

2.6 非完全区间DP

2.7 统计类区间DP

2.8 线段类区间DP

2.9 祖玛类区间DP（消除类）

2.10 特殊划分

3. 代码模版

3.1 基础区间DP框架 (\(O(n^{3})\))

3.2 环形区间DP框架

3.3 非完全区间DP框架

4. 技巧总结

公告