[SDOI2014]LIS

Posted 2021-11-11 asuldb

这道题还是非常好的

首先第一问可以让我们联想到某网络流二十四题里的一道题，发现建图方式应该和这道题差不多啊

所以首先跑一遍\(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)\)是最小割的可行边需要满足两个条件

1. \((u,v)\)满流

2. 不存在从\(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;
}