（最小费用流）hdu 6118（2017百度之星初赛B 1005） 度度熊的交易计划

度度熊的交易计划

Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 260    Accepted Submission(s): 83

Problem 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<=n<=500,
1<=m<=1000,
1<=a[i],b[i],c[i],d[i],k[i]<=1000,
1<=u[i],v[i]<=n

 

Output

输出最多能赚多少钱。

 

Sample Input

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

 

Sample Output

23

 

Source

2017"百度之星"程序设计大赛 - 初赛（B）

UPD：

智障了，请无视掉下述话吧，cost和cap题目中给的acd就是……就是完完全全的费用流裸题。

恰当的建图之后就是个裸的最小费用流（当然，由于求的是最大盈利，值乘-1进行计算）了。将每个点拆成3个，分别为： 由源点连向的点（边cost=a[i]，cap=b[i]） 由第一种点（对应原图中下标设为i）连向的“入点”(对应原图中下标设为j）（cost=-（c[j]-dis[i][j]）,cap=a[i]）（其中dis[i][j]为i到j的最短路，事先需要floyd跑一边求一下） 由于每个点出售的数量是有限制的，故第三种点为第二种点一一对应连接的（cost=0，cap=d[i]）第三种点再连向汇点。

不过需要注意的是，这样建的图并不一定是满流（因为有的地方可以不生产），故为了保证最小费用流中的满流条件，再增加一个“超级源点”、“超级汇点”，分别与原本的源点、汇点相连，并增加一条从原本的源点连向汇点的cost=0,cap=INF的边。

建完图之后直接进行最小费用流即可。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include<bitset>
#include <utility>
using namespace std;
#define REP(I,N) for (I=0;I<N;I++)
#define rREP(I,N) for (I=N-1;I>=0;I--)
#define rep(I,S,N) for (I=S;I<N;I++)
#define rrep(I,S,N) for (I=N-1;I>=S;I--)
#define FOR(I,S,N) for (I=S;I<=N;I++)
#define rFOR(I,S,N) for (I=N;I>=S;I--)
#define rank rankk
#define DFT FFT
typedef unsigned long long ull;
typedef long long ll;
//const int INF=0x3f3f3f3f;
const ll INFF=0x3f3f3f3f3f3f3f3fll;
//const ll M=1e9+7;
const ll maxn=2e5+7;
//const int MAXN=1005;
const int MAX=1e6+5;
const int MAX_N=MAX;
//const int N=55;
const ll MOD=1e9+7;
//const double eps=0.00000001;
int gcd(int a,int b){return b?gcd(b,a%b):a;}
template<typename T>inline T abs(T a) {return a>0?a:-a;}
inline ll powMM(ll a,ll b,ll M){
    ll ret=1;
    a%=M;
//    b%=M;
    while (b){
        if (b&1) ret=ret*a%M;
        b>>=1;
        a=a*a%M;
    }
    return ret;
}
void open()
{
    freopen("t.txt","r",stdin);
    freopen("out.txt","w",stdout);
}

const int MAXN = 10000;
const int MAXM = 1000000;
const int INF = 0x3f3f3f3f;
struct Edge
{
int to,next,cap,flow,cost;
}edge[MAXM];
int head[MAXN],tol;
int pre[MAXN],dis[MAXN];
bool vis[MAXN];
int N;//节点总个数，节点编号从0~N-1
void init(int n)
{
N = n;
tol = 0;
memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int cap,int 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)
{
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 )
{
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;
}
//返回的是最大流，cost存的是最小费用
int minCostMaxflow(int s,int t,int &cost)
{
int flow = 0; 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 n,m;
int diss[505][505];
int a[505],b[505],c[505],d[505];
int V;//顶点数
void warshall_floyd()
{
    for(int k=1;k<=V;k++)
        for(int i=1;i<=V;i++)
            for(int j=1;j<=V;j++)
                diss[i][j]=min(diss[i][j],diss[i][k]+diss[k][j]);
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        memset(diss,-1,sizeof(diss));
        for(int i=1;i<=n;i++)
            scanf("%d%d%d%d",&a[i],&b[i],&c[i],&d[i]);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                diss[i][j]=(int)1e9;
        for(int i=1;i<=n;i++)
            diss[i][i]=0;
        for(int i=1;i<=m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(x==y)
                continue;
            diss[x][y]=diss[y][x]=min(z,diss[x][y]);
        }
        V=n;
        warshall_floyd();
        init(3*n+4);
        for(int i=1;i<=n;i++)
            addedge(0,i,b[i],a[i]);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(diss[i][j]!=-1&&c[j]>=a[i]+diss[i][j])
                    addedge(i,j+n,b[i],-(c[j]-diss[i][j]));
            }
        }
        for(int i=1;i<=n;i++)
            addedge(i+n,i+2*n,d[i],0);
        for(int i=1;i<=n;i++)
            addedge(i+2*n,3*n+1,d[i],0);
        addedge(3*n+2,0,INF,0);
        addedge(3*n+1,3*n+3,INF,0);
        addedge(0,3*n+1,INF,0);
        int co;
        int an=minCostMaxflow(3*n+2,3*n+3,co);
        printf("%d
",-co);
    }
}