hdu Kaka's Matrix Travels（最小费用最大流）

把题意写一下：  给你一个n*n的矩阵，每个格子都有一个非负整数，从左上角走到右下角，收集走过的数字，累加，但是只能向右或者向下走，走过之后数字就变为0，让你求从左上角到右下角，走k次之后，所得的最大值是多少。

典型的最小费用最大流入门题，只需在建图时，把源点到1的cap设成k，对走完一次变成0的处理时，只需拆点，拆成两条边，一条容量为1，权值为点权，另一条是跳板，容量为inf，费用为0，即可

****************************************************************************************************************

#include <stdio.h>
#include <stdlib.h>
#define M 200001
#define maxx 2000
#define Max(a, b) a > b ? a : b
#define Min(a, b) a < b ? a : b
#define inf (1 << 29)
struct T
{
    int u, v, val, next, cost;
} e[M];
int th;
int visit[M], pre[M], dis[M], que[M], g[M], pos[M], map[100][100];
void add(int u, int v, int val, int cost)
{
    e[th].u = u, e[th].v = v, e[th].val = val, e[th].cost = cost;
    e[th].next = g[u], g[u] = th++;
    e[th].u = v, e[th].v = u, e[th].val = 0, e[th].cost = -cost;
    e[th].next = g[v], g[v] = th++;
}
int spfa(int s, int t, int n)
{
    int i, u, v, k;
    for (i = 0; i <= n; i++)
    {
        pre[i] = -1, visit[i] = 0;
    }
    int head, tail;
    head = tail = 0;
    for (i = 0; i <= n; i++) dis[i] = -1;//求最小费用时这里得改成正无穷
    que[tail++] = s, pre[s] = s, dis[s] = 0, visit[s] = 1;
    while (head != tail)
    {
        int u = que[head++];
        visit[u] = 0;
        for (k = g[u]; k != -1; k = e[k].next)
        {
            v = e[k].v;
            if (e[k].val > 0 && dis[u] + e[k].cost > dis[v])//最大费用，求最小费用时这里的改符号
            {
                dis[v] = dis[u] + e[k].cost;
                pre[v] = u;
                pos[v] = k;
                if (!visit[v])
                {
                    visit[v] = 1;
                    que[tail++] = v;
                }
            }
        }
    }
    if (pre[t] != -1 && dis[t] > -1)//求最小费用时这里改成dit[t] < 正无穷
    {
        return 1;
    }
    return 0;
}
int MinCostFlow(int s, int t, int n)
{
    if (s == t)
    {
        //这里具体情况具体分析，如果有附加s跟t就不用，如果用数据中的点作为s跟t就得考虑
        //直接返回某个值。否则spfa里的队列会死循环。
    }
    int flow = 0, cost = 0;
    while (spfa(s, t, n))
    {
        int u, min = inf;
        for (u = t; u != s; u = pre[u])
        {
            min = Min(min, e[pos[u]].val);
        }
        flow += min;
        cost += dis[t] * min;
        for (u = t; u != s; u = pre[u])
        {
            e[pos[u]].val -= min;
            e[pos[u]^1].val += min;
        }
    }
    return cost;
}
int main()
{
    int n, m, i, j, k, s, t, u, v, cost, ans, x, num, tt;
    while (scanf("%d%d", &n, &m) - EOF)
    {
        for (i = 0, th = 0; i < n * n * 3 + 2; i++)
        {
            g[i] = -1;
        }
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                scanf("%d", &map[i][j]);
            }
        }
        num = n * n;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                x = i * n + j;
                add(x, x + num, 1, map[i][j]);
                add(x, x + num, inf, 0);
                if (i + 1 < n)
                {
                    add(x + num, x + n, inf, 0);
                }
                if (j + 1 < n)
                {
                    add(x + num, x + 1, inf, 0);
                }
            }
        }
        s = 2 * n * n, t = s + 1, n = t + 1;
        add(s, 0, m, 0);
        add(s - 1, t, m, 0);
        ans = MinCostFlow(s, t, t + 1);
        printf("%d
", ans);
    }
    return 0;
}