2023 7月 dp做题记录

7月 dp做题记录

7月 dp做题记录

The Bakery #

这道题的状态转移并不难列，经典的分段问题，设状态 $d p_{i, j}$ 表示前 $i$ 个数字分了 $j$ 段的最大价值，转移可以写成

$d p_{i, j} = max (d p_{k, j - 1} + v a l_{k + 1, i})$

这里的 $v a l_{k + 1, i}$ 指的是区间 $[k + 1, i]$ 的价值，即不同数字的个数。如果不加优化，这个方程的转移复杂度是 $O (n^{2} k)$ 的。

现在的瓶颈是，如何快速的求出先前 $d p_{k, j - 1} + v a l_{k + 1, i}$ 的最大值。我们先分析 $v a l$ 贡献的计算，对于相同数字，出现两次是不会增加贡献的，所以我们可以把相同数字的贡献分段，对于数字 $a_{i}$ ，它在区间 $[p r e_{i}, i]$ 中贡献，保证每个区间只存在一个 $a_{i}$ ，这样贡献就不会重复计算。

求区间最大值，我们很容易想到用数据结构维护。需要区间修改和区间查询，求区间最大值，所以我们使用线段树。每枚举一个段数 $j$ ，我们就给线段树赋上初值 $d p_{k, j - 1}$ ，再枚举 $i$ 的同时更新贡献，并记录 $d p_{i, j}$ 的答案，即区间最大值。

复杂度 $O (k n \log n)$

#include <bits/stdc++.h>
using namespace std;
int read(){
    int x = 0, f = 1;
    char c = getchar();
    while(c < '0' || c > '9'){
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9'){
        x = (x << 1) + (x << 3) + (c - '0');
        c = getchar();
    }
    return x * f;
}
int n, k;
int w[35010 << 2], dp[35010][60], lazy[35010 << 2];
int pre[35010], pos[35010];
void pushup(int u){
    w[u] = max(w[u << 1], w[u << 1 | 1]);
}
void build(int u, int l, int r, int now){
    lazy[u] = 0;
    if(l == r){
        w[u] = dp[l - 1][now];
        return;
    }
    int mid = (l + r) >> 1;
    build(u << 1, l, mid, now);
    build(u << 1 | 1, mid + 1, r, now);
    pushup(u);
}
void pushdown(int u, int l, int r){
    w[u << 1] += lazy[u];
    w[u << 1 | 1] += lazy[u];
    lazy[u << 1] += lazy[u];
    lazy[u << 1 | 1] += lazy[u];
    lazy[u] = 0;
}
void update(int u, int l, int r, int L, int R){
    if(L <= l && r <= R){
        w[u]++;
        lazy[u]++;
        return;
    }
    int mid = (l + r) >> 1;
    pushdown(u, l, r);
    if(L <= mid) update(u << 1, l, mid, L, R);
    if(R > mid) update(u << 1 | 1, mid + 1, r, L, R);
    pushup(u);
}
int query(int u, int l, int r, int L, int R){
    if(L <= l && r <= R){
        return w[u];
    }
    int mid = (l + r) >> 1, ans = 0;
    pushdown(u, l, r);
    if(L <= mid) ans = max(ans, query(u << 1, l, mid, L, R));
    if(R > mid) ans = max(ans, query(u << 1 | 1, mid + 1, r, L, R));
    return ans;
}
int main(){
    n = read(), k = read();
    for(int i = 1; i <= n; i++){
        int a = read();
        pre[i] = pos[a];
        pos[a] = i; 
    }
    for(int j = 1; j <= k; j++){
        build(1, 1, n, j - 1);
        for(int i = 1; i <= n; i++){
            update(1, 1, n, pre[i] + 1, i);
            dp[i][j] = query(1, 1, n, 1, i);
        }
    }
    cout << dp[n][k] << endl;
    return 0;
}

P5785 [SDOI2012] 任务安排 #

先考虑朴素的做法，当前费用与启动次数有关，并且与区间内的和有关，所以处理前缀和，设状态 $d p_{i, j}$ 为到第 $i$ 个任务，分了 $j$ 批的最小费用，转移可以列成

$d p_{i, j} = min (d p_{k, j - 1} + (s + s u m t_{i}) \times (s u m c_{i} - s u m c_{j}))$

这样的状态复杂度是 $O (n^{3})$ 的。

考虑转换状态表示，我们发现当前启动仅对之后的任务费用有影响，所以我们把费用提前，把启动多出的费用提前计算，这样就不用考虑先前的启动次数了，状态 $d p_{i}$ 的意义也变成到第 $i$ 个任务，分了若干批的费用再加上由于启动多出的费用的最小费用。

$d p_{i} = min (d p_{j} + s \times (s u m c_{n} - s u m c_{j}) + s u m t_{i} \times (s u m c_{i} - s u m c_{j}))$

复杂度变为 $O (n^{2})$ ，可以通过弱化版的 P2365 任务安排。

这时候我们希望能更快找到先前的最小值。化简时发现当前枚举状态 $i$ 会对先前的 $j$ 贡献造成影响，所以不能用普通单调队列维护，同时也无法用数据结构维护。

化简式子，这里将 $s u m t$ 和 $s u m c$ 简写成 $t$ 和 $c$ ，

$d p_{j} = (s + t_{i}) c_{j} + d p_{i} - s c_{n} - t_{i} c_{i}$

这里为什么可以把 $min$ 去掉呢，是因为我们把 $d p_{j}$ 和 $c_{j}$ 看作一次函数中的 $f (x)$ 和 $x$ ，在平面直角坐标系中看成一个个点 $(c_{j}, d p_{j})$ 组成的点集。

这样子，我们可以发现这是一次函数的形式，并且要使 $d p_{i}$ 最小，即让这个一次函数的截距 $d p_{i} - s c_{n} - t_{i} c_{i}$ 最小。所以我们把问题抽象化，取 $j$ 的过程可以看作这条已知斜率的一次函数的直线不断向上移动的过程。可以发现，第一次碰到点集中的 $(c_{j}, d p_{j})$ 时，截距最小。

所以问题就变成，维护点集中有价值的点，并快速求出第一次碰到的点。由于点是无序的，我们可以两两连线，发现对答案有贡献的点即为这些直线组成的下凸包。根据下凸包的性质，组成下凸包的直线的斜率不断增大，我们可以用单调队列维护不断增大的斜率，若出现一个点，它与队尾连线的斜率小于队尾与它的前一位连线的斜率时，我们弹出队尾（因为这时队尾会成为上凸包的顶点）。

在此题中， $s + s u m t_{i}$ 并不是单调递增，所以队头不一定是最优的，我们需要用二分查找找到第一个碰到的点。具体的，若队列中点 $q_{m i d}$ 与 $q_{m i d + 1}$ 的连线大于斜率 $s + s u m t_{i}$ 时，右端点左移。

这样复杂度降到 $O (n \log n)$ ，这个技巧叫做斜率优化。

#include <bits/stdc++.h>
#define ll long long
using namespace std;
int read(){
    int x = 0, f = 1;
    char c = getchar();
    while(c < '0' || c > '9'){
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9'){
        x = (x << 1) + (x << 3) + (c - '0');
        c = getchar();
    }
    return x * f;
}
ll n, s, l = 1, r;
ll t[300010], c[300010];
ll q[300010], dp[300010];
ll find(ll l, ll r, int now){
    ll res = r;
    while(l <= r){
        ll mid = (l + r) >> 1;
        if((dp[q[mid + 1]] - dp[q[mid]]) >= (s + t[now]) * (c[q[mid + 1]] - c[q[mid]])) res = mid, r = mid - 1;
        else l = mid + 1;
    }
    return q[res];
}
int main(){
    n = read(), s = read();
    for(int i = 1; i <= n; i++){
        t[i] = read(), c[i] = read();   
        t[i] += t[i - 1];
        c[i] += c[i - 1];
    }
    q[++r] = 0;
    memset(dp, 0x3f, sizeof(dp));
    dp[0] = 0;
    for(int i = 1; i <= n; i++){
        ll j = find(l, r, i);
        dp[i] = dp[j] + s * (c[n] - c[j]) + t[i] * (c[i] - c[j]);
        while(l < r && (dp[q[r]] - dp[q[r - 1]]) * (c[i] - c[q[r]]) >= (dp[i] - dp[q[r]]) * (c[q[r]] - c[q[r - 1]])) r--;
        q[++r] = i; 
    }
    cout << dp[n] << endl;
    return 0;
}

P3195 [HNOI2008] 玩具装箱 #

经典的斜率优化动态规划问题。

首先考虑朴素做法，此题为典型的分段问题，并且不关心分了几段，可设状态 $d p_{i}$ 表示到第 $i$ 个玩具，分了若干段的最小费用。转移为

$d p_{i} = min (d p_{j} + (i - j - 1 - \sum_{k = j + 1}^{j} C_{k} - L)^{2})$

式子的变量太多，化简式子。可以发现求和部分可以用前缀和维护。将 $s u m_{i} = \sum_{k = 1}^{i} C_{k}$ ，有 $\sum_{k = j + 1}^{j} C_{k} = s u m_{i} - s u m_{j}$ 。同时我们可以把余下的 $i$ 和 $j$ 并入前缀和，设 $f_{i} = s u m_{i} + i$ 。

式子最后化简为 $d p_{i} = min_{0 \leq j < i} (d p_{j} + (f_{i} - f_{j} - 1 - L)^{2})$

复杂度是 $O (n^{2})$ 的，但很容易发现，我们只需要知道先前的最小值即可。这种式子并不可以用单纯的单调队列维护，因为化简出来后会带有类似 $f_{i} g_{j}$ 的量，这说明当前枚举的 $i$ 是会影响 $j$ 的贡献的。对于这样的式子，我们考虑斜率优化。

这次用更为普遍的方法。考虑对于两个量 $j_{1}$ 和 $j_{2}$ ，有 $j_{1} < j_{2}$ ，并且我们假设 $j_{2}$ 的贡献更优，可以得出

$d p_{j_{2}} + (f_{i} - f_{j_{2}} - 1 - L)^{2} < d p_{j_{1}} + (f_{i} - f_{j_{1}} - 1 - L)^{2}$

$d p_{j_{2}} + f_{i}^{2} - 2 f_{i} (f_{j_{2}} + 1 + L) + (f_{j_{2}} + 1 + L)^{2} < d p_{j_{1}} + f_{i}^{2} - 2 f_{i} (f_{j_{1}} + 1 + L) + (f_{j_{1}} + 1 + L)^{2}$

$d p_{j_{2}} + (f_{j_{2}} + 1 + L)^{2} - d p_{j_{1}} - (f_{j_{2}} + 1 + L)^{2} < 2 f_{i} (f_{j_{2}} - f_{j_{1}})$

$\frac{(d p_{j_{2}} + (f_{j_{2}} + 1 + L)^{2}) - (d p_{j_{1}} + (f_{j_{2}} + 1 + L)^{2})}{f_{j_{2}} - f_{j_{1}}} < 2 f_{i}$

将 $g_{i} = (f_{i} + 1 + L)^{2}$

\frac{(d p_{j_{2}} + g_{j_{2}}^{2}) - (d p_{j_{1}} + g_{j_{1}}^{2})}{f_{j_{2}} - f_{j_{1}}} < 2 f_{i}

这就是经典的斜率优化的形式，即满足此不等式的 $j_{1}$ 与 $j_{2}$ ，有 $j_{2}$ 优于 $j_{1}$ 。有了这个斜率式，我们就可以用单调队列维护一个斜率单调增加的点集，因为这个斜率式反映了我们需要维护下凸包。

针对这一题，由于 $2 f_{i}$ 是单调增加的，所以答案只可能出现在队首，我们直接利用上面的斜率式维护队首，满足就弹出，最后取出队首更新答案即可。如果 $2 f_{i}$ 不是单调增加的，我们就只能用二分查找找到最优决策点了，复杂度会多一个 $\log$ 。

补充：

这里需要补充一下为什么对于点集，我们只需要维护上凸包或下凸包即可。

为了方便表述，我们定义 $K (i, j)$ 表示 $i, j$ 两点的斜率。

接下来我们要证明： 如果 $i, j, k$ 满足 $k < j < i$ 且 $K (i, j) < K (j, k)$ ，则 $j$ 永远不可能成为最优解。

当 $K (i, j) \leq 2 \cdot s u m_{i}$ 时，选择 $i$ 优于选择 $j$ ，排除 $j$ 。
当 $K (i, j) > 2 \cdot s u m_{i}$ 时，选择 $j$ 优于选择 $i$ ，又因为 $K (j, k) > K (i, j) > 2 \cdot s u m_{i}$ ，所以选择 $k$ 优于选择 $j$ ，同样排除 $j$ 。

所以假设成立。

此处引用「算法笔记」斜率优化的证明

#include <bits/stdc++.h>
#define ll long long
using namespace std;
ll read(){
    ll x = 0, f = 1;
    char c = getchar();
    while(c < '0' || c > '9'){
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9'){
        x = (x << 1) + (x << 3) + (c - '0');
        c = getchar();
    }
    return x * f;
}
ll n, L, l = 1, r;
ll c[50010], f[50010], sum[50010], g[50010], dp[50010];
ll q[50010];
double slope(int j1, int j2){
    return (double)((dp[j2] + g[j2]) - dp[j1] - g[j1]) / (f[j2] - f[j1]);
}
int main(){
    n = read(), L = read();
    for(int i = 1; i <= n; i++){
        c[i] = read();
        sum[i] = sum[i - 1] + c[i];
        f[i] = sum[i] + i;
        g[i] = (f[i] + L + 1) * (f[i] + L + 1);
    }
    g[0] = (L + 1) * (L + 1);
    q[++r] = 0;
    for(int i = 1; i <= n; i++){
        while(l < r && slope(q[l], q[l + 1]) <= 2 * f[i]) l++;
        dp[i] = dp[q[l]] + (f[i] - f[q[l]] - 1 - L) * (f[i] - f[q[l]] - 1 - L);
        while(l < r && slope(q[r - 1], q[r]) > slope(q[r], i)) r--;
        q[++r] = i;
    }
    printf("%lld\n", dp[n]);
    return 0;
}

P3648 [APIO2014] 序列分割 #

把长度为 $n$ 的序列分成 $k + 1$ 块，也就是分 $k$ 次，使得分最高。

对于这一类题，我们都可以探索一个性质。因为题目中的分块是无序的，可能同一分割方法不同分割顺序得到的答案不一样，这不利于我们转移，但我们可以猜测分割顺序是不影响答案的。

设有 $a b c$ 序列，

先分割 $a b$ ，再分割 $b c$ 的答案是 $a (b + c) + b c = a b + a c + b c$

先分割 $b c$ ，再分割 $a b$ 的答案是 $(a + b) c + a b = a b + a c + b c$

所以顺序不影响答案，我们只需要求出如何分割即可。

从左到右按顺序考虑，可设状态 $d p_{i, j}$ 为到第 $i$ 块切割了 $j$ 次的最大价值，转移我们枚举第一次分割（因为贡献更好计算），同时是最右边的分割，

$d p_{i, j} = max_{1 \leq k < i} (d p_{k, j - 1} + s u m_{k} \times (s u m_{i} - s u m_{k}))$

求先前最大值，并且带有 $s u m_{k} s u m_{i}$ 的量，我们考虑斜率优化。首先空间上可以滚动数组，记 $g_{k} = d p_{k, j - 1}$

原式为 $d p_{i} = max_{1 \leq k < i} (g_{k} + s u m_{k} \times (s u m_{i} - s u m_{k}))$

设 $k$ 和 $k^{'}$ ， $k < k^{'}$ ，有 $k^{'}$ 的贡献优于 $k$ ，即

$g_{k} + s u m_{k} \times (s u m_{i} - s u m_{k}) < g_{k'} + s u m_{k^{'}} \times (s u m_{i} - s u m_{k^{'}})$

$g_{k} + s u m_{k} s u m_{i} - s u m_{k}^{2} < g_{k^{'}} + s u m_{k^{'}} s u m_{i} - s u m_{k^{'}}^{2}$

$g_{k} - s u m_{k}^{2} - g_{k^{'}} + s u m_{k^{'}}^{2} < s u m_{i} (s u m_{k^{'}} - s u m_{k})$

$\frac{(g_{k} - s u m_{k}^{2}) - (g_{k^{'}} - s u m_{k^{'}}^{2})}{- s u m_{k} - (- s u m_{k^{'}}^{2})} < s u m_{i}$

这可以看作点集 $(- s u m_{k}, g_{k} - s u m_{k}^{2})$ 在第三象限组成的下凸包，维护不断增加的斜率即可。

对于询问方案，每次转移时，记录转移点，从后往前不断跳前继转移点即可。

#include <bits/stdc++.h>
#define ll long long
using namespace std;
ll read(){
    ll x = 0, f = 1;
    char c = getchar();
    while(c < '0' || c > '9'){
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9'){
        x = (x << 1) + (x << 3) + (c - '0');
        c = getchar();
    }
    return x * f;
}
ll n, K, l, r;
ll f[100010], sum[100010], dp[100010], a[100010], q[100010], sum2[100010];
int pre[100010][210];
double slope(int k1, int k2){
    if(sum[k1] == sum[k2]) return -1e18;
    return 1.0 * (f[k1] - sum2[k1] - f[k2] + sum2[k2]) / (sum[k2] - sum[k1]); 
}
int main(){
    n = read(), K = read();
    for(int i = 1; i <= n; i++){
        a[i] = read();
        sum[i] = sum[i - 1] + a[i];
        sum2[i] = sum[i] * sum[i];
    }
    for(int k = 1; k <= K; k++){
        for(int i = 1; i <= n; i++){
            f[i] = dp[i];
        }
        for(int i = 1; i <= n; i++) q[i] = 0;
        l = 1, r = 0;
        q[++r] = 0;
        for(int i = 1; i <= n; i++){
            while(l < r && slope(q[l], q[l + 1]) <= sum[i]) l++;
            dp[i] = f[q[l]] + sum[q[l]] * (sum[i] - sum[q[l]]);
            pre[i][k] = q[l];
            while(l < r && slope(i, q[r]) <= slope(q[r], q[r - 1])) r--; 
            q[++r] = i;
        }
    }
    cout << dp[n] << endl;
    int now = n;
    for(int i = K; i >= 1; i--){
        cout << pre[now][i] << " ";
        now = pre[now][i];  
    }
    cout << endl;
    return 0;
}

posted @ 2024-04-20 11:37 Fire_Raku 阅读(5) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2023 5月 dp做题记录

· 2023 6月 dp做题记录

· 斜率优化DP

· 斜率优化 dp

· 斜率优化dp学习笔记

公告

昵称： Fire_Raku
园龄： 1年5个月
粉丝： 2
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

Loading

FireRaku

2023 7月 dp做题记录

7月 dp做题记录

The Bakery #

P5785 [SDOI2012] 任务安排 #

P3195 [HNOI2008] 玩具装箱 #

P3648 [APIO2014] 序列分割 #

公告

搜索

我的标签

随笔档案

阅读排行榜