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;
}