LOJ #2196「SDOI2014」LIS

直接退流复杂度好优越啊

LOJ #2196

---

题意

一段数列，每个点有点权$ A_i$，删除代价$ B_i$，附加属性$ C_i$

求最小代价使得$ LIS$长度发生变化，且输出一种$ C_i$字典序最小的方案

---

$ Solution$

首先可以求出以每个点结尾的$ LIS$长度数组$ f_i$

按照套路建图

$ i向i+n$连边权为删除代价的边

若$ f_i$=1则$ S向i$连边权为$ INF$的边

若$ f_i$=$ans$则 $i+n向T$连边权为$ INF$的边

然后最小割即是答案

跑一遍最大流即可

考虑输出方案

我们按$ C_i$从小到大枚举每条边，判断这条边是否是割边

若是则选它并删除这条边的贡献

删除之后不需要重新流一遍

只需要从$ i$向$ S$流一遍再从$T$向$ i+n$流一遍去掉贡献

最后再把边的流量上限改成$ 0$即可

复杂度可能是$ O(n^3)$的？

---

$ my \ code$

#include<ctime>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#define INF 1000000000
#define M 1000010
#define rt register int
#define ll long long
using namespace std;
inline ll read(){
    ll x = ; char zf = ; char ch = getchar();
    while (ch != '-' && !isdigit(ch)) ch = getchar();
    if (ch == '-') zf = -, ch = getchar();
    while (isdigit(ch)) x = x *  + ch - '', ch = getchar(); return x * zf;
}
void write(ll y){if(y<)putchar('-'),y=-y;if(y>)write(y/);putchar(y%+);}
void writeln(const ll y){write(y);putchar('\n');}
int i,j,k,m,n,x,y,z,cnt,sum,S,T;
int A[],B[],f[];
int F[M],N[M],L[M],a[M],c[M],dis[M],cur[M],Gap[M];
void add(int x,int y,int z){
    a[++k]=y;c[k]=z;
    if(!F[x])F[x]=k;
    else N[L[x]]=k;
    L[x]=k;
}
int q[M],h,t;
bool BFS(int S,int T){
    h=;q[t=]=S;
    memset(dis,,*sum+);memcpy(cur,F,*sum+);
    dis[S]=;
    while(h<t){
        int x=q[++h];
        for(rt i=F[x];i;i=N[i])if(c[i]&&dis[a[i]]>sum){
            q[++t]=a[i];
            dis[a[i]]=dis[x]+;
            if(a[i]==T)return ;
        }
    }
    return ;
}
int dfs(int x,int y,int flow){
    int used=;
    if(x==y)return flow;
    for(rt i=cur[x];i;i=cur[x]=N[i])if(c[i]&&dis[x]+==dis[a[i]]){
        int v=dfs(a[i],y,min(flow-used,c[i]));
        if(!v)continue;
        c[i]-=v;c[i^]+=v;used+=v;
        if(used>=flow)return used;
    }
    if(!--Gap[dis[x]])dis[S]=sum+;
    ++Gap[++dis[S]];
    return used;
}
int dinic(int S,int T){
    int ans=,now;Gap[]=sum;
    while(BFS(S,T)){
        memset(dis,,sizeof(dis));
        while(now=dfs(S,T,INF))ans+=now;
    }
    return ans;
}
struct node{
    int x,val;
    bool operator <(const node s)const{
        return val<s.val;
    }
}C[];
int ans[],tot;
int main(){
    for(rt QAQ=read();QAQ;QAQ--){
        for(rt i=;i<=sum;i++)F[i]=;
        for(rt i=;i<=k;i++)L[i]=N[i]=;
        n=read();k=;
        for(rt i=;i<=n;i++)A[i]=read();
        for(rt i=;i<=n;i++)B[i]=read();
        for(rt i=;i<=n;i++)C[i].val=read(),C[i].x=i;
        for(rt i=;i<=n;i++)f[i]=;
        for(rt i=;i<=n;i++)
        for(rt j=;j<i;j++)if(A[i]>A[j])f[i]=max(f[i],f[j]+);

        int maxf=*max_element(f+,f+n+);
        for(rt i=;i<=n;i++)add(i,i+n,B[i]),add(i+n,i,);
        sort(C+,C+n+);S=n*+,sum=T=n*+;

        for(rt i=;i<=n;i++)
        for(rt j=i+;j<=n;j++)if(f[j]==f[i]+)add(i+n,j,INF),add(j,i+n,);
        for(rt i=;i<=n;i++)if(f[i]==)add(S,i,INF),add(i,S,);
        for(rt i=;i<=n;i++)if(f[i]==maxf)add(i+n,T,INF),add(T,i+n,);
        write(dinic(S,T));putchar(' ');

        tot=;
        for(rt i=;i<=n;i++)if(!BFS(C[i].x,C[i].x+n)){
            c[C[i].x<<]=c[C[i].x<<|]=;
            dinic(T,C[i].x+n);dinic(C[i].x,S);
            ans[++tot]=C[i].x;
        }
        sort(ans+,ans+tot+);writeln(tot);
        for(rt i=;i<=tot;i++)write(ans[i]),putchar(' ');putchar('\n');
    }
    return ;
}