Codeforces Round #721 (Div. 2) E. Partition Game(线段树优化dp / 决策单调性优化)

最新推荐文章于 2022-11-22 23:15:14 发布

stduy_ing

最新推荐文章于 2022-11-22 23:15:14 发布

阅读量191

点赞数 1

分类专栏： dp

本文链接：https://blog.csdn.net/hddddh/article/details/117213659

版权

dp 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

链接：
E. Partition Game

题意 :
给出一个长度为 n 的数组，要求把它分成 k 段，每一段的权值为当前这一段中每个不同的数最后一次出现的位置与第一次出现的位置之差的和。例如[2 3 2 2 3 1]的权值为 4 - 1 + 5 - 2 + 6 - 6 = 6.现在要求这个权值和的最小值。

思路 :

如果用 dp[i][j]表示把前 i 个数分成 j 段的最小权值，那么不难想到一个 $n^2$ k 复杂度的dp方法 , $f_{i,j}=\min\limits_{k=1}^{i}\{f_{k,j-1}+w_{k,i}\}$ , $w_{k,i}$ 表示[k , i]这一段的权值。这样显然会超时，我们要用线段树来维护 $\min\limits_{k=1}^{i}\{f_{k,j-1}+w_{k,i}\}$ 。
对于题目中要求的权值，我们可以转化为，每个位置的贡献为 $i - l a s t (a [i])$ ,last为这个数上一次出现的位置,例如[2 , 3 , 2 , 2]的权值为 3 - 1 + 4 - 3 = 3.
对于每个f[i][j],我们用线段树维护上述权值 ,对于 $\min\limits_{k=1}^{i}\{f_{k+1,j-1}\}$ 我们在上一层dp时已经求出来了，关键是后半部分 $w_{k,i}$ , 对于当前 i 若线段树上每一个节点的权值已经表示了 $f_{k,j-1} + w_{k+1,i - 1}$ 我们要求 $f_{k,j-1} + w_{k+1,i}$ ,那么就只要算出 i 这个位置对 $w_{k+1,i}$ 的贡献，如果 (last[ a[i] ] , i)属于区间(k+1 , i)即 last(a[i]) $\geq$ k+1 那么就能产生 $i - l a s t (a [i])$ 的贡献,也就是说对于 k $\subset$ 【0 , last[a[i]]),都有一个 i - last(a[i])的贡献，所以做一个线段树区间加就可以维护了。

代码：

#include <iostream>
#include <cstdio>
#include <map>
#include <math.h>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 7;
const int mod=1e9 + 7;
int n,k,a[maxn];
int dp[107][maxn],last[maxn];
int sum[maxn<<2],la[maxn<<2];
void pushup(int rt){
     sum[rt] = min(sum[rt<<1] , sum[rt<<1|1]);
}
void pushdowm(int rt,int l,int r){
    int m=(l + r) >> 1;
    if(la[rt] != 0){
         sum[rt << 1] += la[rt];
         sum[rt << 1 | 1] += la[rt];
         la[rt << 1] += la[rt];
         la[rt << 1 | 1] += la[rt];
         la[rt] = 0;
      }
}
void build(int id , int l,int r,int rt){
     la[rt]=0;
     if(l==r){
        sum[rt] = dp[id][l];
        return ;
     }
     int m=(l + r) >> 1;
     build(id ,l, m, rt << 1);
     build(id , m + 1, r, rt << 1| 1 );
     pushup(rt);
}
void update(int L,int R,int c,int l,int r,int rt){
    if(L <= l && R >= r){
        sum[rt] += c;
        la[rt] += c;
        return ;
    }
    pushdowm(rt,l,r);
    int m=(l + r) >> 1;
    if(L <= m) update(L , R , c , l , m , rt << 1);
    if(R > m) update(L , R , c , m + 1 , r , rt << 1 | 1);
    pushup(rt);
}
int query(int L,int R,int l,int r,int rt){
    int s = mod;
    if(L <= l && R >= r) return sum[rt];
    pushdowm(rt,l,r);
    int m = ( l + r) >> 1;
    if(L <= m) s = min(s , query(L , R , l , m ,rt << 1));
    if(R > m)  s = min(s , query(L , R , m + 1 , r, rt << 1 | 1));
    return s;
}
int main(){
    scanf("%d%d",&n,&k);
    for(int i = 2; i <= n + 1; i ++){
        scanf("%d",&a[i]);
    }
    memset(dp , 0x3f3f3f3f , sizeof(dp));
    dp[0][1] = 0;
    build(0 , 1 , n + 1 , 1);
    for(int j = 1; j <= k; j ++){
        memset(last , 0 , sizeof(last));
        for(int i = 2; i <= n + 1; i ++){
            if(last[a[i]] == 0) last[a[i]] = i;
            update(1 , last[a[i]] - 1 , i - last[a[i]] , 1 , n + 1 , 1);
            dp[j][i] = query(1 , i - 1 , 1 , n + 1 , 1);
            last[a[i]] = i;
        }
        build(j , 1 , n + 1 , 1);
    }
    printf ("%d\n",dp[k][n + 1]);

}

这题还可以用决策单调性优化来写 可以学习一下大佬博客 dp的优化
类似题目：决策单调性优化dp
代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<stack>
#include<set>
#define iss ios::sync_with_stdio(false)
using namespace std;
typedef long long ll;
using namespace std;
typedef long long ll;
const int maxn = 4e4 + 7;
const int mod = 998244353;
int n, k ;
int a[maxn];
ll dp[107][maxn] , ans , cnt[maxn];
int pre[maxn],last[maxn],pos[maxn];
int L,R,now;
ll cal(int l ,int r){
    while(L < l){
        if(last[L] <= R && last[L]){
            ans -= last[L] - L;
        }
        L ++;
    }
    while(L > l){
        L -- ;
        if(last[L] <= R && last[L]){
            ans += last[L] - L;
        }
    }
    while(R > r){
        if(pre[R] >= L && pre[R]){
            ans -= R - pre[R];
        }
        R --;
    }
    while(R < r){
        R ++;
        if(pre[R] >= L && pre[R]){
            ans += R - pre[R];
        }
    }
    return ans;
}
void check(int l,int r,int ll,int rr){
    if(l > r) return ;
    int mid = (l + r) / 2, p  = 0;
    for(int i = ll; i <= min(rr , mid - 1); i ++){
        int val = cal(i + 1 , mid);
        if(dp[now - 1][i] + val < dp[now][mid]){
            dp[now][mid] = dp[now - 1][i] + val;
            p = i;
        }
    }
    check(l , mid - 1 , ll , p);
    check(mid + 1 , r , p , rr);
}
int main (){
    scanf("%d%d",&n,&k);
    for(int i = 1; i <= n; i ++){
        scanf("%d",&a[i]);
    }
    for(int i = 1; i <= n; i ++){
        if(pos[a[i]] == 0){
            pos[a[i]] = i;
        }
        else{
            pre[i] = pos[a[i]];
            last[pos[a[i]]] = i;
            pos[a[i]] = i;
        }
    }
    L = R = 1;
    memset(dp , 0x3f3f3f3f , sizeof(dp));
    now = 1;
    for(int i = 1; i <= n ; i ++){
        dp[now][i] = cal(1 , i);
    }
    for(int i = 2; i <= k; i ++){
        now = i;
        check(1 , n , 1 , n - 1);
    }
    printf ("%lld\n",dp[k][n]);
}