hdoj 5988 Coding Contest

，题目链接：Coding Contest

题目大意：有n个区域和m条路，每个区域有a[i]个人和b[i]个食物，然后是m条路连接两个区域，这条路容量为cap，这条路断掉的概率为p，第一个经过的时候一定不会断，后面的人有概率p会断，现在需要所有人都吃上饭并且破坏网络的概率最小

题目思路：我们是不能直接算破坏网络的，破坏了会对网络流产生影响，所以我们需要去算不能破坏的概率，我们知道一条路里面都不被破坏的概率是乘法，所以我们可以加一个log来使得乘法变加法，这样我们才能去跑网络流，但是我们的概率需要算最小，因为是最小费用嘛，但是我们求的是最大的不破坏概率，所以我们可以加一个负号，就变成求最大了，所以需要用-log去变换，然后我们跑网络流的时候我们需要对a[i]和b[i]去判断，这个点食物少了，那么这个点是要流出去的，那么我们的超级源点在建边的时候建他少的食物容量就好了，如果这个点的食物多了，他是需要去流出去的，所以连接他和超级汇点就好了，然后跑网络流之后把log里面的东西拿出来就好了，另外注意这里的费用是浮点数，所以注意SPFA里面的写法，记得写一个eps，不然会T掉

#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
const int INF = 0x3f3f3f3f;
const int MaxNode = 205;
const int MaxEdge = 40005;
const double eps = 1e-8;

struct Edge{
    int to,vol,next;
    double cost;
}Edges[MaxEdge];

int Pre[MaxNode],Path[MaxNode],Head[MaxNode],EdgeCount;
double Dist[MaxNode];
bool vis[MaxNode];

void addedge(int u, int v, int vol, double cost){
    Edges[EdgeCount].to = v;
    Edges[EdgeCount].vol = vol;
    Edges[EdgeCount].cost = cost;
    Edges[EdgeCount].next = Head[u];
    Head[u] = EdgeCount++;

    Edges[EdgeCount].to = u;
    Edges[EdgeCount].vol = 0;
    Edges[EdgeCount].cost = -cost;
    Edges[EdgeCount].next = Head[v];
    Head[v] = EdgeCount++;
}

bool Spfa(int s, int t){
    for(int i = 0;i < MaxNode;i++) Dist[i] = INF*1.0;
    memset(Pre, -1, sizeof(Pre));
    memset(vis, false, sizeof(vis));
    Dist[s] = 0.0;
    queue<int>Q;
    vis[s] = true;
    Q.push(s);
    while (!Q.empty()){
        int u = Q.front();
        Q.pop();
        vis[u] = false;
        for (int e = Head[u]; e != -1; e = Edges[e].next){
            int v = Edges[e].to;
            if (Edges[e].vol > 0 && Dist[v] - Dist[u] - Edges[e].cost > eps){
                Dist[v] = Dist[u] + Edges[e].cost;
                Pre[v] = u;
                Path[v] = e;
                if(!vis[v]){
                    vis[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return Pre[t] != -1;
}

double MCMF(int s, int t){
    double cost = 0.0;
    int max_flow = 0;
    int u, v, e;
    while(Spfa(s, t)){
        int f = INF;
        for (u = t; u != s; u = Pre[u]){
            f = min(f, Edges[Path[u]].vol);
        }
        for(u = t; u != s; u = Pre[u]){
            e = Path[u];
            Edges[e].vol -= f;
            Edges[e^1].vol += f;
        }
        max_flow += f;
        cost += (double)f*Dist[t];
    }
    return cost;
}

void init(){
    memset(Head,-1,sizeof(Head));
    EdgeCount = 0;
}

int main(){
    int t,n,m,a[MaxNode],b[MaxNode],c[MaxNode];
    int u,v,cap;
    double p;
    scanf("%d",&t);
    while(t--){
        init();
        scanf("%d%d",&n,&m);
        for(int i = 1;i <= n;i++){
            scanf("%d%d",&a[i],&b[i]);
            c[i] = a[i]-b[i];
        }
        while(m--){
            scanf("%d%d%d%lf",&u,&v,&cap,&p);
            p = -log2(1.0-p);
            if(cap > 0) addedge(u,v,1,0.0);
            if(cap-1 > 0) addedge(u,v,cap-1,p);
        }
        for(int i = 1;i <= n;i++){
            if(c[i] > 0) addedge(0,i,c[i],0.0);
            else if(c[i] < 0) addedge(i,n+1,-c[i],0.0);
        }
        double ans = pow(2,-MCMF(0,n+1));
        printf("%.2f\n",1.0-ans);
    }
    return 0;
}