2023 7月 dp做題記錄

Fire_Raku發表於2024-04-20

7月 dp做題記錄
- - The Bakery
  - P5785 [SDOI2012] 任務安排
  - P3195 [HNOI2008] 玩具裝箱
  - P3648 [APIO2014] 序列分割

7月 dp做題記錄

The Bakery

這道題的狀態轉移並不難列，經典的分段問題，設狀態 \(dp_{i,j}\) 表示前 \(i\) 個數字分了 \(j\) 段的最大價值，轉移可以寫成

\(dp_{i,j}=\max(dp_{k,j-1}+val_{k+1,i})\)

這裡的 \(val_{k+1,i}\) 指的是區間 \([k+1,i]\) 的價值，即不同數字的個數。如果不加最佳化，這個方程的轉移複雜度是 \(O(n^2k)\) 的。

現在的瓶頸是，如何快速的求出先前 \(dp_{k,j-1}+val_{k+1,i}\) 的最大值。我們先分析 \(val\) 貢獻的計算，對於相同數字，出現兩次是不會增加貢獻的，所以我們可以把相同數字的貢獻分段，對於數字 \(a_i\)，它在區間 \([pre_i,i]\) 中貢獻，保證每個區間只存在一個 \(a_i\)，這樣貢獻就不會重複計算。

求區間最大值，我們很容易想到用資料結構維護。需要區間修改和區間查詢，求區間最大值，所以我們使用線段樹。每列舉一個段數 \(j\)，我們就給線段樹賦上初值 \(dp_{k,j-1}\)，再列舉 \(i\) 的同時更新貢獻，並記錄 \(dp_{i,j}\) 的答案，即區間最大值。

複雜度 \(O(kn\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] 任務安排

先考慮樸素的做法，當前費用與啟動次數有關，並且與區間內的和有關，所以處理字首和，設狀態 \(dp_{i,j}\) 為到第 \(i\) 個任務，分了 \(j\) 批的最小費用，轉移可以列成

\(dp_{i,j}=\min(dp_{k,j-1}+(s+sumt_i)\times (sumc_i-sumc_j))\)

這樣的狀態複雜度是 \(O(n^3)\) 的。

考慮轉換狀態表示，我們發現當前啟動僅對之後的任務費用有影響，所以我們把費用提前，把啟動多出的費用提前計算，這樣就不用考慮先前的啟動次數了，狀態 \(dp_i\) 的意義也變成到第 \(i\) 個任務，分了若干批的費用再加上由於啟動多出的費用的最小費用。

\(dp_i=\min(dp_j+s\times(sumc_n-sumc_j)+sumt_i\times(sumc_i-sumc_j))\)

複雜度變為 \(O(n^2)\)，可以透過弱化版的 P2365 任務安排。

這時候我們希望能更快找到先前的最小值。化簡時發現當前列舉狀態 \(i\) 會對先前的 \(j\) 貢獻造成影響，所以不能用普通單調佇列維護，同時也無法用資料結構維護。

化簡式子，這裡將 \(sumt\) 和 \(sumc\) 簡寫成 \(t\) 和 \(c\)，

\(dp_{j}=(s+t_i)c_j+dp_i-sc_n-t_ic_i\)

這裡為什麼可以把 \(\min\) 去掉呢，是因為我們把 \(dp_j\) 和 \(c_j\) 看作一次函式中的 \(f(x)\) 和 \(x\)，在平面直角座標系中看成一個個點 \((c_j,dp_j)\) 組成的點集。

這樣子，我們可以發現這是一次函式的形式，並且要使 \(dp_i\) 最小，即讓這個一次函式的截距 \(dp_i-sc_n-t_ic_i\) 最小。所以我們把問題抽象化，取 \(j\) 的過程可以看作這條已知斜率的一次函式的直線不斷向上移動的過程。可以發現，第一次碰到點集中的 \((c_j,dp_j)\) 時，截距最小。

所以問題就變成，維護點集中有價值的點，並快速求出第一次碰到的點。由於點是無序的，我們可以兩兩連線，發現對答案有貢獻的點即為這些直線組成的下凸包。根據下凸包的性質，組成下凸包的直線的斜率不斷增大，我們可以用單調佇列維護不斷增大的斜率，若出現一個點，它與隊尾連線的斜率小於隊尾與它的前一位連線的斜率時，我們彈出隊尾（因為這時隊尾會成為上凸包的頂點）。

在此題中，\(s+sumt_i\) 並不是單調遞增，所以隊頭不一定是最優的，我們需要用二分查詢找到第一個碰到的點。具體的，若佇列中點 \(q_{mid}\) 與 \(q_{mid+1}\) 的連線大於斜率 \(s+sumt_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] 玩具裝箱

經典的斜率最佳化動態規劃問題。

首先考慮樸素做法，此題為典型的分段問題，並且不關心分了幾段，可設狀態 \(dp_{i}\) 表示到第 \(i\) 個玩具，分了若干段的最小費用。轉移為

\(dp_i=\min(dp_j+(i-j-1-\sum\limits_{k=j+1}^jC_k-L)^2)\)

式子的變數太多，化簡式子。可以發現求和部分可以用字首和維護。將 \(sum_i=\sum\limits_{k=1}^iC_k\)，有 \(\sum\limits_{k=j+1}^jC_k=sum_i-sum_j\)。同時我們可以把餘下的 \(i\) 和 \(j\) 併入字首和，設 \(f_i=sum_i+i\)。

式子最後化簡為 \(dp_i=\min\limits_{0\le j< i}(dp_j+(f_i-f_j-1-L)^2)\)

複雜度是 \(O(n^2)\) 的，但很容易發現，我們只需要知道先前的最小值即可。這種式子並不可以用單純的單調佇列維護，因為化簡出來後會帶有類似 \(f_ig_j\) 的量，這說明當前列舉的 \(i\) 是會影響 \(j\) 的貢獻的。對於這樣的式子，我們考慮斜率最佳化。

這次用更為普遍的方法。考慮對於兩個量 \(j_1\) 和 \(j_2\)，有 \(j_1<j_2\)，並且我們假設 \(j_2\) 的貢獻更優，可以得出

\(dp_{j_2}+(f_i-f_{j_2}-1-L)^2<dp_{j_1}+(f_i-f_{j_1}-1-L)^2\)

\(dp_{j_2}+f_i^2-2f_i(f_{j_2}+1+L)+(f_{j_2}+1+L)^2<dp_{j_1}+f_i^2-2f_i(f_{j_1}+1+L)+(f_{j_1}+1+L)^2\)

\(dp_{j_2}+(f_{j_2}+1+L)^2-dp_{j_1}-(f_{j_2}+1+L)^2<2f_i(f_{j_2}-f_{j_1})\)

\(\frac{(dp_{j_2}+(f_{j_2}+1+L)^2)-(dp_{j_1}+(f_{j_2}+1+L)^2)}{f_{j_2}-f_{j_1}}<2f_i\)

將 \(g_i=(f_{i}+1+L)^2\)

\[\frac{(dp_{j_2}+g_{j_2}^2)-(dp_{j_1}+g_{j_1}^2)}{f_{j_2}-f_{j_1}}<2f_i \]

這就是經典的斜率最佳化的形式，即滿足此不等式的 \(j_1\) 與 \(j_2\)，有 \(j_2\) 優於 \(j_1\)。有了這個斜率式，我們就可以用單調佇列維護一個斜率單調增加的點集，因為這個斜率式反映了我們需要維護下凸包。

針對這一題，由於 \(2f_i\) 是單調增加的，所以答案只可能出現在隊首，我們直接利用上面的斜率式維護隊首，滿足就彈出，最後取出隊首更新答案即可。如果 \(2f_i\) 不是單調增加的，我們就只能用二分查詢找到最優決策點了，複雜度會多一個 \(\log\)。

補充：

這裡需要補充一下為什麼對於點集，我們只需要維護上凸包或下凸包即可。

為了方便表述，我們定義 \(K(i,j)\) 表示 \(i,j\) 兩點的斜率。

接下來我們要證明： 如果 \(i,j,k\) 滿足 \(k<j<i\) 且 \(K(i,j)<K(j,k)\)，則 \(j\) 永遠不可能成為最優解。

當 \(K(i,j)\le 2\cdot sum_i\) 時，選擇 \(i\) 優於選擇 \(j\)，排除 \(j\)。
當 \(K(i,j)>2\cdot sum_i\) 時，選擇 \(j\) 優於選擇 \(i\)，又因為 \(K(j,k)>K(i,j)>2\cdot sum_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\) 次，使得分最高。

對於這一類題，我們都可以探索一個性質。因為題目中的分塊是無序的，可能同一分割方法不同分割順序得到的答案不一樣，這不利於我們轉移，但我們可以猜測分割順序是不影響答案的。

設有 \(abc\) 序列，

先分割 \(ab\)，再分割 \(bc\) 的答案是 \(a(b+c)+bc=ab+ac+bc\)

先分割 \(bc\)，再分割 \(ab\) 的答案是 \((a+b)c+ab=ab+ac+bc\)

所以順序不影響答案，我們只需要求出如何分割即可。

從左到右按順序考慮，可設狀態 \(dp_{i,j}\) 為到第 \(i\) 塊切割了 \(j\) 次的最大價值，轉移我們列舉第一次分割（因為貢獻更好計算），同時是最右邊的分割，

\(dp_{i,j}=\max\limits_{1\le k<i}(dp_{k,j-1}+sum_k\times(sum_i-sum_k))\)

求先前最大值，並且帶有 \(sum_ksum_i\) 的量，我們考慮斜率最佳化。首先空間上可以滾動陣列，記 \(g_k=dp_{k,j-1}\)

原式為 \(dp_{i}=\max\limits_{1\le k<i}(g_{k}+sum_k\times(sum_i-sum_k))\)

設 \(k\) 和 \(k^{\prime}\)，\(k<k^{\prime}\)，有 \(k^{\prime}\) 的貢獻優於 \(k\)，即

\(g_{k}+sum_k\times(sum_i-sum_k)<g_{k{\prime}}+sum_{k^{\prime}}\times(sum_i-sum_{k^{\prime}})\)

\(g_k+sum_ksum_i-sum_{k}^2<g_{k^{\prime}}+sum_{k^{\prime}}sum_i-sum_{k^{\prime}}^2\)

\(g_k-sum_k^2-g_{k^{\prime}}+sum_{k^{\prime}}^2<sum_i(sum_{k^{\prime}}-sum_k)\)

\(\frac{(g_k-sum_k^2)-(g_{k^{\prime}}-sum_{k^{\prime}}^2)}{-sum_k-(-sum_{k^{\prime}}^2)}<sum_i\)

這可以看作點集 \((-sum_k,g_k-sum_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;
}

2023 5月 dp做題記錄
2024-04-20
2023 6月 dp做題記錄
2024-04-20
計數 dp 做題記錄（日更）
2024-08-28
做題記錄
2024-09-02
DS做題記錄
2024-10-09
5月做題記錄
2024-05-04
10月做題記錄
2024-10-02
線段做題記錄
2024-10-21
BUUCTF Crypto 做題記錄
2024-07-14
24.07 做題記錄
2024-07-14
8月做題記錄
2024-08-28
「貪心」做題記錄
2024-11-12
ctfshow XXE做題記錄
2024-04-02
推式子的做題記錄
2024-05-27
一些做題記錄
2024-08-11
做題小結 DP訓練
2024-08-09
【做題記錄】ds合集 Part III
2024-10-18
【做題記錄】ds合集 Part I
2024-10-18
【做題記錄】ds合集 Part II
2024-10-18
做題記錄 --- 動態規劃
2024-06-06
動態規劃
2024.6 做題記錄
2024-06-06
Luogu8990 做題記錄
2024-09-06
2024.9 做題記錄
2024-11-15
做題小結 dp訓練6
2024-08-14
2024 Noip 做題記錄（二）
2024-09-23
The 3rd Universal Cup 做題記錄
2024-09-25
2024.10 做題記錄 /
2024-10-06
2024.10 做題記錄
2024-10-10
2024 Noip 做題記錄（五）
2024-10-20
AGC061E 做題記錄
2024-11-06
GC
ARC154E 做題記錄
2024-03-29
ARC147E 做題記錄
2024-07-05
2024.5.31 做題記錄
2024-05-31
ARC149E 做題記錄
2024-09-09
2024 Noip 做題記錄（七）
2024-11-11
2024.11 做題記錄
2024-11-15
ctfshow檔案上傳漏洞做題記錄
2024-03-08
The 3rd Universal Cup 做題記錄 (2)
2024-10-10