hdu5988 Coding Contest（浮点数费用流模板+思维）

最新推荐文章于 2022-08-15 14:30:25 发布

原创最新推荐文章于 2022-08-15 14:30:25 发布 · 置顶 · 667 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#费用流

数据结构--网络流专栏收录该内容

6 篇文章

订阅专栏

本文介绍了一种使用最小费用流算法解决特定概率问题的方法。该问题涉及在一个带权图中找到使得边崩溃概率最小的流量分配方案。通过采用对数转换将乘法运算转化为加法运算，并构建超级源点与汇点来满足各节点的流量需求。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：

http://acm.split.hdu.edu.cn/showproblem.php?pid=5988

题目大意：

n个点，m条边，每个点有两个值，分别表示这个点需要出去的值和需要流进的值。
每条边有一个容量f和费用p。这个费用是一个概率，（0到1之间的浮点数），表示这条边崩溃的概率。
流经每条边第一次的值不会导致崩溃。

题目思路：

费用流求崩溃概率最小的值，因为这里概率只能用乘法，所以我们取log将其变为加法的运算。

建立超级源点和汇点，人多的点是汇入的点，汇入多的人；食物多的点是流入的点，流入多的食物。

还要注意浮点型精度问题。

不要将超级汇点开的过大，莫名其妙的超时了。

代码：

#include <bits/stdc++.h>  
  
using namespace std;  
int n,m;  
int S,T;  
const int MAXN = 10000;  
const int MAXM = 100000;  
const int INF = 2e9;  
const double eps=1e-8;  
struct Edge{  
    int to,next,cap,flow;  
    double cost;  
} edge[MAXM];  
int head[MAXN],tol;  
int pre[MAXN];  
double dis[MAXN];  
bool vis[MAXN];  
int N;  
void init()  //初始化
{  
    N = n+50;  
    tol = 0;  
    memset(head,-1,sizeof(head));
	S=0;//源点 
	T=n+1;  //汇点 ，我在这里开n+10结果超时了，不明觉厉 
}  

void addedge(int u,int v,int cap,double cost)  //建边，cap是容量cost是费用 
{  
    edge[tol].to = v;  
    edge[tol].cap = cap;  
    edge[tol].cost = cost;  
    edge[tol].flow = 0;  
    edge[tol].next = head[u];  
    head[u] = tol++;  
    edge[tol].to = u;  
    edge[tol].cap = 0;  
    edge[tol].cost = -cost;  
    edge[tol].flow = 0;  
    edge[tol].next = head[v];  
    head[v] = tol++;  
}  

bool spfa(int s,int t)  //s是源点 t是汇点 
{  
    queue<int>q;  
    for(int i = 0; i < N; i++)  
    {  
        dis[i] = INF;  
        vis[i] = false;  
        pre[i] = -1;  
    }  
    dis[s] = 0;  
    vis[s] = true;  
    q.push(s);  
    while(!q.empty())  
    {  
  
        int u = q.front();  
        q.pop();  
        vis[u] = false;  
        for(int i = head[u]; i != -1; i = edge[i].next)  
        {  
            int v = edge[i].to;  
            if(edge[i].cap > edge[i].flow &&  
                  dis[v] - dis[u] - edge[i].cost>eps ){  //浮点数加精度判断，否则会T 
                dis[v] = dis[u] + edge[i].cost;  
                pre[v] = i;  
                if(!vis[v]){  
                    vis[v] = true;  
                    q.push(v);  
                }  
            }  
        }  
    }  
    if(pre[t] == -1)return false;  
    else return true;  
}  

int minCostMaxflow(int s,int t,double &cost){  //这里的cost返回的是最小费用
    int flow = 0; //这里的flow返回的最大流 
    cost = 0;  
    while(spfa(s,t)){  
        int Min = INF;  
        for(int i = pre[t]; i != -1; i = pre[edge[i^1].to]){  
            if(Min > edge[i].cap - edge[i].flow)  
                    Min = edge[i].cap - edge[i].flow;  
        }  
        for(int i = pre[t]; i != -1; i = pre[edge[i^1].to]){  
            edge[i].flow += Min;  
            edge[i^1].flow -= Min;  
            cost += edge[i].cost * Min;  
        }  
        flow += Min;  
    }  
    return flow;  //求出来最大流 
}  
  
int a[MAXN],b[MAXN],c[MAXN];  
  
  
int main(){  
    int t;  
    scanf("%d",&t);  
    while(t--){  
        scanf("%d%d",&n,&m);  
        init();  
        for(int i=1;i<=n;i++){  
            scanf("%d%d",&a[i],&b[i]);  
            c[i]=a[i]-b[i];  
        }  
        int u,v,f;  
        double p;  
        for(int i=0;i<m;i++){  
            scanf("%d%d%d%lf",&u,&v,&f,&p);  
            p=-log2(1.0-p);  //转换成log 
            if(f>0) addedge(u,v,1,0.0);  //拆边，因为有一条边的概率是0 ！！！！！！！！！   
            if(f-1>0) addedge(u,v,f-1,p); //正常的边 
        }  
        for(int i=1;i<=n;i++){  
            if(c[i]>0) addedge(S,i,c[i],0); //0是超级源点 n+1是超级汇点 ，建边
            else if(c[i]<0) addedge(i,T,-c[i],0); //  建边
        }  
        double ans=0;  //最小费用
        minCostMaxflow(S,T,ans);  
        ans=pow(2,-ans);  
        printf("%.2f\n",1.0-ans);   //输出摧毁的 
    }  
    return 0;  
}