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[];

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

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

 namespace brute{

     struct edge{ int nt,to; }g[];

     int head[],vi[],vis[],top,num;
     ll st[];

     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 ; vi[x]=; 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 ;
     }
     return ;
     }

     il int check(){
     memset(head,,sizeof(head)),num=;
     for (RG int i=;i<=m;++i)
         if (!vis[i]) insert(G[i].u,G[i].v);
     memset(vi,,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]=,dfs(x+,tot+G[x].w);
     vis[x]=,dfs(x+,tot); return;
     }

     int main(){
     dfs(,),sort(st+,st+top+);
     for (RG int i=;i<=top && i<=k;++i) printf("%lld\n",st[i]);
     if (top<k) puts("-1"); return ;
     }

 }

 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[];

     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=,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-],e[T]=e[n]; else e[S]=e[n],e[T]=e[n-];
     n-=,--k,sort(e+,e+n+,cmp),printf("%lld\n",mincut);
     Q.push((data){mincut+e[].a,,});
     for (;k && !Q.empty();--k){
         RG data x=Q.top(),tmp; Q.pop();
         printf("%lld\n",x.val);
         if (x.level<){
         tmp.val=x.val+e[x.i].b;
         tmp.i=x.i,tmp.level=x.level+,Q.push(tmp);
         }
         if (x.i<n && x.level==){
         tmp.val=x.val-e[x.i].a+e[x.i+].a;
         tmp.i=x.i+,tmp.level=,Q.push(tmp);
         }
         if(x.i<n){
         tmp.val=x.val+e[x.i+].a;
         tmp.i=x.i+,tmp.level=,Q.push(tmp);
         }
     }
     if (k) puts("-1"); return ;
     }

 }

 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[*M],num=;

     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,,cap},head[from]=num; return;
     }

     il int bfs(RG int S,RG int T){
         memset(d,,sizeof(d)),d[S]=;
         RG int h=,t=; 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]+,q[++t]=v;
             if (v==T) return ;
             }
         }
         }
         return d[T];
     }

     il ll dfs(RG int x,RG int T,RG int a){
         if (!a || x==T) return a; RG ll flow=,f;
         for (RG int &i=cur[x],v;i;i=g[i].nt){
         v=g[i].to;
         if (d[v]==d[x]+ && g[i].cap>g[i].flow){
             f=dfs(v,T,min(a,g[i].cap-g[i].flow));
             if (!f){ d[v]=; continue; }
             g[i].flow+=f,g[i^].flow-=f;
             flow+=f,a-=f; if (!a) return flow;
         }
         }
         return flow;
     }

     il ll mincut(RG int S,RG int T){
         RG ll cut=;
         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]=;
         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,,sizeof(vis)),memset(in,,sizeof(in)),DFS(S);
         for (RG int i=;i<=m;++i) if (vis[G[i].u] && !vis[G[i].v]) in[i]=;
         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=,lin1=Gra;
         for (RG int i=;i<=m;++i)
         if (must[i]) val+=G[i].w,lin1.g[i<<].cap=;
         else if (stop[i]) lin1.g[i<<].cap=inf;
         val+=lin1.mincut(S,T),lin1.getcut(),ww=inf,id=;
         memset(havs,,sizeof(havs)),memset(havt,,sizeof(havt));
         for (RG int i=;i<=m;++i){
         if (must[i] || stop[i]) continue;
         if (in[i]){
             if (!havs[G[i].u]){
             havs[G[i].u]=,lin2=lin1;
             ds[G[i].u]=lin2.mincut(S,G[i].u);
             }
             if (!havt[G[i].v]){
             havt[G[i].v]=,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=;i<=m;++i){
         Gra.insert(G[i].u,G[i].v,G[i].w);
         Gra.insert(G[i].v,G[i].u,);
     }
     --k,lin1=Gra,printf("%lld\n",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\n",a.val);
         a.must[a.id]=,a.build(); if (a.val<inf) Q.push(a);
         b.stop[b.id]=,b.build(); if (b.val<inf) Q.push(b);
     }
     if (k) puts("-1"); return ;
     }

 }

 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=;i<=m;++i)
     G[i].u=gi(),G[i].v=gi(),G[i].w=gi(),mx=max(mx,G[i].w);
     if (m<=) brute::main();
     else if (n<= && k<= && mx<=) kthcut::main();
     else heap::main();
     return ;
 }