Description:

物流配送是物流活動中一種非單一的業務形式，它與物品流動、資金流動緊密結合。備貨是配送的準備工作或基礎工作，備貨工作包括籌集貨源、訂貨或購貨、集貨、進貨及有關的質量檢查、結算、交接等。配送的優勢之一，就是可以集中使用者的需求進行一定規模的備貨。備貨是決定配送成敗的初期工作，如果備貨成本太高，會大大降低配送的效益。配送中的儲存有儲備及暫存兩種形態。配送儲備是按一定時期的配送經營要求，形成的對配送的資源保證。這種型別的儲備數量較大，儲備結構也較完善，視貨源及到貨情況，可以有計劃地確定週轉儲備及保險儲備結構及數量。

Dr. Kong 所在的研究團隊準備為Hai-E集團開發一個物流配送管理系統。已知Hai-E集團已經在全國各地建立了n個貨物倉庫基地，任意兩個基地的貨物可以相互調配。現在需要根據使用者訂貨要求，來重新調配每個基地的貨物數量。為了節流開源，希望對整個物流配送體系實行統一的貨物管理和排程，能夠提供一個全面完善的物流倉儲配送解決方案，以減少物流配送過程中成本、人力、時間。

Input:

第一行： n （1 ≤ n ≤ 1000）

第2行： a1 a2 …… an 表示n個基地當前的物品數量 (0≤ ai ≤ 106 )

第3行： b1 b2 …… bn 表示調配後，每個基地i應不少於bi個物品 (0≤ bi ≤ 106)

接下來n-1行，每行三個整數： i j k 表示從第i基地調配一個物品到第j基地需要花費為k，或 從第j基地調配一個物品到第i基地需要花費為k。(0≤ k ≤ 10^6)

Output:

輸出配送後的最小費用。

已知： a1+a2+…+an >=b1+b2+…+bn

Sample Input:

6 0 1 2 2 0 0 0 0 1 1 1 1 1 2 2 1 3 5 1 4 1 2 5 5 2 6 1

Sample Output:

9

題目連結

題目很明顯的最小費用最大流裸題，要求出最後重新調配每個基地貨物數量之後的最小花費，建圖時源點連線每個貨物倉庫基地，容量為a[i]花費為0（初始時每個貨物倉庫基地有a[i]個貨物），每個貨物倉庫基地連結匯點，容量為b[i]花費為0（因為要求最小化費，顯然最大流為$\sum_{i=1}^{n}b_{i}$），最後在可調配路線上建邊跑最小費用最大流即可，此題資料會爆int。

AC程式碼:

#include <bits/stdc++.h>
 

using namespace std;

const int INF = 0x3f3f3f3f;
const int maxn = 1e3 + 5;

struct Link {
    long long V, Cap, Cost, Flow, Next;
};

int N;
int A[maxn], B[maxn];
int Head[maxn];
int Path[maxn];
int Dis[maxn];
bool Vis[maxn];
int Tot;
Link edges[maxn << 7];

void Init() {
    Tot = 0;
    memset(Head, -1, sizeof(Head));
}

void AddEdge(int U, int V, long long Cap, long long Cost) {
    edges[Tot] = Link {V, Cap, Cost, 0, Head[U]};
    Head[U] = Tot++;
    edges[Tot] = Link {U, 0, -Cost, 0, Head[V]};
    Head[V] = Tot++;
}

bool Spfa(int Start, int End) {
    memset(Dis, INF, sizeof(Dis));
    memset(Vis, false, sizeof(Vis));
    memset(Path, -1, sizeof(Path));
    Dis[Start] = 0;
    Vis[Start] = true;
    std::queue<int> Que;
    while (!Que.empty()) {
        Que.pop();
    }
    Que.push(Start);
    while (!Que.empty()) {
        int U = Que.front();
        Que.pop();
        Vis[U] = false;
        for (int i = Head[U]; i != -1; i = edges[i].Next) {
            int V = edges[i].V;
            if (edges[i].Cap > edges[i].Flow && Dis[V] > Dis[U] + edges[i].Cost) {
                Dis[V] = Dis[U] + edges[i].Cost;
                Path[V] = i;
                if (!Vis[V]) {
                    Vis[V] = true;
                    Que.push(V);
                }
            }
        }
    }
    return Path[End] != -1;
}

int MinCostMaxFlow(int Start, int End, long long &MinCost) {
    int MaxFlow = 0;
    MinCost = 0;
    while (Spfa(Start, End)) {
        int Min = INF;
        for (int i = Path[End]; i != -1; i = Path[edges[i ^ 1].V]) {
            if (edges[i].Cap - edges[i].Flow < Min) {
                Min = edges[i].Cap - edges[i].Flow;
            }
        }
        for (int i = Path[End]; i != -1; i = Path[edges[i ^ 1].V]) {
            edges[i].Flow += Min;
            edges[i ^ 1].Flow -= Min;
            MinCost += edges[i].Cost * Min;
        }
        MaxFlow += Min;
    }
    return MaxFlow;
}

int main(int argc, char *argv[]) {
    while (~scanf("%d", &N)) {
        Init();
        for (int i = 1; i <= N; ++i) {
            scanf("%d", &A[i]);
            AddEdge(0, i, A[i], 0);
        }
        for (int i = 1; i <= N; ++i) {
            scanf("%d", &B[i]);
            AddEdge(i, N + 1, B[i], 0);
        }
        for (int i = 1, U, V, C; i < N; ++i) {
            scanf("%d%d%d", &U, &V, &C);
            AddEdge(U, V, INF, C);
            AddEdge(V, U, INF, C);
        }
        long long MinCost;
        MinCostMaxFlow(0, N + 1, MinCost);
        printf("%lld\n", MinCost);
    }
    return 0;
}