HDU6118 度度熊的交易计划

度度熊的交易计划

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

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
最小费用最大流，因为是获得的利润最大是多少，所以我们把花费整体取反，支出为正，收入为负，然后跑就可以了。但是要注意最重要的一点就是当前再卖物品就要花钱的时候，我们就不要继续累加花费了。

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 500+7;
const int inf = 1e9;

int n,m;
int s,e;
int cnt,head[MAXN];
struct node
{
    int u,v,w,f,next;
} edge[102005];

void init()
{
    cnt=0;
    for(int i=0; i<=e; ++i)
    {
        head[i]=-1;
    }
}

void add(int u,int v,int w,int f)
{
    edge[cnt].u=u;
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].f=f;
    edge[cnt].next=head[u];
    head[u]=cnt++;
    edge[cnt].u=v;
    edge[cnt].v=u;
    edge[cnt].w=-w;
    edge[cnt].f=0;
    edge[cnt].next=head[v];
    head[v]=cnt++;
}

bool vis[MAXN];
int dis[MAXN],pre[MAXN];
bool spfa()
{
    int i;
    for(i=s; i<=e; ++i)
    {
        dis[i]=inf;
        pre[i]=-1;
        vis[i]=0;
    }
    queue<int>q;
    q.push(s);
    dis[s]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(i=head[u]; i!=-1; i=edge[i].next)
        {
            int v=edge[i].v;
            int w=edge[i].w;
            int f=edge[i].f;
            if(f>0&&dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                pre[v]=i;
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    if(pre[e]==-1)return 0;
    return 1;
}
int get_mincost()
{
    int max_flow=0,min_cost=0;
    while(spfa())
    {
        if(dis[e] > 0)break;
        int p=pre[e];
        int flow=inf;
        while(p!=-1)
        {
            flow=min(flow,edge[p].f);
            p=pre[edge[p].u];
        }
        max_flow+=flow;
        min_cost+=flow*dis[e];
        p=pre[e];
        while(p!=-1)
        {
            edge[p].f-=flow;
            edge[p^1].f+=flow;
            p=pre[edge[p].u];
        }
    }
    return min_cost;
}

int main()
{

    while(~scanf("%d%d",&n,&m))
    {
        s = 0;
        e = n+1;
        init();
        int a,b,c,d;
        for(int i = 1; i <= n; ++i)
        {
            scanf("%d%d%d%d",&a,&b,&c,&d);
            add(s,i,a,b);
            add(i,e,-c,d);
        }
        int u,v,w;
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w,inf);
            add(v,u,w,inf);
        }
        printf("%d\n",-get_mincost());
    }
    return 0;
}