bzoj3882 [Wc2015]K小割

Description

Input

Output

Sample Input

3 3 1 3 100
1 2 3
2 3 4
1 3 5

Sample Output

8
9
12
-1

 

正解：暴搜+堆+最小割。

我觉得这道题真是毒瘤的可以了，正解要写$3$个程序才能过。。

 

$task1$：

$n<=10,m<=20$，暴搜即可。

 

$task2$：

$s$向除了$t$以外其他点连边，其他点向$t$连边。

最小割就是每个点的两条边取最小值然后相加。

考虑用堆来维护$k$小割，我们用类似于$k$短路的方法。

设每个点的两条边分别为$a$，$b$，且$a<=b$。

把每个点分为$3$级，$a$为$0$级，$b$为$1$级，$a+b$为$2$级。

我们作一个差，把$b-a$和$a$存起来，然后按照两个关键字从小到大排序。

我们发现，每个点只要升级就是加上$b-a$或$a$就行了。

那么对于每个点，有$3$种选择：

1.当前点升级；

2.当前点降级，后面那个点升级；

3.后面那个点升级。

然后就很好求出答案了。注意一个细节，就是操作$2$只在当前点为$1$级时考虑。因为从$2$级降到$1$级，后面那个点升级，这样会与操作$3$重复。

 

$task3$：

$n,m,k$不大，没有特殊条件。

我们直接考虑$k$小割如何求，我们得到最小割以后，然后有两种选择：要么是把最小割中的某一条边换成另一边，要么直接加一条边。

用类似$k$短路的做法，我们可以强制选一条边，或强制不选一条边，然后考虑上面两种生成次小割的方法。

直接加一条边就枚举不在割集的最小边加入就行了。

对于第一种情况，我们要删掉割集的一条边，那么显然要使$S,T$到两个割点必须不连通。

那么我们对于这两个割点，对$S,T$跑最小割，求出最小的最小割，然后加上这个最小割就行了。

不过细节巨多，所以我基本上是抄的代码。。

 

//It is made by wfj_2048~
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define inf (1<<28)
#define il inline
#define RG register
#define ll long long

using namespace std;

struct E{ int u,v,w; }G[500010];

int n,m,k,S,T,mx;

il int gi(){
    RG int x=0,q=1; RG char ch=getchar();
    while ((ch<'0' || ch>'9') && ch!='-') ch=getchar();
    if (ch=='-') q=-1,ch=getchar();
    while (ch>='0' && ch<='9') x=x*10+ch-48,ch=getchar();
    return q*x;
}

namespace brute{
    
    struct edge{ int nt,to; }g[22];
    
    int head[12],vi[12],vis[22],top,num;
    ll st[2000010];
    
    il void insert(RG int from,RG int to){
    g[++num]=(edge){head[from],to},head[from]=num; return;
    }
    
    il int find(RG int x,RG int T){
    if (x==T) return 1; vi[x]=1; RG int v;
    for (RG int i=head[x];i;i=g[i].nt){
        v=g[i].to; if (vi[v]) continue;
        if (find(v,T)) return 1;
    }
    return 0;
    }
    
    il int check(){
    memset(head,0,sizeof(head)),num=0;
    for (RG int i=1;i<=m;++i)
        if (!vis[i]) insert(G[i].u,G[i].v);
    memset(vi,0,sizeof(vi)); return !find(S,T);
    }
    
    il void dfs(RG int x,RG ll tot){
    if (x>m){
        if (check()) st[++top]=tot;
        return;
    }
    vis[x]=1,dfs(x+1,tot+G[x].w);
    vis[x]=0,dfs(x+1,tot); return;
    }
    
    int main(){
    dfs(1,0),sort(st+1,st+top+1);
    for (RG int i=1;i<=top && i<=k;++i) printf("%lld
",st[i]);
    if (top<k) puts("-1"); return 0;
    }
    
}

namespace heap{
    
    struct data{
    ll val; int i,level;
    il bool operator < (const data &a) const{ return val>a.val; }
    };
    
    struct node{ ll a,b; }e[200010];
    
    priority_queue <data> Q;
    
    ll mincut;
    
    il int cmp(const node &x,const node &y){
    if (x.a==y.a) return x.b<y.b; return x.a<y.a;
    }
    
    int main(){
    for (RG int i=1,x;i<=m;++i){
        x=G[i].u; if (x==S || x==T) x=G[i].v;
        if (!e[x].a) e[x].a=G[i].w; else{
        e[x].b=G[i].w;
        if (e[x].a<e[x].b) swap(e[x].a,e[x].b);
        mincut+=e[x].b,e[x].a-=e[x].b;
        }
    }
    if (T==n) e[S]=e[n-1],e[T]=e[n]; else e[S]=e[n],e[T]=e[n-1];
    n-=2,--k,sort(e+1,e+n+1,cmp),printf("%lld
",mincut);
    Q.push((data){mincut+e[1].a,1,1});
    for (;k && !Q.empty();--k){
        RG data x=Q.top(),tmp; Q.pop();
        printf("%lld
",x.val);
        if (x.level<2){
        tmp.val=x.val+e[x.i].b;
        tmp.i=x.i,tmp.level=x.level+1,Q.push(tmp);
        }
        if (x.i<n && x.level==1){
        tmp.val=x.val-e[x.i].a+e[x.i+1].a;
        tmp.i=x.i+1,tmp.level=1,Q.push(tmp);
        }
        if(x.i<n){
        tmp.val=x.val+e[x.i+1].a;
        tmp.i=x.i+1,tmp.level=1,Q.push(tmp);
        }
    }
    if (k) puts("-1"); return 0;
    }
    
}

namespace kthcut{

#define M (3005)
#define N (60)
    
    int head[N],cur[N],havs[N],havt[N],ds[N],dt[N],d[N],vis[N],in[M],q[10*M],num=1;
    
    struct Graph{
     
    struct edge{ int nt,to,flow,cap; }g[M];
    
    il void insert(RG int from,RG int to,RG int cap){
        g[++num]=(edge){head[from],to,0,cap},head[from]=num; return;
    }
    
    il int bfs(RG int S,RG int T){
        memset(d,0,sizeof(d)),d[S]=1;
        RG int h=0,t=1; q[t]=S;
        while (h<t){
        RG int x=q[++h],v;
        for (RG int i=head[x];i;i=g[i].nt){
            v=g[i].to;
            if (!d[v] && g[i].cap>g[i].flow){
            d[v]=d[x]+1,q[++t]=v;
            if (v==T) return 1;
            }
        }
        }
        return d[T];
    }
    
    il ll dfs(RG int x,RG int T,RG int a){
        if (!a || x==T) return a; RG ll flow=0,f;
        for (RG int &i=cur[x],v;i;i=g[i].nt){
        v=g[i].to;
        if (d[v]==d[x]+1 && g[i].cap>g[i].flow){
            f=dfs(v,T,min(a,g[i].cap-g[i].flow));
            if (!f){ d[v]=0; continue; }
            g[i].flow+=f,g[i^1].flow-=f;
            flow+=f,a-=f; if (!a) return flow;
        }
        }
        return flow;
    }
    
    il ll mincut(RG int S,RG int T){
        RG ll cut=0;
        while (bfs(S,T)){
        memcpy(cur,head,sizeof(head));
        cut+=dfs(S,T,inf); if (cut>inf) return cut;
        }
        return cut;
    }
    
    il void DFS(RG int x){
        vis[x]=1;
        for (RG int i=head[x];i;i=g[i].nt)
        if (g[i].cap>g[i].flow && !vis[g[i].to]) DFS(g[i].to);
        return;
    }
    
    il void getcut(){
        memset(vis,0,sizeof(vis)),memset(in,0,sizeof(in)),DFS(S);
        for (RG int i=1;i<=m;++i) if (vis[G[i].u] && !vis[G[i].v]) in[i]=1;
        return;
    }
    
    }Gra,lin1,lin2;
    
    struct node{
    
    int must[M],stop[M],id,ww; ll val;
    
    il bool operator < (const node &a) const{ return val>a.val; }
    
    il void build(){
        val=0,lin1=Gra;
        for (RG int i=1;i<=m;++i)
        if (must[i]) val+=G[i].w,lin1.g[i<<1].cap=0;
        else if (stop[i]) lin1.g[i<<1].cap=inf;
        val+=lin1.mincut(S,T),lin1.getcut(),ww=inf,id=0;
        memset(havs,0,sizeof(havs)),memset(havt,0,sizeof(havt));
        for (RG int i=1;i<=m;++i){
        if (must[i] || stop[i]) continue;
        if (in[i]){
            if (!havs[G[i].u]){
            havs[G[i].u]=1,lin2=lin1;
            ds[G[i].u]=lin2.mincut(S,G[i].u);
            }
            if (!havt[G[i].v]){
            havt[G[i].v]=1,lin2=lin1;
            dt[G[i].v]=lin2.mincut(G[i].v,T);
            }
            if (ds[G[i].u]<ww) ww=ds[G[i].u],id=i;
            if (dt[G[i].v]<ww) ww=dt[G[i].v],id=i;
        } else if (G[i].w<ww) ww=G[i].w,id=i;
        }
        val+=ww; return;
    }
    
    }a,b;
    
    priority_queue <node> Q;
    
    int main(){
    for (RG int i=1;i<=m;++i){
        Gra.insert(G[i].u,G[i].v,G[i].w);
        Gra.insert(G[i].v,G[i].u,0);
    }
    --k,lin1=Gra,printf("%lld
",lin1.mincut(S,T));
    a.build(); if (a.val<inf) Q.push(a);
    for (;k && !Q.empty();--k){
        a=b=Q.top(),Q.pop(),printf("%lld
",a.val);
        a.must[a.id]=1,a.build(); if (a.val<inf) Q.push(a);
        b.stop[b.id]=1,b.build(); if (b.val<inf) Q.push(b);
    }
    if (k) puts("-1"); return 0;
    }
         
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("kthcut.in","r",stdin);
    freopen("kthcut.out","w",stdout);
#endif
    n=gi(),m=gi(),S=gi(),T=gi(),k=gi();
    for (RG int i=1;i<=m;++i)
    G[i].u=gi(),G[i].v=gi(),G[i].w=gi(),mx=max(mx,G[i].w);
    if (m<=20) brute::main();
    else if (n<=50 && k<=100 && mx<=65536) kthcut::main();
    else heap::main();
    return 0;
}