luogu P3308 [SDOI2014]LIS(最小字典序最小割)

luogu P3308 [SDOI2014]LIS(最小字典序最小割)

题目大意

给出一段序列其中点都有a,b,c三种权值，每次想要删除一个数，则要花费其b权值的花费，要求花费尽可能少的b权值，删除一些数字，使得序列对于a权值的最长上升子序列缩短，当存在多种方案时，输出删除的数字的c排序之后字典序尽可能小的那个方案

解题思路

先处理出序列的最长上升子序列的长度，再对每个序列中每个可以作为最长上升子序列终点的点向汇点连接容量inf的边，源点向每个作为终点时LIS为1的点连inf边，所有的点拆成两个之间连接容量为b的边，所有的点向dp值为其本身dp值+1的点连边，跑dinic即可得到最小的费用。接下来为了得到字典序最小的答案。首先对c做一次排序，接下来根据c从小到大，检测每个点拆点后的两个点的连通性，假如不连通则说明是最小割集中的点，为此将其假如答案，并删去这条边，并删去其影响，即对拆点后的后面的一个点向汇点做一遍dinic退流，而前面那个点向起点做一遍dinic退流，最后再将这个点的边以及其反向边容量置为0即可

AC代码

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=2005;
const int maxm=5e6+5;
const LL inf=1e12;
struct Edge{
    int to,nxt;
	LL cap,flow;
}edge[maxm];
int tol;
int head[maxn];
inline void init(){
    tol=2;
    memset(head,-1,sizeof(head));
}
inline void AddEdge(int u,int v,LL w,int rw=0){
    edge[tol].to=v;edge[tol].cap=w;edge[tol].flow=0;
    edge[tol].nxt=head[u];head[u]=tol++;
    edge[tol].to=u;edge[tol].cap=rw;edge[tol].flow=0;
    edge[tol].nxt=head[v];head[v]=tol++;
}
int Q[maxn];
int dep[maxn],cur[maxn],sta[maxn];
inline bool bfs(int s,int t,int n){
    int front=0,tail=0;
    memset(dep,-1,sizeof(dep[0])*(n+1));
    dep[s]=0;
    Q[tail++]=s;
    while(front<tail){
        int u=Q[front++];
        for(register int i=head[u];i!=-1;i=edge[i].nxt){
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&dep[v]==-1){
                dep[v]=dep[u]+1;
                if(v==t) return true;
                Q[tail++]=v;
            }
        }
    }
    return false;
}
inline LL dinic(int s,int t,int n){
    LL maxflow=0;
    while(bfs(s,t,n)){
        for(register int i=0;i<n;++i) cur[i]=head[i];
        int u=s,tail=0;
        while(cur[s]!=-1){
            if(u==t){
                LL tp=inf;
                for(register int i=tail-1;i>=0;--i)
                {
                    tp=min(tp,edge[sta[i]].cap-edge[sta[i]].flow);
                }
                maxflow+=tp;
                for(register int i=tail-1;i>=0;--i){
                    edge[sta[i]].flow+=tp;
                    edge[sta[i]^1].flow-=tp;
                    if(edge[sta[i]].cap-edge[sta[i]].flow==0) tail=i;
                }
                u=edge[sta[tail]^1].to;
            }
            else if(cur[u]!=-1&&edge[cur[u]].cap>edge[cur[u]].flow&&dep[u]+1==dep[edge[cur[u]].to]){
                sta[tail++]=cur[u];
                u=edge[cur[u]].to;
            }
            else{
                while(u!=s&&cur[u]==-1) u=edge[sta[--tail]^1].to;
                cur[u] = edge [cur[u]].nxt;
            }
        }
    }
    return maxflow;
}
struct C{
	int v,id;
	C(){}
	C(int v,int id):v(v),id(id){}
	friend bool operator<(C x,C y)
	{
		return x.v<y.v;
	}
}c[705];
int a[705],b[705];
int n;
int dp[705];
bool vis[705];
int s,t;
inline void build()
{
	init();
	for(int i=1;i<=n;i++) AddEdge(i,i+n,b[i]);
	fill(dp+1,dp+1+n,1);
	int lg=0;
	s=0,t=2*n+1;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<i;j++) if(a[i]>a[j])dp[i]=max(dp[j]+1,dp[i]);
		lg=max(lg,dp[i]);
	}
	memset(vis,0,sizeof(vis));
	for(int i=1;i<=n;i++)
	{
		if(dp[i]==lg) 
		AddEdge(i+n,t,inf);
		if(dp[i]==1) AddEdge(s,i,inf);
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j]&&dp[i]==dp[j]+1) AddEdge(j+n,i,inf);
		}
	}
}
int ansv[705],tot;
int32_t main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		for(int i=1;i<=n;i++) scanf("%d",&a[i]);
		for(int i=1;i<=n;i++) scanf("%d",&b[i]);
		for(int i=1;i<=n;i++) scanf("%d",&c[i].v),c[i].id=i;
		build();
		sort(c+1,c+1+n);
		LL ans=dinic(s,t,t+1);
		printf("%lld ",ans);
		tot=0;
		int tans;
		for(register int i=1;i<=n;i++)
		{
			if(!bfs(c[i].id,c[i].id+n,t+1)) 
			{
				ansv[++tot]=c[i].id;
				dinic(t,c[i].id+n,t+1);
				dinic(c[i].id,s,t+1);
				edge[2*c[i].id].cap=edge[2*c[i].id+1].cap=0;
			}
		}
		sort(ansv+1,ansv+1+tot);
		printf("%d\n",tot);
		for(register int i=1;i<=tot;++i)
		{
			printf("%d ",ansv[i]);			
		}
		puts("");
	}
}