【补题计划】Educational Codeforces Round 59 (Rated for Div. 2)

E. Vasya and Binary String
消除连续相同的子段，消除不同长度的子段的收益不同，要求最大化收益。

搜了一下发现有几乎一样的原题，不过收益是l*l
状态设的还是有点厉害啊，DP的本质就是用尽量少的情况把所有情况表示出来复杂度只与状态数和转移复杂度有关了。
这题状态设置的是dp[i][j][k]表示考虑区间[i,j]，且后面有k个与j相同的字符跟在后面（在原序列中不相邻，但是已经消除掉，所以k个字符紧跟区间后面）
对于状态的转移，就是：1、消除这k+1个字符。2、消除区间内后面的某一段，使得更多和j相同的字符连在一起，这样就能考虑到所有的情况。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef unsigned long long ull;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
const int maxn=100+5;
const int inf=0x3f3f3f3f;
const int mod=998244353;

int n;
char str[maxn];
int a[maxn];
ll dp[maxn][maxn][maxn];
bool vis[maxn][maxn][maxn];

ll dfs(int lef,int rig,int k){
    if(lef>rig)return 0;
    if(lef==rig)return a[k+1];
    if(vis[lef][rig][k])return dp[lef][rig][k];
    vis[lef][rig][k]=1;
    ll ret=dfs(lef,rig-1,0)+a[k+1];
    for(int i=lef;i<rig;i++){
        if(str[i]==str[rig]){
            ret=max(ret,dfs(lef,i,k+1)+dfs(i+1,rig-1,0));
        }
    }
    return dp[lef][rig][k]=ret;
}

int main(){
    scanf("%d",&n);
    scanf("%s",str);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    printf("%lld\n",dfs(0,n-1,0));
    return 0;
}

F. Vasya and Endless Credits
每个业务是首先收获a元，然后接下来的k个月内每个月还b元
每个月只能选一个业务，一个业务也只能被选一次（这个限制其实提示了做法）
问什么时候能拿到最多的钱

假设在第x个月的钱最多，且之前每个月都选择了一个业务。那么这些业务的还款次数就是1,2,3,4…（不过有些业务还款月数k较小，已经还掉了）
设ei,j为选择第j个业务，经过i个月时的总金钱数最多，那么ei,j=aj-bj*min(i,kj)
这个题就转换成二分图最大权匹配了，把负权置为0就完成了。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef unsigned long long ull;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
const int maxn=500+5;
const int inf=0x3f3f3f3f;
const int mod=1e9+7;
const ll linf=1e18;

int n;

ll w[maxn][maxn],slack[maxn],x[maxn],y[maxn];
ll prev_x[maxn],prev_y[maxn],son_y[maxn],par[maxn];
ll lx,ly,pop;
void adjust(int v){
    son_y[v]=prev_y[v];
    if(prev_x[son_y[v]]!=-2)adjust(prev_x[son_y[v]]);
}

bool findd(int v){
    ll i;
    for(i=0;i<pop;i++)
        if(prev_y[i]==-1){
            if(slack[i]>x[v]+y[i]-w[v][i]){
                slack[i]=x[v]+y[i]-w[v][i];
                par[i]=v;
            }
            if(x[v]+y[i]==w[v][i]){
                prev_y[i]=v;
                if(son_y[i]==-1){
                    adjust(i);
                    return 1;
                }
                if(prev_x[son_y[i]]!=-1)
                    continue;
                prev_x[son_y[i]]=i;
                if(findd(son_y[i]))
                    return 1;
            }
        }
    return 0;
}

ll km(){
    ll i,j,m;
    for(i=0;i<pop;i++){
        son_y[i]=-1;
        y[i]=0;
    }
    for(i=0;i<pop;i++){
        x[i]=0;
        for(j=0;j<pop;j++)
            x[i]=max(x[i],w[i][j]);
    }
    bool flag;
    for(i=0;i<pop;i++){
        for(j=0;j<pop;j++){
            prev_x[j]=prev_y[j]=-1;
            slack[j]=linf;
        }
        prev_x[i]=-2;
        if(findd(i))continue;
        flag=false;
        while(!flag){
            m=inf;
            for(j=0;j<pop;j++)
                if(prev_y[j]==-1)
                    m=min(m,slack[j]);
            for(j=0;j<pop;j++){
                if(prev_x[j]!=-1)
                    x[j]-=m;
                if(prev_y[j]!=-1)
                    y[j]+=m;
                else
                    slack[j]-=m;
            }
            for(j=0;j<pop;j++)
                if(prev_y[j]==-1&&!slack[j]){
                    prev_y[j]=par[j];
                    if(son_y[j]==-1){
                        adjust(j);
                        flag=true;
                        break;
                    }
                    prev_x[son_y[j]]=j;
                    if(findd(son_y[j])){
                        flag=true;
                        break;
                    }
                }
        }
    }
    ll ans=0;
    for(int i=0;i<pop;i++)ans+=w[son_y[i]][i];
    return ans;
}

ll a[maxn],b[maxn],k[maxn];

int main(){
    scanf("%d",&n);
    pop=n;
    for(int i=0;i<n;i++)scanf("%lld%lld%lld",&a[i],&b[i],&k[i]);
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            ll vv=a[j]-min(k[j],(ll)i)*b[j];
            if(vv<0)vv=0;
            w[i][j]=vv;
        }
    }
    ll ans=km();
    printf("%lld\n",ans);
    return 0;
}

G. Vasya and Maximum Profit
就是选择一个连续子段，使得定义的权值最大。
考虑每个(di+1-di)^2所支配的区间
然后查询区间的最大连续子段和就可以了。
竟然是第一次写最大连续字段和的线段树，需要用全局变量来辅助查找。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef unsigned long long ull;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
const int maxn=3e5+5;
const int inf=0x3f3f3f3f;
const int mod=998244353;

int n,a;
int d[maxn],c[maxn];

struct node{
    ll mm,lef,rig,sum;
}t[maxn*4];
ll L,R,M,S;


void build(int u,int l,int r){
    if(l==r){
        t[u].mm=t[u].lef=t[u].rig=t[u].sum=c[l];
        return;
    }
    int mid=(l+r)>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    t[u].sum=t[u<<1].sum+t[u<<1|1].sum;
    t[u].mm=max(t[u<<1].mm,t[u<<1|1].mm);
    t[u].mm=max(t[u].mm,t[u<<1].rig+t[u<<1|1].lef);
    t[u].lef=max(t[u<<1].lef,t[u<<1].sum+t[u<<1|1].lef);
    t[u].rig=max(t[u<<1|1].rig,t[u<<1].rig+t[u<<1|1].sum);
}

void query(int u,int l,int r,int ql,int qr){
    if(ql<=l&&qr>=r){
        M=max(M,max(t[u].mm,max(R,0LL)+t[u].lef));
        L=max(L,S+t[u].lef);
        R=max(R+t[u].sum,t[u].rig);
        //M=max(M,max(L,R));
        S+=t[u].sum;
        return;
    }
    int mid=(l+r)>>1;
    if(ql<=mid)query(u<<1,l,mid,ql,qr);
    if(qr>mid)query(u<<1|1,mid+1,r,ql,qr);
}

int lef[maxn],rig[maxn];
stack<pii> sta;

int main(){
    scanf("%d%d",&n,&a);
    for(int i=1;i<=n;i++)scanf("%d%d",&d[i],&c[i]);
    for(int i=1;i<=n;i++)c[i]=a-c[i];
    build(1,1,n);
    for(int i=n;i>=2;i--)d[i]-=d[i-1];
    lef[2]=1;sta.push(mp(d[2],2));
    for(int i=3;i<=n;i++){
        while(!sta.empty()&&sta.top().fi<=d[i])sta.pop();
        if(sta.empty())lef[i]=1;
        else lef[i]=sta.top().se;
        sta.push(mp(d[i],i));
    }
    while(!sta.empty())sta.pop();
    rig[n]=n;sta.push(mp(d[n],n));
    for(int i=n-1;i>=2;i--){
        while(!sta.empty()&&sta.top().fi<=d[i])sta.pop();
        if(sta.empty())rig[i]=n;
        else rig[i]=sta.top().se-1;
        sta.push(mp(d[i],i));
    }
    ll ans=0;
    for(int i=1;i<=n;i++)ans=max(ans,(ll)c[i]);
    for(int i=2;i<=n;i++){
        L=R=M=-1e18;
        S=0;
        query(1,1,n,lef[i],rig[i]);
        ans=max(ans,-((ll)d[i]*d[i])+M);
    }
    printf("%lld\n",ans);
    return 0;
}