Vijos1825 NOI2008 志愿者招募 费用流

Orz ByVoid大神的题解：https://www.byvoid.com/blog/noi-2008-employee/

学习网络流建图的好题，不难想到线性规划的模型，不过利用模型的特殊性，结合网络流的性质，可以设计出很优美的解法

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>

 ;
 ;
 const int inf=0x7f7f7f7f;

 struct Edge
 {
     int to;
     int next;
     int capacity;
     int cost;

     void assign(int t,int n,int cp,int co)
     {
         to=t,next=n,capacity=cp,cost=co;
     }
 };

 Edge elist[maxM*];
 int head[maxN];
 int ecnt;
 int src,sink;

 void initEdge()
 {
     memset(head,-,sizeof(head));
     ecnt=;
 }

 inline void addEdge(int from,int to,int capacity,int cost)
 {
     elist[ecnt].assign(to,head[from],capacity,cost);
     head[from]=ecnt++;
     elist[ecnt].assign(,-cost);
     head[to]=ecnt++;
 }

 int N,M;
 int A[maxN];
 int S[maxM],T[maxM],C[maxM];

 void input()
 {
     scanf("%d%d",&N,&M);
     A[]=; A[N+]=;
     ;i<=N;i++) scanf("%d",A+i);
     ;i<=M;i++)
         scanf("%d%d%d",S+i,T+i,C+i);
 }

 void buildGraph()
 {
     src=; sink=N+;
     initEdge();
     ;i<=N+;i++)
     {
         ]>) addEdge(i,sink,A[i]-A[i-],);
         ]<) addEdge(src,i,A[i-]-A[i],);
     }
     ;i<=N;i++)
         addEdge(i,i+,inf,);
     ;i<=M;i++)
         addEdge(T[i]+,S[i],inf,C[i]);
 }

 int dist[maxN];
 int prevV[maxN];
 int prevE[maxN];
 bool inq[maxN];
 std::queue<int> que;

 bool spfa()
 {
     memset(dist,0x7f,sizeof(dist));
     dist[src]=;
     memset(inq,,sizeof(inq));
     que.push(src);
     prevV[src]=prevE[src]=-;
     while(!que.empty())
     {
         int cur=que.front();
         que.pop(); inq[cur]=false;
         ;e=elist[e].next)
             if(elist[e].capacity)
             {
                 int& to=elist[e].to;
                 int& co=elist[e].cost;
                 if(dist[to]>dist[cur]+co)
                 {
                     dist[to]=dist[cur]+co;
                     prevV[to]=cur;
                     prevE[to]=e;
                     if(!inq[to])
                     {
                         que.push(to);
                         inq[to]=true;
                     }
                 }
             }
     }
     return dist[sink]<inf;
 }

 int minCostFlow()
 {
     );
     while(spfa())
     {
         int maxf=inf;
         ;v=prevV[v],e=prevE[v])
             maxf=std::min(maxf,elist[e].capacity);
         ;v=prevV[v],e=prevE[v])
         {
             res+=maxf*elist[e].cost;
             elist[e].capacity-=maxf;
             elist[e^].capacity+=maxf;
         }
     }
     return res;
 }

 int main()
 {
     input();
     buildGraph();
     printf("%d\n",minCostFlow());
     ;
 }