3422 (3477) Kaka's Matrix Travels：为什么不用DP？为什么需要拆点？

最新推荐文章于 2021-02-06 20:28:05 发布

Ordinary_yfz

最新推荐文章于 2021-02-06 20:28:05 发布

阅读量195

点赞数 1

分类专栏： ACM图论/网络流文章标签：网络

本文链接：https://blog.csdn.net/csyifanZhang/article/details/105133265

版权

ACM图论/网络流专栏收录该内容

42 篇文章 4 订阅

订阅专栏

题目翻译

在每个网格中都有一个非负数的N×N棋盘上，卡卡开始其矩阵行程为SUM =0。对于每次行程，卡卡都将一个车从左上方网格移动到右下方网格，请注意车只向右或向下移动。 Kaka将数字添加到车队访问的每个网格的SUM中，并将其替换为零。不难知道，卡卡首次旅行可获得的最高总和。现在，卡卡（Kaka）想知道在他的第K次旅行之后他可以获得的最大总和是多少。请注意，在K行进期间SUM是累积的。

思路分析

看到题目很容易想到搜索，搜索TLE很容易扩展到记忆话搜索，只需要记录每一次的路径，然后将最长的那条路全部置为0即可。~~于是我用了10分钟写完了这道题~~

#include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
#include<string.h>
using namespace std;

#define MAX 55
#define ll long long
#define inf 1e9

ll arr[MAX][MAX], N, K;
ll dp[MAX][MAX];
pair<ll,ll> pre[MAX][MAX];//pre:记录i，j是从哪里来的

ll dfs() {
	memset(dp, 0, sizeof(dp));
	memset(pre, -1, sizeof(pre));
	dp[1][1] = arr[1][1];
	for (ll i = 1; i <= N; i++) {
		for (ll j = 1; j <= N; j++) {
			if (dp[i - 1][j] + arr[i][j] > dp[i][j])//从上边来
				dp[i][j] = dp[i - 1][j] + arr[i][j], pre[i][j] = make_pair(i - 1, j);
			if (dp[i][j - 1] + arr[i][j] > dp[i][j])//从左边来
				dp[i][j] = dp[i][j - 1] + arr[i][j], pre[i][j] = make_pair(i, j - 1);
		}
	}
	return dp[N][N];
}

int main() {
	cin >> N >> K;
	for (ll i = 1; i <= N; i++)for (ll j = 1; j <= N; j++)cin >> arr[i][j];
	ll res = 0;
	
	for (ll i = 0; i < K; i++) {
		res += dfs();
		pair<ll, ll> t(N, N);
		arr[1][1] = 0;
		//从终点到起点，置0
		while (t.first != -1 && t.second != -1) {
			ll m = t.first, n = t.second;
			arr[m][n] = 0;
			t.first = pre[m][n].first, t.second = pre[m][n].second;
		}
	}
	if (K == 0) res = arr[1][1];
	cout << res << endl;
}

好吧完全没写完，DP其实是不能够的，贪心的策略存在着巨大的bug，考虑下面的图：

3 2
0 1 0
2 3 4
5 0 0
第一次取2->3->4
第二次取5
但最优解是
第一次取1->3->4
第二次取2->5

每次贪心的选择最长路径其实往往不能得到最优解。那么应该如何是好？答案是最小费用流基础讲解点这里，网络流的算法可以称之为万金油，只要图建的好，大多问题都解的了，唯一美中不足的一点是最小费用流的spfa，他死了。~~跑题了~~

最重要的现在就是如何建图了，我们有三个地方需要考虑：

以何为点？以何为边？
最多走 $K$ 次，如何限制这个走的次数。如果我们设置各边容量为1（大多数是这样设的），那么就需要每次跑完费用流，将对应的边置0，这与DP无异，我们需要一个更好的方法。
每次走完一个点要把他的费用置为0，也就是再走也不会给 $S U M$ 值增加。

直接拿别人题解上的一个图来
在这里插入图片描述
我们先说建图的方法，然后再说为什么一定要这样做，如果不做会怎么样

首先以矩形的每个块为点，将一个点分成两部分，然后点 $x, x^{'}$ 之间，有一条花费为cost的边，k-1条花费为0的边（建模经过一次之后清零该位置元素），点到相邻位置的可达点连一条(k,0)的边，转移位置并不需要花费，但是不能经过k次以上，类似的从源点s连一条（k，0）的边到左上角，右下角连一条（k，0）的边到汇点。注意所有花费都取得相反数，这样求的最小花费是最小的负数，我们取相反数即最大的花费了。

如果我们不拆分点，那么可以以边的末尾点的花费作为边的花费来建图：
在这里插入图片描述
乍一看好像也挺合理的，但是请注意，此时我们从2-4之后，2-4确实没有花费不为0的变了，好像4的花费清零了一样，然饿3这里仍然存在去往4的带花费的边，由此可见花费不应该绑定在相邻点的连边上，而应该绑定在点上，点一旦被经过，就清零。如何达到这个目标?其实这就相当于给点加了限制，而网络流处理点的限制一般都会拆点，比如在点上有流量的限制的时候，就需要
在这里插入图片描述
同样的，这里我们也可以拆点，拆成上面那样，就可以将每个点只在第一次经过时有值的事件建模了。

~~哎，打个费用流调了一个小时，这个速度怎么参加夏令营~~

#include<iostream>
#include<string.h>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;

#define MAX 5005
#define ll long long
#define inf 1e10

struct edge {
	ll to, cap, rev, cost;
	edge(ll a = 0, ll b = 0, ll c = 0, ll d = 0) { to = a, cap = b, rev = c, cost = d; }
};

vector<edge> G[MAX];

ll N, K, arr[55][55];
ll vis[MAX], pre1[MAX], pre2[MAX], dist[MAX], maxflow, minCost, minf[MAX];

void addEdge(ll from, ll to, ll cap, ll cost) {
	G[from].push_back(edge(to, cap, G[to].size(), cost));
	G[to].push_back(edge(from, 0, G[from].size() - 1, -cost));
}

ll spfa(ll s, ll t) {
	memset(vis, 0, sizeof(vis));
	for (ll i = 0; i < MAX; i++)dist[i] = inf;
	//fill(dist, dist + MAX, inf);
	queue<ll> q; vis[s] = 1; q.push(s); minf[s] = inf; dist[s] = 0;
	while (!q.empty()) {
		ll id = q.front(); q.pop(); vis[id] = 0;
		for (unsigned i = 0; i < G[id].size(); i++) {
			edge & e = G[id][i];
			if (e.cap > 0 && dist[e.to] > dist[id] + e.cost) {
				dist[e.to] = dist[id] + e.cost;
				pre1[e.to] = id; pre2[e.to] = i;
				minf[e.to] = min(minf[id], e.cap);
				if (!vis[e.to]) {
					q.push(e.to); vis[e.to] = 1;
				}
			}
		}
	}
	return dist[t] != inf;
}

void update(ll s, ll t) {
	ll x = t;
	while (x != s) {
		ll Vid = pre1[x], Eid = pre2[x];
		G[Vid][Eid].cap -= minf[t];
		G[x][G[Vid][Eid].rev].cap += minf[t];
		x = Vid;
	}
	maxflow += minf[t];
	minCost += minf[t] * dist[t];
}

void minCostFlow(ll s, ll t) {
	ll i = 0;
	while (i++ < K) {
		spfa(s, t);
		update(s, t);
	}
}

int main() {
	cin >> N >> K;
	for (ll i = 0; i < N; i++)for (ll j = 0; j < N; j++)cin >> arr[i][j];
	ll s = 0, t = MAX - 1;
	//建图 s:0 t:MAX
	//1-N*N:真实点
	//N*N+1-2N*N：拆分点
	for (ll i = 0; i < N; i++) {
		for (ll j = 0; j < N; j++) {
			ll id = i * N + j + 1;
			addEdge(id, id + N * N, 1, -arr[i][j]);//花费取反
			addEdge(id, id + N * N, K - 1, 0);
			if (j + 1 < N)addEdge(id + N * N, id + 1, K, 0);//从拆分点连向的右侧的原始点
			if (i + 1 < N)addEdge(id + N * N, id + N, K, 0);//从拆分点连向下侧的原始点
		}
	}
	addEdge(s, 1, K, 0); addEdge(2 * N*N, t, K, 0);
	minCostFlow(s, t);
	cout << -minCost << endl;
}