网络战争（最小割之直接应用+01分数规划）：割的经验以及注意点

网络战争

给出一个带权无向图 $G=(V,E)$，每条边 $e$ 有一个权 $w_e$。

求将点 $s$ 和点 $t$ 分开的一个边割集 $C$，使得该割集的平均边权最小，即最小化：

$$\frac{\sum _{e\in C}{w}_e}{|C|}$$

注意： 边割集的定义与最小割中的割边的集合不同。在本题中，一个边割集是指：将这些边删去之后，$s$ 与 $t$ 不再连通。

输入格式

第一行包含四个整数 $n,m,s,t$，其中 $n,m$ 分别表示无向图的点数、边数。

接下来 $m$ 行，每行包含三个整数 $a,b,w$，表示点 $a$ 和 $b$ 之间存在一条无向边，边权为 $w$。

点的编号从 $1$ 到 $n$。

输出格式

输出一个实数，表示将点 $s$ 和点 $t$ 分开的边割集的最小平均边权。

结果保留两位小数。

数据范围

$2\le n\le 100$,
$1\le m\le 400$,
$1\le w\le 10^7$,
保证 $s$ 和 $t$ 之间连通。

输入样例：

6 8 1 6
1 2 3
1 3 3
2 4 2
2 5 2
3 4 2
3 5 2
5 6 3
4 6 3

输出样例：

2.00

思路

本道题是求分数的最大/最小值，因此就是很典型的01分数规划题。

注意，网络流的割指的是S和T之间的边。

拓展：01分数规划：


因此 01分数规划 可以二分的，因为有二段性。

注意上图，它们是等价关系的，如果你算出来 $\sum (w_e-\lambda )<0$ 的话，那么就说明 $\frac{\sum _{e\in C}{w}_e}{|C|}<0$。

• 因此我们可以把容量减去 $\lambda$。如果容量小于 $0$，则必选，因为题目求的是最小值。

• 而且本道题的割跟网络流的割不一样，因此本道题在网络流种是包含集合内部的边的。

• 对于大于 $0$ 的，尽量不选，因为选了会使得最小值变大。

• 本道题的割是无向边，网络流中的是有向边，因此我们就要类似之前题目建立无向图那样建边。

• 注意1：你要加上负数边 $res$。

代码

//本道题是典型的01分数规划，最后我们化简了就变成了，具体见上面思路
//分数规划的实现通常采用二分

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 210,M = 810,INT = 1e8;
const double eps=1e-7;

int e[M],ne[M],w[M],h[N],idx;
int cur[N],d[N];
int n,m,S,T;
double f[M];

void add(int a,int b,int c){
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
    e[idx]=a,w[idx]=c,ne[idx]=h[b],h[b]=idx++;
}

bool bfs(){
    queue<int>q;
    
    q.push(S);
    
    memset(d,-1,sizeof d);
    
    d[S]=0,cur[S]=h[S];
    
    while(q.size()){
        int t=q.front();
        q.pop();
        
        for(int i=h[t];~i;i=ne[i]){
            int ver=e[i];
            
            if(d[ver]==-1&&f[i]>0){
                d[ver]=d[t]+1;
                cur[ver]=h[ver];
                if(ver==T)return true;
                q.push(ver);
            }
        }
    }
    return false;
}

double find(int u,double lim){
    if(u==T)return lim;
    
    double flow=0;
    
    for(int i=cur[u];~i&&flow<lim;i=ne[i]){
        int ver=e[i];
        
        cur[u]=i;
        
        if(d[ver]==d[u]+1&&f[i]>0){
            double t=find(ver,min(f[i],lim-flow));
            if(t<eps)d[ver]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    return flow;
}

double dinic(double x){
    double res=0;
    
    for(int i=0;i<idx;i+=2){
        if(w[i]<=x){
            res+=w[i]-x;//负数
            f[i]=f[i^1]=0;
        }else f[i]=f[i^1]=w[i]-x;
    }
    
    double r=0,flow;
    
    while(bfs())while(flow=find(S,INT))r+=flow;
    
    return r+res;
    
}

int main(){
    cin>>n>>m>>S>>T;
    
    memset(h,-1,sizeof h);
    
    for(int i=1;i<=m;i++){
    
        int a,b,c;
        cin>>a>>b>>c;
        
        add(a,b,c);
    }
    
    
    double l=0,r=1e7;
    
    while(r-l>eps){
        double mid=(l+r)/2;
        if(dinic(mid)<0)r=mid;
        else l=mid;
    }
    
    printf("%.2lf",r);
    
    return 0;
    
}