BZOJ3532: [Sdoi2014]Lis

BZOJ3532: [Sdoi2014]Lis

Description

 给定序列A，序列中的每一项Ai有删除代价Bi和附加属性Ci。请删除若
干项，使得4的最长上升子序列长度减少至少1，且付出的代价之和最小，并输出方案。
    如果有多种方案，请输出将删去项的附加属性排序之后，字典序最小的一种。

Input

  输入包含多组数据。
    输入的第一行包含整数T，表示数据组数。接下来4*T行描述每组数据。
    每组数据的第一行包含一个整数N，表示A的项数，接下来三行，每行N个整数A1．．An，B1．，Bn，C1．．Cn，满足1 < =Ai，Bi，Ci < =10^9，且Ci两两不同。

Output

    对每组数据，输出两行。第一行包含两个整数S，M，依次表示删去项的代价和与数量；接下来一行M个整数，表示删去项在4中的的位置，按升序输出。

Sample Input

1
6
3 4 4 2 2 3
2 1 1 1 1 2
6 5 4 3 2 1

Sample Output

4 3
2 3 6
解释：删去(A2，43，A6)，(A1，A6)，(A2，43，44，A5)等都是合法的方案，但
{A2，43，A6)对应的C值的字典序最小。

HINT

1 < =N < =700     T < =5

---

题解Here!

LIS最小割：

拆点，所有$X_j$向$Y_j$连权值边；

对于$A[k]<A[j]$，且$f[j]==f[k]+1$的点$Y_k$和$X_j$之间连流量为$MAX$边；

对于$f[j]==1$的点连$S$和$X$的流量为$MAX$边，对于$f[j]==maxn$的点$Y$和$T$的连流量为$MAX$边。

但输出方案要求字典序最小，贪心选择最小的可能存在在最小割中的边。

这里的边是连接同一点$X$和$Y$的边，在最小割上满足且仅满足$ ext{满流}&& ext{不能增广}$两个条件。

选择一条边后要删除它对其他边选择的影响，所以退流：

边的靠$S$端点向$S$退边权流，$T$端点向靠$T$端点退边权流。

退流就是更改源点和汇点，然后倒着跑一次$Dinic$。

附代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<cstring>
#define MAXN 1410
#define MAXM 1000010
#define MAX (1<<30)
using namespace std;
int n,S,T,c;
int head[MAXN],deep[MAXN],id[MAXN];
int top=0,ans[MAXN];
int A[MAXN],B[MAXN],C[MAXN],num[MAXN],dp[MAXN];
struct Edge{
	int next,to;
	long long w;
}a[MAXM<<1];
inline int read(){
	int date=0,w=1;char c=0;
	while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
	while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
	return date*w;
}
inline bool cmp(const int &x,const int &y){
	return C[x]<C[y];
}
inline void add(int u,int v,int w){
	a[c].to=v;a[c].w=w;a[c].next=head[u];head[u]=c++;
	a[c].to=u;a[c].w=0;a[c].next=head[v];head[v]=c++;
}
bool bfs(int s,int t){
	int u,v;
	queue<int> q;
	for(int i=1;i<=T;i++)deep[i]=0;
	deep[s]=1;
	q.push(s);
	while(!q.empty()){
		u=q.front();
		q.pop();
		for(int i=head[u];i;i=a[i].next){
			v=a[i].to;
			if(a[i].w&&!deep[v]){
				deep[v]=deep[u]+1;
				if(v==t)return true;
				q.push(v);
			}
		}
	}
	return false;
}
long long dfs(int x,long long limit,int t){
	if(x==t)return limit;
	int v;
	long long sum,cost=0;
	for(int i=head[x];i;i=a[i].next){
		v=a[i].to;
		if(a[i].w&&deep[v]==deep[x]+1){
			sum=dfs(v,min(a[i].w,limit-cost),t);
			if(sum>0){
				a[i].w-=sum;
				a[i^1].w+=sum;
				cost+=sum;
				if(limit==cost)break;
			}
			else deep[v]=-1;
		}
	}
	return cost;
}
int dinic(int s,int t,long long ans){
	while(bfs(s,t))ans+=dfs(s,MAX,t);
	return ans;
}
bool check(int x){
	return (!(a[id[x]].w||bfs(x,x+n)));
}
void solve(){
	top=0;
	for(int i=1;i<=n;i++)num[i]=i;
	sort(num+1,num+n+1,cmp);
	for(int i=1;i<=n;i++)if(check(num[i])){
		ans[++top]=num[i];
		dinic(T,num[i]+n,B[num[i]]);
		dinic(num[i],S,B[num[i]]);
		a[id[num[i]]].w=a[id[num[i]]^1].w=0;
	}
}
void work(){
	printf("%d ",dinic(S,T,0));
	solve();
	printf("%d
",top);
	sort(ans+1,ans+top+1);
	for(int i=1;i<=top;i++)printf("%d ",ans[i]);
	printf("
");
}
void init(){
	int maxn=0;
	c=2;
	memset(head,0,sizeof(head));
	n=read();
	S=(n<<1)+1;T=(n<<1)+2;
	for(int i=1;i<=n;i++)A[i]=read();
	for(int i=1;i<=n;i++)B[i]=read();
	for(int i=1;i<=n;i++)C[i]=read();
	for(int i=1;i<=n;i++){
		dp[i]=1;
		for(int j=1;j<i;j++)if(A[j]<A[i])dp[i]=max(dp[i],dp[j]+1);
		maxn=max(maxn,dp[i]);
	}
	for(int i=1;i<=n;i++){
		if(dp[i]==1)add(S,i,MAX);
		else{
			if(dp[i]==maxn)add(i+n,T,MAX);
			for(int j=1;j<i;j++)if(A[j]<A[i]&&dp[i]==dp[j]+1)add(j+n,i,MAX);
		}
		id[i]=c;
		add(i,i+n,B[i]);
	}
}
int main(){
	int t=read();
	while(t--){
		init();
		work();
	}
    return 0;
}