HDU6118 度度熊的交易計劃 【費用流】

鏈接

---

百度之星的時候腦抽了…
跑了n次Dijkstra求了個全源最短路
拆點 i和j′的費用爲cj−ai−disi,j
S到i,流量爲bi,費用爲0, i′到T流量爲di,費用爲0
這樣邊數2n2,TLE到爆

---

正解...直接按輸入建圖即可,拆點都不需要...
S到i的費用爲ai,流量bi
i到T費用−ci,流量di
<i,j>有一條長爲k的邊,則建一條i到j,費用k,流量inf的邊,跑一遍,費用取反即可
但是這樣即使利潤<0的交易也會被計算在內,所以spfa增廣的dis>=0時結束掉即可

#include<stdio.h>
#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define pll pair<ll,ll>
#define MEM(a,x) memset(a,x,sizeof(a))
#define lowbit(x) ((x)&-(x))

using namespace std;

const int inf=1e9+7;
const int MOD = 1e9+7;
const int INF = inf;

const int N = 500 + 50;
const int M = 1000*4+4*N + 100;//邊

struct MinFlow{
    struct Edge{
        int to,c,w,next;//c:流量，w：費用
    }edge[M];
    int head[N];
    int nume=0;
    inline void addEdge(int k,int u,int v,int c,int w){
        edge[k].to=v,
                edge[k].c=c,
                edge[k].w=w,
                edge[k].next=head[u];
        head[u]=k;
    }
    inline void addEdge(int u,int v,int c,int w){
        addEdge(nume++,u,v,c,w);
        addEdge(nume++,v,u,0,-w);
    }
    void init(int n){
        fill(head,head+n+1,-1);
        nume=0;
    }
    bool used[N];
    int dis[N],load[N],p[N];//距離 ，前驅邊，前驅點
    bool spfa(int s,int e,int n){
        deque<int>que;
        for(int i=0;i<=n;++i){
            dis[i]=INF;
            load[i]=p[i]=-1;
            used[i]=false;
        }
        que.push_back(s);
        dis[s]=0;
        used[s]=true;
        while(!que.empty()){
            int u=que.front();
            que.pop_front();
            used[u]=false;
            for(int i=head[u];i!=-1;i=edge[i].next){
                if(edge[i].c>0){
                    int v=edge[i].to;
                    if(dis[v]>dis[u]+edge[i].w){
                        dis[v]=dis[u]+edge[i].w;
                        p[v]=u;
                        load[v]=i;
                        if(used[v]==false){
                            used[v]=true;
                            que.push_back(v);
                        }
                    }
                }
            }
        }
        return dis[e]<0;//dis[e]>=0時,利潤<=0,結束計算
    }

    int min_cost_flow(int s,int t,int n){
        int ansflow=0,anscost=0;//最大流，最小費用
        while(spfa(s,t,n)){
            int u=t;
            int f=INF;
            while(p[u]!=-1){
                f=min(f,edge[load[u]].c);
                u=p[u];
            }
            u=t;
            while(p[u]!=-1){
                edge[load[u]].c-=f;
                edge[load[u]^1].c+=f;
                u=p[u];
            }
            anscost+=dis[t]*f;
            ansflow+=f;
        }
        return anscost;
    }
}minflow;

int slove(int n,int m){
    const int S=n+1,T=S+1;
    minflow.init(T+1);
    for(int i=1;i<=n;++i){
        int a,b,c,d;
        scanf("%d%d%d%d",&a,&b,&c,&d);
        minflow.addEdge(S,i,b,a);
        minflow.addEdge(i,T,d,-c);
    }
    for(int i=1;i<=m;++i){
        int u,v,k;
        scanf("%d%d%d",&u,&v,&k);
        minflow.addEdge(u,v,inf,k);
        minflow.addEdge(v,u,inf,k);
    }
    return -minflow.min_cost_flow(S,T,T+1);
}

int main()
{
    //freopen("/home/lu/code/r.txt","r",stdin);
    //freopen("/home/lu/code/w.txt","w",stdout);
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        printf("%d\n",slove(n,m));
    }
    return 0;
}