ZOJ2676 Network Wars(网络流 + 01分数规划)

题意：
$\ \ \ \ $$n$个点$m$条边的无向图，每条边有一个权值$c_i$，要找$1$到$n$的一个割集$C$，使得：

$$\frac{\sum \limits_{e \in C} w_e}{|C|}$$
最小，求这些割边。
思路：
$\ \ \ \ $看的胡伯涛的论文，就是$0-1$分数规划的应用，假设答案为ans，那么有$\sum \limits_{e \in C} w_e = ans * |C|$，移项之后得到$\sum \limits_{e \in C} (w_e - ans) = 0$，可以二分$ans$，令每条边的权值为$c_i-ans$，要最小化该和式，首先权值小于$0$的边要选择，剩余的就是权值大于$0$的边， 可以用网络流，设立每条边的权值为$c_i-ans$，一次网络流之后得到一个最大流，这样两个结果加起来就是本次二分结果的$\sum \limits_{e \in C} (w_e - ans)$的最小值，如果不为$0$继续二分就好了。边集的选择，知道$ans$后，$c_i-ans<0$的一定要选，剩余的可以从$1$开始$dfs$一下，只有非满流边才可以走，那么一条边如果有一端点拜访过一个端点没有拜访过，那么该边就是一个选择，
$\ $

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 4e2 + 10;
const int INF = 1e9;
const double eps = 1e-8;
using namespace std;

struct st {
    int to, re, id;
    double cap;
    st() {}
    st(int t, double c, int fl, int id) :
        to(t), cap(c), re(fl), id(id) {}
};
int n, m, s, t;
vector<st> G[maxn];
int used[maxn], lv[maxn];
int it[maxn], from[maxn], to[maxn];
double cost[maxn];

void add(int f, int t, double c, int id) {
    G[f].push_back(st(t, c, G[t].size(), id));
    G[t].push_back(st(f, 0, G[f].size() - 1, -1));
}

void bfs() {
    memset(lv, -1, sizeof(lv));
    queue<int> q; lv[s] = 0; q.push(s);
    while(!q.empty()) {
        int u = q.front(); q.pop();
        for(int i = 0; i < G[u].size(); i++) {
            st &e = G[u][i];
            if(e.cap > eps && lv[e.to] < 0) {
                lv[e.to] = lv[u] + 1;
                q.push(e.to);
            }
        }
     }
}

double dfs(int v, int t, double f) {
    if(v == t) return f;
    for(int &i = it[v]; i < G[v].size(); i++) {
        st &e = G[v][i];
        if(e.cap > eps && lv[v] < lv[e.to]) {
            double d = dfs(e.to, t, min(f, e.cap));
            if(d > eps) {
                e.cap -= d;
                G[e.to][e.re].cap += d;
                return d;
            }
        }
    }
    return 0;
}

double maxflow() {
    double f = 0;
    while(1) {
        bfs();
        if(lv[t] < 0) return f;
        memset(it, 0, sizeof(it));
        double fl;
        while((fl = dfs(s, t, INF)) > eps) f += fl;
    }
}

double solve(double key, vector<int> &vec) {
    s = 0; t = n + 1;
    double ans = 0;
    vec.clear();
    for(int i = 0; i < n + 5; i++) G[i].clear();
    for(int i = 1; i <= m; i++) {
        if(cost[i] - key <= eps) { ans += cost[i] - key; vec.push_back(i); }
        else {
            add(from[i], to[i], cost[i] - key, i);
            add(to[i], from[i], cost[i] - key, i);
        }
    }
    add(s, 1, INF, -1); add(n, t, INF, 1);
    ans += maxflow();
    return ans;
}

int vis[maxn];
void dfs(int x) {
    vis[x] = 1;
    for(int i = 0; i < G[x].size(); i++) {
        st now = G[x][i];
        int nxt = now.to;
        if(now.cap < eps || vis[nxt]) continue;
        dfs(nxt);
    }
}

int main() {
    while(scanf("%d %d", &n, &m) != EOF) {
        memset(vis, 0, sizeof vis);
        for(int i = 1; i <= m; i++) scanf("%d %d %lf", &from[i], &to[i], &cost[i]);
        int tt = 100;
        double l = 0, r = 100000000, mid;
        vector<int> ans;
        while(tt--) {
            mid = (l + r) / 2;
            double as = solve(mid, ans);
            if(fabs(as) < eps) break;
            if(as > 0) l = mid;
            else r = mid;
        }
        dfs(1);
        for(int i = 1; i <= m; i++) {
            if(cost[i] - mid <= eps) continue;
            if(vis[from[i]] + vis[to[i]] == 1) ans.push_back(i);
        }
        sort(ans.begin(), ans.end());
        cout << ans.size() << endl;
        for(int i = 0; i < ans.size(); i++) {
            if(i + 1 < ans.size()) cout << ans[i] << " ";
            else cout << ans[i] << endl;
        }
        cout << endl;
    }
    return 0;
}