线性dp

https://blog.youkuaiyun.com/csyzcyj/article/details/9324057   !!

D - Beautiful Array

题意:

一个长为n的数组,一个x,选择数组的一个区间,该区间里的数*x,使得该数组的最大子序和最大

求最大子序和

解析:

用动态规划解决

dp[i][j]为前i个数再j状态下的最大值

dp[i][0]表示以i为终点还没进入加倍区的最大子段和。
dp[i][1]表示以i为终点在加倍区内的最大子段和。
dp[i][2]表示以i为终点离开加倍区的最大子段和。

ac:

#include <bits/stdc++.h>
#define ll long long
#define MAXN 300005
using namespace std;

ll dp[MAXN][3],ans;

int main()
{
    ll n,x,y;
    scanf("%lld%lld",&n,&x);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&y);
        dp[i][0]=max(0LL,dp[i-1][0]+y);
        dp[i][1]=max(0LL,max(dp[i-1][0],dp[i-1][1])+y*x);
        dp[i][2]=max(0LL,max(dp[i-1][1],dp[i-1][2])+y);
        ans=max(ans,dp[i][0]);
        ans=max(ans,dp[i][1]);
        ans=max(ans,dp[i][2]);
    }
    printf("%lld\n",ans);
    return 0;
}

http://codeforces.com/contest/1221/problem/D

题意:

给你两个数组a[],b[],要1让数组a[i]中,相邻的数组元素相同,可以选择将任意a[i]+1,最多两次,每加1代价为b[i]

求花费最小的代价使得a数组符合条件

解析:

1个位置的元素最多增加2次,我们从前往后推,将所以情况置为inf,其中对dp[1][0],dp[1][1],dp[1][2]初始化

最终答案是min(dp[n][0],min(dp[n][1],dp[n][2]))

递推公式: if(a[i]+k!=a[i-1]+j)
                        dp[i][k]=min(dp[i][k],dp[i-1][j]+k*b[i]);

ac:

#include<bits/stdc++.h>
#define ll long long
#define MAXN 300005
using namespace std;
ll dp[MAXN][4];
int a[MAXN],b[MAXN];

int main()
{
    int q,n;
    scanf("%d",&q);
    while(q--)
    {
        scanf("%d",&n);
        for(int i=0;i<=n;i++)
            dp[i][0]=dp[i][1]=dp[i][2]=1e18+1;
        for(int i=1;i<=n;i++)
            scanf("%d%d",&a[i],&b[i]);
        dp[1][0]=0;
        dp[1][1]=b[1];
        dp[1][2]=b[1]*2;
        for(int i=2;i<=n;i++)
        {
            for(int j=0;j<=2;j++)
            {
                for(int k=0;k<=2;k++)
                {
                    if(a[i]+k!=a[i-1]+j)
                        dp[i][k]=min(dp[i][k],dp[i-1][j]+k*b[i]);
                }
            }
        }
        printf("%lld\n",min(dp[n][0],min(dp[n][1],dp[n][2])));
    }
    return 0;
}

https://codeforces.com/contest/1256/problem/E

题意:

给定一个数组,将数组分未若干份,每份至少有3个元素,每组的权值未其中极大-极小

怎么分使得所以组的权值和最小?输出分组

解析:

如果元素>=6,呢么显然将他们分成至少2组.

递推式:i-j>=0&&dp[i]>dp[i-j]+ee[i].v-ee[i-j+1].v

更新的时候,顺便记录路径

ac:

#include<bits/stdc++.h>
#define MAXN 200005
#define ll long long
using namespace std;
struct node
{
    int v,id;
    friend bool operator <(node a,node b)
    {
        return a.v<b.v;
    }
}ee[MAXN];
int dp[MAXN];
int pre[MAXN];
int ans[MAXN];

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&ee[i].v),ee[i].id=i;
    sort(ee+1,ee+n+1);
    memset(dp,0x3f3f3f,sizeof(dp));
    dp[0]=0;
    pre[0]=0;
    for(int i=3;i<=n;i++)
    {
        for(int j=3;j<=5;j++)
        {
            if(i-j>=0&&dp[i]>dp[i-j]+ee[i].v-ee[i-j+1].v){
                dp[i]=dp[i-j]+ee[i].v-ee[i-j+1].v;
                pre[i]=i-j;
            }
        }
    }
    int tot=0;
    for(int i=n;i>=1;i=pre[i])
    {
        ++tot;
        for(int j=i;j>pre[i];j--)
            ans[ee[j].id]=tot;
    }
    printf("%d %d\n",dp[n],tot);
    for(int i=1;i<n;i++)
        printf("%d ",ans[i]);
    printf("%d\n",ans[n]);
    return 0;
}

https://codeforces.com/contest/1106/problem/E

题意:

爸爸有k个红包,每个红包会[st,ed]时间到达,领取这个红包后,d+1时间才能再次行动,这个红包又w价值

女儿有m次机会阻止爸爸得红包,可以任意选择阻止时间,怎么阻止让爸爸得最小的红包.

解析:

dp[i][j]表示在刚到i时刻,被j次阻止的最小值

我们将红包存入优先队列中,在一个时间里,我们用这个时间段能用的红包来更新答案

有3种情况:

1.无红包可用,dp[i+1][j]=min(dp[i+1][j],dp[i][j]);就不用红包

2.阻止拿红包,dp[i+1][j+1]=min(dp[i+1][j+1],dp[i][j]);

3.不阻止拿红包,dp[top.d+1][j]=min(dp[top.d+1][j],dp[i][j]+top.val);

注意j可以为0,最后结果需要便利dp[n+1][i],d可能等于n,更新后为n+1.dp[i][j]代表的是

ac:

#include<bits/stdc++.h>
#define ll long long
#define MAXN 100005
using namespace std;
struct node
{
    int st,ed,d,val;
    friend bool operator <(node a,node b)
    {
        if(a.val==b.val)
            return a.d<b.d;
        return a.val<b.val;
    }
}ee[MAXN];

bool cmp(node a,node b)
{
    return a.st<b.st;
}
ll dp[MAXN][205];

int main()
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=k;i++)
        scanf("%d%d%d%d",&ee[i].st,&ee[i].ed,&ee[i].d,&ee[i].val);
    sort(ee+1,ee+k+1,cmp);
    for(int i=0;i<MAXN;i++)
        for(int j=0;j<205;j++)
            dp[i][j]=1e18;
    dp[ee[1].st][0]=0;
    int pos=1;
    priority_queue<node> que;
    for(int i=ee[1].st;i<=n;i++)
    {
        while(pos<=k&&ee[pos].st==i)//装入红包
            que.push(ee[pos]),pos++;
        while(que.size()&&que.top().ed<i)//删除无效红包
            que.pop();
        if(que.size()==0){//没有红包,将结果保存到下一个时刻
            for(int j=0;j<=m;j++)
                dp[i+1][j]=min(dp[i+1][j],dp[i][j]);
        }
        else{
            node x=que.top();
            for(int j=0;j<=m;j++){
                dp[x.d+1][j]=min(dp[x.d+1][j],dp[i][j]+x.val);//不阻止拿红包
                dp[i+1][j+1]=min(dp[i+1][j+1],dp[i][j]);      //阻止拿红包
            }
        }
    }
    ll mins=1e18;
    for(int i=0;i<=m;i++)
        mins=min(mins,dp[n+1][i]);
    printf("%lld\n",mins);
    return 0;
}