POJ 3422 最小费用最大流

链接：

http://poj.org/problem?id=3422

题解：

关键是如何处理“只能获取一次”的问题，为此可以为每个点创建伪点，由两条有向边相连。原始点到伪点连一条容量为1，权值为负分数的边；原始点到伪点连一条容量为无穷，权值为0的边。前者表示分数只能拿一次，后者表示第二次第三次……可以继续走这个点，但是不拿分数。负权是因为题目要求的是“最大费用”。又因为最多走同一个点K次，所以此处的无穷大取K就行了。

代码：

#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
typedef vector<int> VI;
typedef long long ll;
typedef pair<int, int> PII;
const ll mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-10;
const double pi = acos(-1.0);
// head

struct edge { int to, cap, cost, rev; };
const int MAX_V = 2e4 + 7;
int V;
vector<edge> G[MAX_V];
int h[MAX_V];
int dist[MAX_V];
int prevv[MAX_V], preve[MAX_V];

void add_edge(int from, int to, int cap, int cost) {
    G[from].pb(edge{ to,cap,cost,(int)G[to].size() });
    G[to].pb(edge{ from,0,-cost,(int)G[from].size() - 1 });
}

int min_cost_flow(int s, int t, int f){
    int res = 0;
    memset(h, 0, sizeof(h));
    while (f > 0) {
        priority_queue<PII, vector<PII>, greater<PII> > que;
        memset(dist, 0x3f, sizeof(dist));
        dist[s] = 0;
        que.push(mp(s, 0));
        while (!que.empty()) {
            PII p = que.top(); que.pop();
            int v = p.second;
            rep(i, 0, G[v].size()) {
                edge &e = G[v][i];
                if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
                    dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
                    prevv[e.to] = v;
                    preve[e.to] = i;
                    que.push(mp(dist[e.to], e.to));
                }
            }
        }
        if (dist[t] == inf) return -1;
        rep(v, 0, V) h[v] += dist[v];
        int d = f;
        for (int v = t; v != s; v = prevv[v]) d = min(d, G[prevv[v]][preve[v]].cap);
        f -= d;
        res += d*h[t];
        for (int v = t; v != s; v = prevv[v]) {
            edge &e = G[prevv[v]][preve[v]];
            e.cap -= d;
            G[v][e.rev].cap += d;
        }
    }
    return res;
}

int n, k;

int pos(int i, int j){
    return 2 * (i * n + j);
}

int main() {
    cin >> n >> k;
    V = n*n * 2;
    rep(i, 0, n) rep(j, 0, n) {
        int a;
        cin >> a;
        int cur = pos(i, j);
        add_edge(cur, cur + 1, 1, -a);
        add_edge(cur, cur + 1, inf, 0);
        if (i < n - 1) add_edge(cur + 1, pos(i + 1, j), inf, 0);
        if (j < n - 1) add_edge(cur + 1, pos(i, j + 1), inf, 0);
    }
    cout << - min_cost_flow(0, V - 1, k) << endl;
    return 0;
}