Description
给定序列A,序列中的每一项Ai有删除代价Bi和附加属性Ci。请删除若干项,使得A的最长上升子序列长度减少至少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个整数,表示删去项在A中的的位置,按升序输出。
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,A3,A6),(A1,A6),(A2,A3,A4,A5)等都是合法的方案,但{A2,A3,A6)对应的C值的字典序最小。
分析:
一开始看到这道题,根本没有思路
我们先不管字典序的问题
我们可以先求出LIS,但是怎么求一个最小的删除花费呢
实际上,这个问题可以转化成在序列中选择一些数,使得形成的最长上升子序列不超过一个值
那么会产生矛盾的就是在同一个上升序列中的数
这个问题可以转化成“最小割最小代价消除矛盾”问题(自己YY的名字)
之前见过一道用网络流求LIS数量的问题
建图:
二分图,
i向i+n连边,流量是b[i](控制流量)
如果f[i]+1=f[j]&&a[i] < a[j],那么连接i+n和j
源点向所有f值等于1的点连边,所有f值等于LIS的点向汇点连边
跑出的最大流就是要求输出的S
一开始我的建图方式:
S和X部之间的连边容量为b,Y向T连边容量为b
X和Y之间的连边是INF
仔细想了想好像这样会被卡掉
(还是因为两边的总容量是2*Σbi,只用重复计算才能保证答案正确,但是这样之后的退流就没法做了)
现在我们就要考虑怎么构造最优解
这里我们需要用到退流算法:
我们建出图来之后,先跑完dinic
之后按照C值从小到大贪心选择
选择的第i个数,如果i—>i+n有流量,而且是满流,说明在最大流中一定有ta
所以我们要删除这条边的影响
如何消除一条边< u,v >的影响?
退流:T向v跑一边最大流,u向S跑一边最大流,这条边流量清零
tip
记录了一下可能发生退流的边的编号
如果整个序列是单调递减的
这种情况不需要特判,只需要在加边的时候:
if (f[i]==1) add(s,i,INF); //二者选其一
else if (f[i]==l) add(i+n,t,INF);
在判断一条边之间是否有流的时候,需要用bfs
(不能直接看边的容量)
实际上退流的作用就在于判断并证明一条边在最大流中的必要性
只有这条边满流,而且一定在最大流中出现时(没有其他增广路能连接原边的两个端点),退流算法才会选择删除这条边
被卡PE,不能输出多余空格
之后又被卡T(原因玄学)
自己在线下造数据,最慢的也是0.1s
一气之下在luogu上交了一个模板(手写队列,多路增广,弧优化都有)
100ms,不算快,最快的20-ms,好像是用ISAP(然而我是不想学的)
#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
const int INF=1e9;
const int N=2000;
int g[N],f[N],a[N],b[N],n,s,t;
struct node{
int x,y,v,nxt;
};
node way[N*100];
int deep[N],st[N],tot=-1,cur[N],ans[N],bh[N],Q[N*10];
struct po{
int c,id;
}c[N];
int cmp(const po &A,const po &B){return A.c<B.c;}
void add(int u,int w,int z)
{
tot++;
way[tot].x=u;way[tot].y=w;way[tot].v=z;way[tot].nxt=st[u];st[u]=tot;
tot++;
way[tot].x=w;way[tot].y=u;way[tot].v=0;way[tot].nxt=st[w];st[w]=tot;
}
void LIS()
{
memset(g,0,sizeof(g));
g[1]=a[1]; f[1]=1;
int l=1;
for (int i=2;i<=n;i++)
{
if (a[i]>g[l]) {
g[++l]=a[i];
f[i]=l;
continue;
}
int r=lower_bound(g+1,g+1+l,a[i])-g;
g[r]=a[i];
f[i]=r;
}
s=0;t=2*n+1;
for (int i=1;i<=n;i++)
{
bh[i]=tot+1; add(i,i+n,b[i]);
//记录一下每个点中这条边的编号,因为之后会枚举这条边构解并进行退流
if (f[i]==1) add(s,i,INF);
else if (f[i]==l) add(i+n,t,INF);
for (int j=i+1;j<=n;j++)
if (f[j]==f[i]+1&&a[i]<a[j]) //
add(i+n,j,INF);
}
}
int bfs(int s,int t)
{
memset(deep,-1,sizeof(deep));
int tou=0,wei=0;
Q[++wei]=s;
deep[s]=1;
while (tou<wei)
{
int now=Q[++tou];
for (int i=st[now];i!=-1;i=way[i].nxt)
if (way[i].v&&deep[way[i].y]==-1)
{
deep[way[i].y]=deep[now]+1;
Q[++wei]=way[i].y;
if (way[i].y==t) return 1;
}
}
return 0;
}
int dfs(int now,int t,int limit)
{
if (now==t||!limit) return limit;
int f,flow=0;
for (int i=st[now];i!=-1;i=way[i].nxt)
if (way[i].v&&deep[way[i].y]==deep[now]+1&&(f=dfs(way[i].y,t,min(limit,way[i].v))))
{
flow+=f;
limit-=f;
way[i].v-=f;
way[i^1].v+=f;
if (!limit) break;
}
return flow;
}
int dinic(int s,int t)
{
int ans=0;
while (bfs(s,t))
ans+=dfs(s,t,INF);
return ans;
}
void solve()
{
int cnt=0;
sort(c+1,c+1+n,cmp);
for (int i=1;i<=n;i++)
{
int now=c[i].id;
int u=now,w=now+n;
if (bfs(u,w)) continue; //判断是否还连通(是否有流)
ans[++cnt]=now;
dinic(t,w); dinic(u,s); //退流
way[bh[now]].v=0; way[bh[now]^1].v=0; //删边
}
sort(ans+1,ans+1+cnt);
printf("%d\n",cnt);
for (int i=1;i<=cnt;i++) printf("%d%c",ans[i],(i==cnt)? '\n':' ');
}
int main()
{
int T;
scanf("%d",&T);
while (T--)
{
memset(st,-1,sizeof(st)); tot=-1;
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].c),c[i].id=i;
LIS();
printf("%d ",dinic(s,t));
solve();
}
return 0;
}