POJ3422 Kaka's Matrix Travels

一.原题链接：http://poj.org/problem?id=3422

二.题目大意：卡卡从一个N*N的矩阵的左上角走到右下角，走K次，每个格子只要走过一次，里面的数值会被吸收，求被吸收的最大值。

三,思路：一开始想DP K次，再想一想其实这是贪心，K>1就肯定能构造出一个不能AC的了。所以要用最小费用最大流，（它的反向弧决定了它其实不是贪心的)。严格来说，用最大费用最大流。

构图如下：

1.把一个点拆成2个点，之间连2条边，1条容量为1，花费为输入的花费（表示只能通过一次，取得花费）。另1条边容量为INF（为K的可以不自己建立超级源点），花费为0。（表示通过K次）

2.建立超级源点，容量K，花费0，和左上角的点相连。

3.每个点如果它右边或下边的点不超过N，就相连。

4.原图中每个点相连方法如下，假如p被拆为p, p'，q被拆为q, q'，p->q在原图中相连。则p‘->q。容量INF，花费0。

然后用SPFA求最长路，对其增广直至没有最长路。

求最长路的方法如下：

将所有费用取相反数，然后求最短路。

（当然你也可以反向松弛，但是由于这题存在权为0的边，而且还是超级源点和左上角的点相连的权就是0，这意味着你要先把这条边加权加1，然后减去K，减去K是因为它走了K次，这样就好麻烦。其实我一开始就这样的，也AC了，反向松弛的方法详细请看http://blog.csdn.net/h992109898/article/details/51057201这题是用最长路判正环，我当时就是用反向松弛的方法，不过我以后也不会再用，也不推荐用，取相反数多简单，还能处理特殊情况。）

四.代码：

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <cstdlib>

using namespace std;

const int INF = 0x3f3f3f3f,
          MAX_N = 55,
          MAX_SIZE = 5050;

class AdjList
{
public:
    int head[MAX_SIZE], cnt;
    struct Edge
    {
        int cost, cap, v, next;
    }edges[MAX_SIZE*20];

    AdjList()
    {
        cnt = 0;
        memset(head, -1, sizeof(head));
    }

    void addEdge(int u, int v, int cap, int cost)
    {
        edges[cnt].v = v, edges[cnt].cap = cap,
        edges[cnt].cost = cost, edges[cnt].next = head[u];
        head[u] = cnt++;

        edges[cnt].v = u, edges[cnt].cap = 0,
        edges[cnt].cost = -cost, edges[cnt].next = head[v];
        head[v] = cnt++;
    }
};

AdjList G;
int N, K, s, t;

void addNode(int i, int j, int cost)
{
    G.addEdge(i*N + j, i*N + j + N*N, 1, cost);
    G.addEdge(i*N + j, i*N + j + N*N, INF, 0);
    if(i + 1 < N)
        G.addEdge(i*N + j + N*N, (i+1)*N + j, INF, 0);
    if(j + 1 < N)
        G.addEdge(i*N + j + N*N, i*N + j + 1, INF, 0);
}

int dist[MAX_SIZE], pre[MAX_SIZE], path[MAX_SIZE];
bool SPFA(int s)
{
    bool inQue[MAX_SIZE];
    queue <int> que;
    int cur, v, i;

    memset(dist, INF, sizeof(dist));
    memset(inQue, 0, sizeof(inQue));
    memset(pre, -1, sizeof(pre));

    dist[s] = 0;
    que.push(s);
    inQue[s] = true;

    while(!que.empty()){
        cur = que.front();
        que.pop();
        inQue[cur] = false;
        for(i = G.head[cur]; i != -1; i = G.edges[i].next){
            v = G.edges[i].v;
            if(G.edges[i].cap && dist[v] > dist[cur] - G.edges[i].cost){
               dist[v] = dist[cur] - G.edges[i].cost;
               pre[v] = cur;
               path[v] = i;
               if(!inQue[v]){
                que.push(v);
                inQue[v] = true;
                }
            }
        }
    }
    return pre[t] != -1;
}

int ford_fulkerson(int s, int t)
{
    int sum = 0, u, v, minFlow, i, j;
    while(SPFA(s)){
        sum -= dist[t];
        minFlow = INF;
        for(u = pre[t], v = t;  u != -1; v = u, u = pre[u]){
            i = path[v];
            minFlow = min(minFlow, G.edges[i].cap);
        }

        for(u = pre[t], v = t;  u != -1; v = u, u = pre[u]){
            i = path[v];
            G.edges[i].cap -= minFlow;
            G.edges[i^1].cap += minFlow;
        }
    }
    return sum;
}

int main()
{
    freopen("in.txt", "r", stdin);
    int i, j, cost;

    scanf("%d%d", &N, &K);

    s = 2*N*N, t = 2*N*N - 1;
    G.addEdge(s, 0, K, 0);

    for(i = 0; i < N; i++)
        for(j = 0; j < N; j++){
            scanf("%d", &cost);
            addNode(i, j, cost);
        }

    printf("%d\n", ford_fulkerson(s, t));
    return 0;
}