2017"百度之星"程序设计大赛 - 初赛（B）度度熊的交易计划

n个村庄m条带权路，权值为花费，村庄可以造东西卖东西，造完东西可以换地方卖，给出每个村庄造东西花费a和最多个数b、卖东西价值c和最多个数d，求最大收益。

裸的费用流。然而还WA了一发。很好。

建源向每个村庄连边(b,a)，(b,a)表示容量b费用a，每个村庄向汇点连边(d,-c)，村庄间有路就互相连边(inf,v)，v为边权，然后就是最小费用流。

不是最小费用最大流！！把费用最大流SPFA中最后一句判断改成<0即可，因为>=0时的费用可以不要他。

 #include<stdio.h>
 #include<stdlib.h>
 #include<string.h>
 #include<algorithm>
 #include<math.h>
 #include<iostream>
 using namespace std;

 int n,m,s,t;
 #define maxn 10011
 #define maxm 50011
 struct Edge{int from,to,next,cap,flow,cost;};
 const int inf=0x3f3f3f3f;
 struct Graph
 {
     Edge edge[maxm];
     int n,first[maxn],d[maxn],cur[maxn],le,cost,s,t;
     bool inq[maxn],mark[maxn];
     void clear() {memset(first,,sizeof(first));le=;cost=;}
     void in(int x,int y,int cap,int cost)
     {
         Edge& e=edge[le];
         e.from=x;e.to=y;e.cap=cap;e.flow=;
         e.cost=cost;e.next=first[x];first[x]=le++;
     }
     void insert(int x,int y,int cap,int cost)
     {
         in(x,y,cap,cost);
         in(y,x,,-cost);
     }
     bool SPFA()
     {
         memset(d,0x3f,*(n+));
         int que[],head=,tail=;
         que[]=s;inq[s]=;d[s]=;
         while (head<tail)
         {
             const int now=que[head++];
             if (head==) head=;
             inq[now]=;
             for (int i=first[now];i;i=edge[i].next)
             {
                 Edge& e=edge[i];
                 if (e.cap>e.flow && d[e.to]>d[now]+e.cost)
                 {
                     d[e.to]=d[now]+e.cost;
                     if (!inq[e.to])
                     {
                         que[tail++]=e.to;
                         inq[e.to]=;
                         if (tail==) tail=;
                     }
                 }
             }
         }
         return d[t]<;
     }
     int dfs(int x,int a)
     {
         if (x==t || !a) {cost+=a*d[t];return a;}
         mark[x]=;
         int flow=,f;
         for (int& i=cur[x];i;i=edge[i].next)
         {
             Edge& e=edge[i];
             if (!mark[e.to] && d[e.to]==d[x]+e.cost && (f=dfs(e.to,min(a,e.cap-e.flow)))>)
             {
                 flow+=f;
                 e.flow+=f;
                 edge[i^].flow-=f;
                 a-=f;
                 if (!a) break;
             }
         }
 //        mark[x]=0;
         return flow;
     }
     int MCMF(int s,int t)
     {
         this->s=s;this->t=t;
         int flow=;cost=;
         memset(mark,,sizeof(mark));
         memset(inq,,sizeof(inq));
         while (SPFA())
         {
             memset(mark,,n+);
             for (int i=;i<=n;i++) cur[i]=first[i];
             flow+=dfs(s,inf);
         }
         return cost;
     }
 }g;
 int a,b,c,d;
 int main()
 {
     while (scanf("%d%d",&n,&m)==)
     {
         g.clear();g.n=n+;s=n+;t=s+;
         for (int i=;i<=n;i++)
         {
             scanf("%d%d%d%d",&a,&b,&c,&d);
             g.insert(s,i,b,a);
             g.insert(i,t,d,-c);
         }
         for (int i=;i<=m;i++)
         {
             scanf("%d%d%d",&a,&b,&c);
             if (a==b) continue;
             g.insert(a,b,inf,c);
             g.insert(b,a,inf,c);
         }
         printf("%d\n",-g.MCMF(s,t));
     }
     return ;
 }