HDU4862-Jump（最大流量最大费用流）

#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <vector>
#include <bitset>
#include <cstdio>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <map>
#include <set>
#define pk(x) printf("%d\n", x)
using namespace std;
#define PI acos(-1.0)
#define EPS 1E-6
#define clr(x,c) memset(x,c,sizeof(x))
//#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;

#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;
const int MAXV = 410;
const int INF = 1<<30;

struct Edge { int to, cap, cost, rev; };
vector<Edge> G[MAXV];
int dist[MAXV], prv[MAXV], pre[MAXV], in[MAXV];
queue<int> que;

void addedge(int from, int to, int cap, int cost) {
    G[from].push_back((Edge){to, cap, cost, G[to].size()});
    G[to].push_back((Edge){from, 0, -cost, G[from].size()-1});
}

int min_cost_max_flow(int s, int t, int f) {
    int res = 0;
    while (f > 0) {
        for (int i = 0; i <= t; ++i) dist[i] = -INF, in[i] = 0;
        dist[s] = 0;
        while (!que.empty()) que.pop();
        in[s] = 1;
        que.push(s);

        while (!que.empty()) {
            int u = que.front(); que.pop(); in[u] = 0;
            for (int i = 0; i < G[u].size(); ++i) {
                Edge &e = G[u][i];
                if (e.cap > 0 && dist[e.to] < dist[u] + e.cost) {
                    dist[e.to] = dist[u] + e.cost;
                    prv[e.to] = u;
                    pre[e.to] = i;
                    if (in[e.to] == 0) {
                        in[e.to] = 1;
                        que.push(e.to);
                    }
                }
            }
        }

        if (dist[t] == -INF) return -1;

        int d = f;
        for (int v = t; v != s; v = prv[v]) {
            d = min(d, G[prv[v]][pre[v]].cap);
        }
        f -= d;
        res += d * dist[t];
        for (int v = t; v != s; v = prv[v]) {
            Edge &e = G[prv[v]][pre[v]];
            e.cap -= d;
            G[v][e.rev].cap += d;
        }
    }
    return res;
}

int n, m, k;
char str[15][15];
int id1(int x, int y) {
    return x*m+y+1;
}
int id2(int x, int y) {
    return n*m+x*m+y+1;
}
// |x1-x2|+|y1-y2|-1
int cost(int x1, int y1, int x2, int y2) {
    int ans = -(abs(x1-x2)+abs(y1-y2)-1);
    if (str[x1][y1] == str[x2][y2]) ans += str[x1][y1] - ‘0‘;
    return ans;
}

int main()
{
    int T, cas = 0;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d%d", &n, &m, &k);

        for (int i = 0; i < n; ++i) {
            scanf("%s", str[i]);
        }

        int src = 0;
        int q = n*m*2+1;
        int sink = n*m*2+2;

        for (int i = src; i <= sink; ++i) G[i].clear();

        addedge(src, q, k, 0);

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {

                addedge(src, id1(i, j), 1, 0);
                addedge(id2(i,j), sink, 1, 0);
                addedge(q, id2(i,j), 1, 0);

                for (int k = i+1; k < n; ++k) {
                    addedge(id1(i, j), id2(k, j), 1, cost(i,j,k,j));
                }

                for (int k = j+1; k < m; ++k) {
                    addedge(id1(i,j), id2(i,k), 1, cost(i,j,i,k));
                }

            }
        }

        printf("Case %d : %d\n", ++cas, min_cost_max_flow(src, sink, n*m));
    }
    return 0;
}