【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

Source

Round 1 Day 2

---

忽略字典序的话，拆点最小割，很简单

加上那个限制，可以考虑从C的值小到大贪心选，选一个边把它删去加入答案，并且消除当前边的影响。

如何消除一条边< u,v >的影响？退流。e向v跑一边最大流，u向s跑一边最大流，然后这条边流量清零就行了。

你问我为什么TLE？数组开大了memset超时啊233

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;

typedef long long LL;
const int SZ = 10000;
const int INF = 1000000010;

int a[SZ],b[SZ];

struct haha{
    int c,id;
}c[SZ];

bool cmp(haha a,haha b)
{
    return a.c < b.c;
}

int head[SZ],nxt[1000010],tot = 1,n;

struct edge{
    int t,d;
}l[1000010];

void build(int f,int t,int d)
{
    l[++ tot].t = t;
    l[tot].d = d;
    nxt[tot] = head[f];
    head[f] = tot;
}

void insert(int f,int t,int d)
{
    build(f,t,d); build(t,f,0);
}

int deep[SZ];
queue<int> q;

bool bfs(int s,int e)
{
    memset(deep,0,sizeof(deep));
    while(q.size()) q.pop();
    q.push(s);
    deep[s] = 1;
    while(q.size())
    {
        int u = q.front(); q.pop();
        for(int i = head[u];i;i = nxt[i])
        {
            int v = l[i].t;
            if(l[i].d && !deep[v])
            {
                deep[v] = deep[u] + 1,q.push(v);
                if(v == e) return true;
            }
        }
    }
    return false;
}

int dfs(int u,int flow,int e)
{
    if(flow == 0 || u == e) return flow;
    int rest = flow;
    for(int i = head[u];i;i = nxt[i])
    {
        int v = l[i].t;
        if(l[i].d && deep[v] == deep[u] + 1)
        {
            int f = dfs(v,min(l[i].d,rest),e);
            if(f > 0)
            {
                l[i].d -= f; l[i ^ 1].d += f;
                rest -= f; if(rest == 0) break;
            }
            else deep[v] = 0;
        }
    }
    return flow - rest;
}

int dinic(int s,int e)
{
    int ans = 0;
    while(bfs(s,e)) ans += dfs(s,INF,e);
    return ans;
}

int dp[1010];

int DP()
{
    int ans = 0;
    for(int i = 1;i <= n;i ++)
    {
        dp[i] = 1;
        for(int j = 1;j < i;j ++)
            if(a[i] > a[j])
                dp[i] = max(dp[i],dp[j] + 1);
        ans = max(ans,dp[i]);
    }
    return ans;
}

void build_graph(int s,int e)
{
    int maxlen = DP();
    for(int i = 1;i <= n;i ++) insert(i,i + n,b[i]);
    for(int i = 1;i <= n;i ++)
        if(dp[i] == 1)
            insert(s,i,INF);
        else if(dp[i] == maxlen)
            insert(i + n,e,INF);
    for(int i = 1;i <= n;i ++)
        for(int j = 1;j < i;j ++)
            if(dp[i] == dp[j] + 1 && a[i] > a[j])
                insert(j + n,i,INF);        
}

int ans[100010];

void init()
{
    memset(head,0,sizeof(head));
    tot = 1;
}

int main()
{
    freopen("3532.in","r",stdin);
    freopen("3532.out","w",stdout);
    int T;
    scanf("%d",&T);
    while(T --)
    {
        init();
        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;
        int s = n * 2 + 1,e = n * 2 + 2;
        build_graph(s,e);
        int maxflow = dinic(s,e),tot = 0;
        sort(c + 1,c + 1 + n,cmp);
        for(int i = 1;i <= n;i ++)
        {
            int now = c[i].id;
            int u = now,v = now + n;
            if(bfs(u,v)) continue;
            ans[++ tot] = now;
            dinic(e,v); dinic(u,s);
            l[now * 2].d = l[now * 2 + 1].d = 0;
        }
        sort(ans + 1,ans + 1 + tot);
        printf("%d %d\n",maxflow,tot);
        for(int i = 1;i <= tot;i ++)
            printf("%d%c",ans[i],i == tot ? '\n' : ' ');
    }
    return 0;
}
/*
1

6

3 4 4 2 2 3

2 1 1 1 1 2

6 5 4 3 2 1

*/