CF1927G：Paint Charges 题解

G：

题意：（妙妙dp题）给你 a 序列，你可以选 k 个数并决定它们左右方向，每个数可以向左或向右覆盖 \(a_i\) 个数，求覆盖所有位置的最小 k。（n<=100）

---

我一开始想这不是 n 方就解决了吗，设 \(f[i]\) 表示覆盖前 i 个位置的最小花费，然后更新每个位置是否选择。一运行发现过不了样例倒数第3个点：选6向右，选8向左。

由于这个数据正好交叉着选，这种做法在枚举到6时，由于认为6左边不能一次覆盖完，于是把6向右的那些状态也更新成了大于2次的值。

很明显，这个dp的错误之处在于后效性：前面的位置是否全部覆盖，并不只由前面位置和当前位置决定，也可以由某个后面位置的向左操作来覆盖。而当我们枚举到后面位置更新前面时，那个6的位置虽然更新过，但我们也不会再去枚举，这就错失了最优解。

任何序列上dp的题，要保证无后效性，就要满足枚举到后面的操作时不会把前面的状态更新掉，否则更新的路线成了环。

Solution：

正确的做法比较有趣，是 “每次枚举两个数”。

我们之前的dp转移操作有两个，“当前位置 i 向左” 和 “当前位置 i 向右” ，我们把操作增加一个 “当前位置 i 向左，前面位置 j 向右”。

第三种操作可以解决样例中6向右，8向左的情况。把这个操作加上之后，我们就消除了后效性的影响，我们的dp状态也因此改为了 \(f[i][j]\) 表示用前 i 个数字，覆盖 1 到 j 的最小花费。

前两种操作和曾经的思路一样。第三种操作的转移方程就是 \(f[i][j]\) 从 i 向右再枚举两个位置 x 和 y，\(a_x\) 向右 \(a_y\) 向左，并计算 j 的新位置。（\(a_y\) 向左必须要接得上 j）

复杂度 n^3。

反正就，挺妙的说。

ll T;
int n,k,m;
int f[N][N],a[N];

int main() {
    T = read();
    while(T--) {
        chushihua();
        n = read();
        for(int i=1;i<=n;i++) a[i] = read();
        for(int i=0;i<=n;i++) for(int j=0;j<=n;j++) f[i][j] = inf;
        f[0][0] = 0;
        for(int i=1;i<=n;i++) {
            for(int j=0;j<=n;j++) f[i][j] = min(f[i][j],f[i-1][j]);

            for(int j=i;j<=min(n,i+a[i]-1);j++) f[i][j] = min(f[i][j],f[i-1][i-1]+1); // i to right

            int xiao = inf;
            for(int j=max(0,i-a[i]);j<i;j++) xiao = min(xiao,f[i-1][j]);
            for(int j=max(1,i-a[i]+1);j<=i;j++) f[i][j] = min(f[i][j],xiao+1); // i to left

            for(int k=i-1;k>=1;k--) {  // k to right,  i to left
                if(k+a[k]-1<=i) continue;
                if(k<=i-a[i]) break;
                xiao = inf;
                for(int j=max(0,i-a[i]);j<k;j++) xiao = min(xiao,f[k-1][j]);
                for(int j=max(1,i-a[i]+1);j<=min(n,k+a[k]-1);j++) f[i][j] = min(f[i][j],xiao+2);
            }
        }
        cout<<f[n][n]<<endl;
    }
    return 0;
}