HDU 6118 度度熊的交易计划（最小费用可行流）

Description

度度熊参与了喵哈哈村的商业大会，但是这次商业大会遇到了一个难题：

喵哈哈村以及周围的村庄可以看做是一共由$n$个片区，$m$条公路组成的地区。

由于生产能力的区别，第$i$个片区能够花费$a[i]$元生产$1$个商品，但是最多生产$b[i]$个。

同样的，由于每个片区的购买能力的区别，第$i$个片区也能够以$c[i]$的价格出售最多$d[i]$个物品。

由于这些因素，度度熊觉得只有合理的调动物品，才能获得最大的利益。

据测算，每一个商品运输$1$公里，将会花费$1$元。

那么喵哈哈村最多能够实现多少盈利呢？

Input

本题包含若干组测试数据。
每组测试数据包含：
第一行两个整数$n,m$表示喵哈哈村由$n$个片区、$m$条街道。
接下来$n$行，每行四个整数$a[i],b[i],c[i],d[i]$表示的第$i$个地区，能够以$a[i]$的价格生产，最多生产$b[i]$个，以$c[i]$的价格出售，最多出售$d[i]$个。
接下来$m$行，每行三个整数$u[i],v[i],k[i]$，表示该条公路连接$u[i],v[i]$两个片区，距离为$k[i]$

可能存在重边，也可能存在自环。

满足:
$1\le n\le 500$,
$1\le m\le 1000$,
$1\le a[i],b[i],c[i],d[i],k[i]\le 1000$,
$1\le u[i],v[i]\le n$

Output

输出最多能赚多少钱。

Sample Input

2 1
5 5 6 1
3 5 7 7
1 2 1

Sample Output

23

Solution

将数量限制体现在流量上，把花费变成正代价，把利润变成负代价，那么问题转化为一个最小费用可行流问题

1.源点向$i$点连容量为$b[i]$费用为$a[i]$的边

2.$i$点向汇点连容量为$d[i]$费用为$-c[i]$的边

3.对于边$u\leftrightarrow v$，从$u$向$v$和从$v$向$u$连容量为无穷费用为 k <script type="math/tex" id="MathJax-Element-41">k</script>的边

Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
#define maxn 555
#define maxm 11111
#define INF 0x3f3f3f3f
int head[maxn],d[maxn],s,e,no,vis[maxn],pre[maxn];//s为源点,e为汇点 
struct point
{
    int u,v,flow,next,cost;
    point(){};
    point(int _u,int _v,int _next,int _flow,int _cost)
    {
        u=_u,v=_v,next=_next,flow=_flow,cost=_cost;
    } 
}p[maxm];
void add(int x,int y,int z,int c)//从x到y建一条容量为z,花费为c的边 
{
    p[no]=point(x,y,head[x],z,c);   
    head[x]=no++;
    p[no]=point(y,x,head[y],0,-c);  
    head[y]=no++;
}
void init()//初始化 
{
    memset(head,-1,sizeof(head));
    no=0;
}
bool spfa()
{
    int i,x,y;
    queue<int>q;
    memset(d,0x3f,sizeof(d));
    memset(vis,false,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    d[s]=0;   
    vis[s]=true;  
    q.push(s);
    while(!q.empty())
    {
        x=q.front();  
        q.pop();    
        vis[x]=false;
        for(i=head[x];i!=-1;i=p[i].next)
        {
            if(p[i].flow&&d[y=p[i].v]>d[x]+p[i].cost)
            {
                d[y]=d[x]+p[i].cost;   
                pre[y]=i;
                if(vis[y])continue;
                vis[y]=true;  
                q.push(y);
            }  
        }  
    }
    return d[e]!=d[e+1];
}
int mcmf()//最小费用可行流
{
    int mincost=0,maxflow=0,minflow,i;
    while(spfa())
    {
        if(d[e]>=0)break;
        minflow=INF;
        for(i=pre[e];i!=-1;i=pre[p[i].u])
            minflow=min(minflow,p[i].flow);
        for(i=pre[e];i!=-1;i=pre[p[i].u])
        {
            p[i].flow-=minflow;
            p[i^1].flow+=minflow;
        } 
        mincost+=d[e]*minflow; 
        maxflow+=minflow;
    }
    return mincost;//最小费用
}
int n,m;
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        s=0,e=n+1;
        init();
        for(int i=1;i<=n;i++)
        {
            int a,b,c,d;
            scanf("%d%d%d%d",&a,&b,&c,&d);
            add(s,i,b,a),add(i,e,d,-c);
        }
        while(m--)
        {
            int u,v,k;
            scanf("%d%d%d",&u,&v,&k);
            add(u,v,INF,k),add(v,u,INF,k);
        }
        printf("%d\n",-mcmf());
    }
    return 0;
}