HDU 3667 Transportation | 费用流（拆边）

题意：

运送货物，从city 1 到city n。途中有劫匪，因此你需要雇佣护卫。随着每条边的流量增多，费用也逐渐上涨。费用 = ai*x^2。（ai为已给的系数）

求把所有物品运送到city n的最小费用。不能把所有物品运送到city n的，输出-1

错误思路：

建好图，打算每次只跑一点流量。根据该条边的当前已有的流量，来更新下一个点的费用。听起来感觉好对，但还是WA了，现在还是没找到错误的测试组。

后来铭神跟我讲了下，好像是反向边更新时决策变少了。还是不太懂= =

思路：

每条边的最大流量才5，因此拆边。听到拆边这个词，应该知道怎么做了吧。

AC代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <queue>
using namespace std;
#define debug cout<<"debug"<<endl;
const int MAXN = 105;
const int MAXM = 5005;
const int MAXK = 105;
const int MAXEDGE = 1e5+5;
const int INF = 0x3f3f3f3f;
int n, m, k;
struct CEdge
{
        int from, to, cap, flow, cost, next;
}edge[MAXEDGE];
struct CMCMF
{
        int s, t, pp;
        int head[MAXN], d[MAXN], a[MAXN], p[MAXN];
        bool inq[MAXN];
        CMCMF(int ss, int tt)
        {
                s = ss, t = tt;
                pp = 0;
                memset(head, -1, sizeof(head));
        }
        void addEdge(int u, int v, int cap, int cost)
        {
                edge[pp] = (CEdge){u, v, cap, 0, cost, head[u]};
                head[u] = pp++;
                edge[pp] = (CEdge){v, u, 0, 0, -cost, head[v]};
                head[v] = pp++;
        }
        bool bellmanFord(int &flow, int &cost)
        {
                //if(flow >= k)   return false;
                memset(d, INF, sizeof(d));
                memset(inq, false, sizeof(inq));
                queue <int> q;
                q.push(s), inq[s] = true;
                d[s] = 0, a[s] = INF, p[s] = -1;
                while(!q.empty())
                {
                        int u = q.front();
                        q.pop(), inq[u] = false;
                        int next = head[u];
                        while(next != -1)
                        {
                                CEdge &e = edge[next];
                                if(e.cap > e.flow &&  d[e.to] > d[u] + e.cost)
                                {
                                        d[e.to] = d[u] + e.cost;
                                        a[e.to] = min(a[u], e.cap - e.flow);
                                        p[e.to] = next;
                                        if(!inq[e.to])  inq[e.to] = true, q.push(e.to);
                                }
                                next = e.next;
                        }
                }
                if(d[t] == INF) return false;
               // cout<<"each flow = "<<a[t]<<endl;
                cost += d[t] * a[t];
                flow += a[t];
                int u = t;
                while(u != s)
                {
                        edge[p[u]].flow += a[t];
                        edge[p[u]^1].flow -= a[t];
                        u = edge[p[u]].from;
                }
                return true;
        }
};


int main()
{
        while(scanf("%d%d%d", &n, &m, &k) != EOF)
        {
                int s = 0, t = n;
                CMCMF mcmf(s, t);
                mcmf.addEdge(s, 1, k, 0);
                int u, v, a, cap;
                for(int i = 0;i < m; i++)
                {
                        scanf("%d%d%d%d", &u, &v, &a, &cap);
                        for(int j = 1;j <= cap; j++)
                        {
                                mcmf.addEdge(u, v, 1, a*j*j-a*(j-1)*(j-1));
                        }
                }
                int cost = 0, flow = 0;
                while(mcmf.bellmanFord(flow, cost));
                if(flow < k)
                        puts("-1");
                else
                        cout<<cost<<endl;
        }
        return 0;
}

错误思路的代码（存一份吧）：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <queue>
using namespace std;
#define debug cout<<"debug"<<endl;
const int MAXN = 105;
const int MAXM = 5005;
const int MAXK = 105;
const int MAXEDGE = 1e5+5;
const int INF = 0x3f3f3f3f;
int n, m, k;
struct CEdge
{
        int from, to, cap, flow, cost, next;
}edge[MAXEDGE];
struct CMCMF
{
        int s, t, pp;
        int head[MAXN], d[MAXN], a[MAXN], p[MAXN];
        bool inq[MAXN];
        CMCMF(int ss, int tt)
        {
                s = ss, t = tt;
                pp = 0;
                memset(head, -1, sizeof(head));
        }
        void addEdge(int u, int v, int cap, int cost)
        {
                edge[pp] = (CEdge){u, v, cap, 0, cost, head[u]};
                head[u] = pp++;
                edge[pp] = (CEdge){v, u, 0, 0, -cost, head[v]};
                head[v] = pp++;
        }
        bool bellmanFord(int &flow, int &cost)
        {
                //if(flow >= k)   return false;
                memset(d, INF, sizeof(d));
                memset(inq, false, sizeof(inq));
                queue <int> q;
                q.push(s), inq[s] = true;
                d[s] = 0, a[s] = INF, p[s] = -1;
                while(!q.empty())
                {
                        int u = q.front();
                        q.pop(), inq[u] = false;
                        int next = head[u];
                        while(next != -1)
                        {
                                CEdge &e = edge[next];
                                int tcost = e.cost*((e.flow+1)*(e.flow+1) - e.flow*e.flow);
                                if(e.cap > e.flow &&  d[e.to] > d[u] + tcost)
                                {
                                        d[e.to] = d[u] + tcost;
                                        a[e.to] = min(a[u], e.cap - e.flow);
                                        p[e.to] = next;
                                        if(!inq[e.to])  inq[e.to] = true, q.push(e.to);
                                }
                                next = e.next;
                        }
                }
                if(d[t] == INF) return false;
               // cout<<"each flow = "<<a[t]<<endl;
                cost += d[t] * a[t];
                flow += a[t];
                int u = t;
                while(u != s)
                {
                        edge[p[u]].flow += a[t];
                        edge[p[u]^1].flow -= a[t];
                        u = edge[p[u]].from;
                }
                return true;
        }
};


int main()
{
        while(scanf("%d%d%d", &n, &m, &k) != EOF)
        {
                int s = 0, t = n;
                CMCMF mcmf(s, t);
                mcmf.addEdge(s, 1, k, 0);
                int u, v, a, cap;
                for(int i = 0;i < m; i++)
                {
                        scanf("%d%d%d%d", &u, &v, &a, &cap);
                        for(int j = 1;j <= cap; j++)
                        {
                                mcmf.addEdge(u, v, 1, a*j*j-a*(j-1)*(j-1));
                        }
                }
                int cost = 0, flow = 0;
                while(mcmf.bellmanFord(flow, cost));
                if(flow < k)
                        puts("-1");
                else
                        cout<<cost<<endl;
        }
        return 0;
}