HDU 4862 Jump (2014-多校1-1002，最小K路径覆盖，最小费用最大流)

题目：

http://acm.hdu.edu.cn/showproblem.php?pid=4862

题意：

给你一个n*m的矩阵，填充着0-9的数字，每次能从一个点出发，到它的右边或者下边的点，花费为|x1-x2|+|y1-y2|-1，如果跳跃的起点和终点的数字相同，则获得这个数字的收益，不能走已经走过的点

有K次重新选择起点的机会

如果可以走遍所有点，则输出最大的价值(收益-花费)

否则，输出-1

方法：

最小K路径覆盖，最小费用最大流

建图：

每个点拆为2点：X部和Y部，(a,b)表示流量a，费用b

源点与X部每个点连(1,0)的边

Y部每个点与汇点连(1,0)的边

X部的点如果可以到Y部的点，则连(1,花费-收益)的边

源点与一个新点连(k,0)的边，新点与Y部每个点连(1,0)的边

结果：

如果满流，则输出0-费用

否则，输出-1

代码：

// #pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <list>
#include <map>
#include <iterator>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long LL;
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
// const int maxn = 210;
// const int maxm = 200010;
// const int inf = 0x3f3f3f3f;
const LL inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double INF = 1e30;
const double eps = 1e-6;
const int P[4] = {0, 0, -1, 1};
const int Q[4] = {1, -1, 0, 0};
const int PP[8] = { -1, -1, -1, 0, 0, 1, 1, 1};
const int QQ[8] = { -1, 0, 1, -1, 1, -1, 0, 1};

/**
*最小(大)费用最大流：SPFA增广路($O(w*O(SPFA))$)
*最大费用：费用取反addEdge(,,,-cost);
*输入：图(链式前向星),n(顶点个数,包含源汇),s(源),t(汇)
*输出：minCostMaxflow(int s, int t, int &cost)返回流量, cost为费用
*打印路径方法：按反向边(i&1)的flow 找，或者按边的flow找
*/
const int maxn = 210;
const int maxm = 200010;
const int inf = 0x3f3f3f3f;
struct Edge
{
    int u, v;
    int cap, flow;
    int cost;
    int next;
} edge[maxm];
int head[maxn], en; //需初始化
int n, m;
int st, ed;
bool vis[maxn];
int pre[maxn], dis[maxn];
void addse(int u, int v, int cap, int flow, int cost)
{
    edge[en].u = u;
    edge[en].v = v;
    edge[en].cap = cap;
    edge[en].flow = flow;
    edge[en].cost = cost;
    edge[en].next = head[u];
    head[u] = en++;
}
void adde(int u, int v, int cap, int cost)
{
    addse(u, v, cap, 0, cost);
    addse(v, u, 0, 0, -cost); //注意加反向0 边
}
bool spfa(int s, int t)
{
    queue<int>q;
    for (int i = 0; i < n; i++)
    {
        dis[i] = inf;
        vis[i] = false;
        pre[i] = -1;
    }
    dis[s] = 0;
    vis[s] = true;
    q.push(s);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        vis[u] = false;
        for (int i = head[u]; i != -1; i = edge[i].next)
        {
            int v = edge[i].v;
            if (edge[i].cap > edge[i].flow &&
                    dis[v] > dis[u] + edge[i].cost )
            {
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;
                if (!vis[v])
                {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    if (pre[t] == -1)return false;
    else return true;
}
int minCostMaxflow(int s, int t, int &cost)//返回流量, cost为费用
{
    int flow = 0;
    cost = 0;
    while (spfa(s, t))
    {
        int Min = inf;
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].v])
        {
            if (Min > edge[i].cap - edge[i].flow)
                Min = edge[i].cap - edge[i].flow;
        }
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].v])
        {
            edge[i].flow += Min;
            edge[i ^ 1].flow -= Min;
            cost += edge[i].cost * Min;
        }
        flow += Min;
    }
    return flow;
}
int N, M, K;
int kase;
int mtx[maxn][maxn];
int disxy(int x1, int y1, int x2, int y2)
{
    return abs(x1 - x2) + abs(y1 - y2) - 1;
}
void build()
{
    n = 3 + N * M * 2;
    st = 0, ed = 1;
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            adde(st, i * M + j + 3, 1, 0);
        }
    }
    adde(st, 2, K, 0);
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            adde(2, i * M + j + N * M + 3, 1, 0);
            adde(i * M + j + N * M + 3, ed, 1, 0);
        }
    }
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            for (int h = i + 1; h < N; h++)
            {
                if (mtx[i][j] == mtx[h][j])
                {
                    adde(i * M + j + 3, h * M + j + N * M + 3, 1, h - i - 1 - mtx[i][j]);
                    // cout << i << " " << j << " " << h << " " << j << endl;
                }
                else
                {
                    adde(i * M + j + 3, h * M + j + N * M + 3, 1, h - i - 1);
                }
            }
            for (int h = j + 1; h < M; h++)
            {
                if (mtx[i][j] == mtx[i][h])
                {
                    adde(i * M + j + 3, i * M + h + N * M + 3, 1, h - j - 1 - mtx[i][j]);
                    // cout << i << " " << j << " " << i << " " << h << endl;
                }
                else
                {
                    adde(i * M + j + 3, i * M + h + N * M + 3, 1, h - j - 1);
                }
            }
        }
    }
}
void init()
{
    memset(head, -1, sizeof(head));
    en = 0;
    kase++;
}
void input()
{
    scanf("%d%d%d", &N, &M, &K);
    for (int i = 0; i < N; i++)
    {
        char str[maxn];
        scanf("%s", str);
        for (int j = 0; j < M; j++)
        {
            mtx[i][j] = str[j] - '0';
        }
    }
}
void debug()
{
    //
}
void solve()
{
    build();
    int cost;
    int flow = minCostMaxflow(st, ed, cost);
    // cout << "flow,cost: " << flow << " " << cost << endl;
    if (flow == N * M)
    {
        printf("Case %d : %d
", kase, -cost);
    }
    else
    {
        printf("Case %d : %d
", kase, -1);
    }
}
void output()
{
    //
}
int main()
{
    // int size = 256 << 20; // 256MB
    // char *p = (char *)malloc(size) + size;
    // __asm__("movl %0, %%esp
" :: "r"(p));

    // std::ios_base::sync_with_stdio(false);
#ifndef ONLINE_JUDGE
    freopen("in.cpp", "r", stdin);
#endif

    kase = 0;
    int T;
    scanf("%d", &T);
    while (T--)
    {
        init();
        input();
        solve();
        output();
    }
    return 0;
}