POJ 3422 Kaka's Matrix Travels(拆點+最大流)


題目鏈接:點擊打開鏈接

題意:給一個nXn的矩陣, 每個點有一個值, 讓你從(1,1)走到(n,n)走k次, 每次只能向右或者向下走, 走到一個數字, 就得到那個值, 並且這個地方走第二次的時候不會再次獲得該值, 求能得到的最大值。

思路:

走k次這限制我們可以用流量來解決, 關鍵是費用問題, 解決方法是拆點 —— 解決結點容量或者費用的通法。

細節參見代碼:

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#define Max(a,b) ((a)>(b)?(a):(b))
#define Min(a,b) ((a)<(b)?(a):(b))
using namespace std;
typedef long long ll;
typedef long double ld;
const ld eps = 1e-9, PI = 3.1415926535897932384626433832795;
const int mod = 1000000000 + 7;
const int INF = 0x3f3f3f3f;
// & 0x7FFFFFFF
const int seed = 131;
const ll INF64 = ll(1e18);
const int maxn = 55;
struct Edge {
int from, to, cap, flow, cost;
};

struct MCMF {
int n, m, s, t;
vector<Edge> edges;
vector<int> G[maxn*maxn*10];
int inq[maxn*maxn*10]; // 是否在隊列中
int d[maxn*maxn*10]; // Bellman-Ford
int p[maxn*maxn*10]; // 上一條弧
int a[maxn*maxn*10]; // 可改進量

void init(int n) {
this->n = n;
for(int i = 0; i < n; i++) G[i].clear();
edges.clear();
}

void AddEdge(int from, int to, int cap, int cost) {
edges.push_back((Edge){from, to, cap, 0, cost});
edges.push_back((Edge){to, from, 0, 0, -cost});
m = edges.size();
G[from].push_back(m-2);
G[to].push_back(m-1);
}

bool BellmanFord(int s, int t, int& flow, int& cost) {
for(int i = 0; i < n; i++) d[i] = INF;
memset(inq, 0, sizeof(inq));
d[s] = 0; inq[s] = 1; p[s] = 0; a[s] = INF;

queue<int> Q;
Q.push(s);
while(!Q.empty()) {
int u = Q.front(); Q.pop();
inq[u] = 0;
for(int i = 0; i < G[u].size(); i++) {
Edge& e = edges[G[u][i]];
if(e.cap > e.flow && d[e.to] > d[u] + e.cost) {
d[e.to] = d[u] + e.cost;
p[e.to] = G[u][i];
a[e.to] = min(a[u], e.cap - e.flow);
if(!inq[e.to]) { Q.push(e.to); inq[e.to] = 1; }
}
}
}
if(d[t] == INF) return false;
flow += a[t];
cost += d[t] * a[t];
int u = t;
while(u != s) {
edges[p[u]].flow += a[t];
edges[p[u]^1].flow -= a[t];
u = edges[p[u]].from;
}
return true;
}

// 需要保證初始網絡中沒有負權圈
int Mincost(int s, int t) {
int cost = 0, flow = 0;
while(BellmanFord(s, t, flow, cost));
return cost;
}

};

MCMF g;
int T, n, k;
struct node {
int v, id;
}a[maxn][maxn];
int main() {
while(~scanf("%d%d",&n,&k)) {

int cnt = 0;
for(int i=1;i<=n;i++) {
for(int j=1;j<=n;j++) {
scanf("%d",&a[i][j].v);
a[i][j].id = ++cnt;
}
}
g.init(2 * cnt + 10);
for(int i=1;i<=n;i++) {
for(int j=1;j<=n;j++) {
g.AddEdge(a[i][j].id, a[i][j].id+cnt, 1, -a[i][j].v);
g.AddEdge(a[i][j].id, a[i][j].id+cnt, INF, 0);
if(i < n) g.AddEdge(a[i][j].id+cnt, a[i+1][j].id, INF, 0);
if(j < n) g.AddEdge(a[i][j].id+cnt, a[i][j+1].id, INF, 0);
}
}
int s = 2 * cnt + 1;
int t = 2 * cnt + 2;
g.AddEdge(s, a[1][1].id, k, 0);
g.AddEdge(a[n][n].id+cnt, t, k, 0);
printf("%d\n",-g.Mincost(s, t));
}
return 0;
}




注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com