poj3422(最小费用流 + 拆点）

题目大概意思为有一个N × N矩阵，每个格子里都有一个非负数，一辆车从左上方的网格移动到右下方的网格k次（车只向右或向下移动）。每次访问格子后，其替换为0，且将其加入到金额中。求第k次旅行后能得到的最大金额是多少。

首先我们需要把求最大金额转化为求最小费用流，我们便用 1000 - 金额 来表示 金额 ， 这样便可以用最小费求解（由于每次从起点到终点必定经过 (2 * N - 1) 个点，因此可以【实际金额和 = （2 * N - 1） * 1000 - 转化后的金额和】来求）。

然后便是考虑怎么建立边，首先对于每个顶点，我们进行拆开，连接一条容量为1，费用为 1000 - 金额 的边，再连接一条容量足够大，费用为 1000 - 0 的边（这样可以确保，一个点的金额只会加入一次，且下次还能使用该点）
其次我们把每个顶点和其右边和下边的点分别连接一条容量足够大，费用为0的边，使车能顺利从起点开到终点

最后就是正常的最小费用流套模板

（只要就是如何构建图比较需要思考，其他套模板即可）

#include <iostream>
#include <stdio.h>
#include <utility>
#include <stdlib.h>
#include <vector>
#define INF 100000005
using namespace std;
vector<pair<int, int> > flag1;
vector<pair<int, int> > flag2;
int N, K, data[55][55];
struct edge
{
    int to, cap, coust, rev;
    edge(int t, int c, int s, int r)
    {
        to = t; cap = c; coust = s; rev = r;
    }
};
vector<struct edge> ddd[5005];
int dist[5005];
int prev[5005];
int prep[5005];
void add_edge(int from, int to, int cap, int coust)
{
    ddd[from].push_back(edge(to, cap, coust, ddd[to].size()));
    ddd[to].push_back(edge(from, 0, -coust, ddd[from].size() - 1));
}
int min_coust(int from, int to, int flow)
{
    int res = 0;
    while(flow > 0)
    {
        fill(dist, dist + N * N * 2, INF);
        dist[from] = 0;
        bool flag = true;
        while(flag)
        {
            flag = false;
            for(int i = 0; i < 2 * N * N; i++)
            {
                if(dist[i] != INF)
                {
                    for(int j = 0; j < ddd[i].size(); j++)
                    {
                        struct edge e = ddd[i][j];
                        if(e.cap != 0 && dist[i] + e.coust < dist[e.to])
                        {
                            flag = true;
                            dist[e.to] = dist[i] + e.coust;
                            prev[e.to] = i;
                            prep[e.to] = j;
                        }
                    }
                }
            }
        }
        int d = flow;
        for(int i = to; i != from; i = prev[i])
        {
            d = min(d, ddd[prev[i]][prep[i]].cap);
        }
        for(int i = to; i != from; i = prev[i])
        {
            ddd[prev[i]][prep[i]].cap -= d;
            ddd[i][ddd[prev[i]][prep[i]].rev].cap += d;
        }
        res = res - dist[to] * d + (N + N - 1) * 1000 * d;
        flow = flow - d;
    }
    return res;
}
int main()
{
    scanf("%d %d", &N, &K);
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            scanf("%d", &data[i][j]);
        }
    }

    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            add_edge(i * N + j, N * N + i * N + j, 1, 1000 - data[i][j]);
            add_edge(i * N + j, N * N + i * N + j, 20, 1000);
            if(j + 1 < N)
            {
                add_edge(N * N + i * N + j, i * N + j + 1, 20, 0);
            }
            if(i + 1 < N)
            {
                add_edge(N * N + i * N + j, (i + 1) * N + j, 20, 0);
            }
        }
    }
    printf("%d\n", min_coust(0, N * N * 2 - 1, K));
}