bzoj3532 [Sdoi2014]Lis（网络流退流）

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;
}