[SDOI2014]LIS
这道题还是非常好的
首先第一问可以让我们联想到某网络流二十四题里的一道题，发现建图方式应该和这道题差不多啊
所以首先跑一遍\(dp\)，求出\(dp[i]\)表示\(i\)位置结束的\(LIS\)长度，设最长的\(LIS\)长度为\(M\)
我们考虑一下如果想要使得这个\(M\)减小要割掉一些点，显然我们割掉的是点，所以将每一个点\(i\)拆成\(i\)和\(i'\)两个点，之后在\(i\)和\(i'\)之间连一条容量为\(b_i\)的边，表示割掉这个点的代价是\(b_i\)
之后我们将那些\(dp[i]=M\)点的\(i'\)向\(T\)连边，\(S\)向\(dp[i]=1\)的\(i\)连边，容量都是\(inf\)，表示这些边割不掉
之后跑一遍最小割就是第一问的答案了
考虑第二问，我们要构造一组字典序最小的最小割
首先有一个前置知识，就是最小割的可行边与必须边
一条边是最小割的可行边，就表明这条边存在于某一种最小割中
一条边\((u,v)\)是最小割的可行边需要满足两个条件
-
\((u,v)\)满流
-
不存在从\(u\)到\(v\)的增广路径
我们只需要看看从\(u\)到\(v\)能不能\(bfs\)就好了
所以我们的答案就一定是最小割的可行边，我们开始构造这个最小割集
我们按照边的权值排序，如果一条边是可行边，我们就需要把这条边加入答案
同时选择了这条边的话我们就得排除和这条边等价的那些边的影响
这条边等价的那些边显然会存在于\(S\)到\(u\)和\(v\)到\(T\)的路径上，我们只需要从\(u\)向\(S\)，\(T\)向\(v\)退流,把那些满流的边的流量清掉
退流的话跑一遍\(dinic\)就好了
同时注意优化一下\(dinic\)的常数，有一点卡常
代码
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#define re register
#define maxn 1505
#define LL long long
#define inf 999999999
inline int max(int a,int b){return a>b?a:b;}
inline int min(int a,int b){return a<b?a:b;}
inline int read()
{
char c=getchar();int x=0;while(c<'0'||c>'9') c=getchar();
while(c>='0'&&c<='9') x=(x<<3)+(x<<1)+c-48,c=getchar();return x;
}
struct node{int a,b,c,rk;}g[maxn];
inline int cmp(node A,node B) {return A.c<B.c;}
struct E{int v,nxt,w,f;}e[maxn*maxn];
int n,num=1,S,T,Test;
int ans[maxn],cnt,id[maxn],vis[maxn];
int d[maxn],dp[maxn],head[maxn],cur[maxn],in[maxn],out[maxn];
inline void add(int x,int y,int z) {e[++num].v=y;e[num].nxt=head[x];head[x]=num;e[num].w=z;}
inline void C(int x,int y,int z) {add(x,y,z),add(y,x,0);}
inline int check(int s,int t)
{
std::queue<int> q;
memset(vis,0,sizeof(vis));
q.push(s);vis[s]=1;
while(!q.empty())
{
int k=q.front();q.pop();
if(k==t) return 1;
for(re int i=head[k];i;i=e[i].nxt)
if(!vis[e[i].v]&&e[i].w>e[i].f) q.push(e[i].v),vis[e[i].v]=1;
}
return 0;
}
inline int BFS(int s,int t)
{
std::queue<int> q;
memcpy(cur,head,sizeof(head));
memset(d,0,sizeof(d));
d[s]=1,q.push(s);
while(!q.empty())
{
int k=q.front();q.pop();
for(re int i=head[k];i;i=e[i].nxt)
if(!d[e[i].v]&&e[i].w>e[i].f)
{
d[e[i].v]=d[k]+1;
if(e[i].v==t) return 1;
q.push(e[i].v);
}
}
return d[t];
}
int dfs(int x,int now,int t)
{
if(x==t||!now) return now;
int flow=0,ff;
for(re int& i=cur[x];i;i=e[i].nxt)
if(d[e[i].v]==d[x]+1)
{
ff=dfs(e[i].v,min(now,e[i].w-e[i].f),t);
if(ff<=0) continue;
now-=ff,flow+=ff;
e[i].f+=ff,e[i^1].f-=ff;
if(!now) break;
}
return flow;
}
int main()
{
Test=read();
while(Test--)
{
n=read();cnt=0;num=1;memset(head,0,sizeof(head));
for(re int i=1;i<=n;i++) g[i].a=read(),dp[i]=1;
for(re int i=1;i<=n;i++) g[i].b=read(),g[i].rk=i;
for(re int i=1;i<=n;i++)
for(re int j=1;j<i;j++) if(g[j].a<g[i].a) dp[i]=max(dp[j]+1,dp[i]);
int tot=0;
for(re int i=1;i<=n;i++) tot=max(tot,dp[i]);
T=0;
for(re int i=1;i<=n;i++) in[i]=++T;
for(re int i=1;i<=n;i++) out[i]=++T;++T;
for(re int i=1;i<=n;i++) C(in[i],out[i],g[i].b),id[i]=num;
for(re int i=1;i<=n;i++) if(dp[i]==1) C(S,in[i],inf);
for(re int i=1;i<=n;i++) if(dp[i]==tot) C(out[i],T,inf);
for(re int i=1;i<=n;i++)
for(re int j=1;j<i;j++) if(g[j].a<g[i].a&&dp[j]+1==dp[i]) C(out[j],in[i],inf);
tot=0;
while(BFS(S,T))
tot+=dfs(S,inf,T);
for(re int i=1;i<=n;i++) g[i].c=read();
printf("%d ",tot);
std::sort(g+1,g+n+1,cmp);
for(re int i=1;i<=n;i++)
{
int k=g[i].rk;
if(check(in[k],out[k])) continue;
ans[++cnt]=k;
while(BFS(T,out[k])) dfs(T,inf,out[k]);
while(BFS(in[k],S)) dfs(in[k],inf,S);
e[id[k]].w=e[id[k]^1].w=0;
e[id[k]].f=e[id[k]^1].f=0;
}
printf("%d\n",cnt);
std::sort(ans+1,ans+cnt+1);
for(re int i=1;i<=cnt;i++) printf("%d ",ans[i]);putchar(10);
}
return 0;
}
