【最短路】【动态规划】数字矩阵 rectangle

最新推荐文章于 2022-05-05 23:03:40 发布

jiangzh7

最新推荐文章于 2022-05-05 23:03:40 发布

阅读量598

点赞数

分类专栏：动态规划最短路/最小生成树

本文链接：https://blog.csdn.net/jiangzh7/article/details/8600327

版权

动态规划同时被 2 个专栏收录

92 篇文章 0 订阅

订阅专栏

最短路/最小生成树

21 篇文章 0 订阅

订阅专栏

本文介绍了一种使用最短路算法和动态规划解决数字矩阵中寻找从最上层到最下层最小路径和的问题。通过引入超级源和超级汇简化问题，并讨论了如何建图和优化Dijkstra算法。同时，提出了动态规划的解决方案，通过分步递推计算到达每个位置的最优值。

摘要由CSDN通过智能技术生成

数字矩形

rectangle.pascal/c/cpp

【题目描述】

给一个由数字组成的矩形，每次可以向左、向右、向下走，求一条从最上层的任意一个点走到最下层的任意一个点最小数字和的路径，输出其值。

【输入】

输入第一行包含两个数n, m，表示矩形的行数和列数。

接下来的n行每行有m个数，每个数表示矩形该位置上的值。

【输出】

输出最上层的任意一个点走到最下层的任意一个点的最小数字和的路径值。

【输出样例】

3 4

9 9 1 9

2 2 2 9

1 9 9 9

【输出样例】

【样例解释】

9 9 19

2 2 2 9

1 9 9 9

是最优方案

【数据规模】

对于20%的数据，n, m不超过10

对于40%的数据，n * m不超过500

对于所有数据，n不超过100，m不超过500，每个数字不超过1000000。

题目描述很简单

当时考试时想到用最短路做来着，不过由于建图卡住了，时间也不多了，就悲剧地深搜了。。。。。也就悲剧地30分了。。。。。

下来后决心用最短路写出来

由于是从第一行任意一点到最后一行任意一点，所以我们可以简化一下，加入 “ 超级源 ” 和 “ 超级汇 ” ，也就是用0号点跟第一行所有点连一条边，再把最后一行所有点和n*m+1 号点连一条边，这样我们就可以求 0 ~ n*m+1 号点的的最短路了

然后就是建图了，除了上面的，我们还需要在相邻点之间连边（也就是说，把以前每个点的权值放在了每条边上）

完了之后就可以dijkstra了，不过是要超时的，所以要用到堆优化，或者用 spfa 也行

下面是堆优 dijkstra 的的情况

cena测评

C++ AC Code

/*
http://blog.csdn.net/jiangzh7
By Jiangzh
*/
#include<cstdio>
#include<cstring>
#include<queue>
#include<utility>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
const int N=500+10;
const int V=500*100+10;
const int inf=0x3f3f3f3f;

int n,m;
int map[N][N];
struct link{int y,z;link *next;}*head[V];
int dist[V];
bool h[V];
typedef pair<int,int> pii;
priority_queue<pii,vector<pii>,greater<pii> > q;

void inlink(int x,int y,int z)
{
	link *node=new link;
	node->y=y;node->z=z;
	node->next=head[x];
	head[x]=node;
}

inline int pos(int a,int b){ return (a-1)*m+b; }

void build_map()
{
	for(int j=1;j<=m;j++) inlink(0,pos(1,j),map[1][j]);
	for(int i=1;i<n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			inlink(pos(i,j),pos(i+1,j),map[i+1][j]);
			if(j<m) inlink(pos(i,j),pos(i,j+1),map[i][j+1]);
			if(j>1) inlink(pos(i,j),pos(i,j-1),map[i][j-1]);
		}
	}
	for(int j=1;j<=m;j++) inlink(pos(n,j),n*m+1,0);
}

int main()
{
	freopen("rectangle.in","r",stdin);
	freopen("rectangle.out","w",stdout);
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) scanf("%d",&map[i][j]);
	build_map();
	memset(dist,0x3f,sizeof(dist));	dist[0]=0;
	q.push(make_pair(dist[0],0));
	while(!q.empty())
	{
		pii t=q.top();q.pop();
		int k=t.second;
		h[k]=true;
		for(link *node=head[k];node;node=node->next)
		{
			int y=node->y,z=node->z;
			if(h[y]) continue;
			if(dist[y]>dist[k]+z)
			{
				dist[y]=dist[k]+z;
				q.push(make_pair(dist[y],y));
			}
		}
	}
	printf("%d\n",dist[n*m+1]);
	return 0;
}

好了最短路的解法就完了，说实话，这其实是一种投机取巧的办法（能过就行了 ^_^）

那么用DP怎么写呢？

状态很容易想出来，用 f [ i ] [ j ] 表示到位置 ( i , j ) 的最优值，但是有三个方向我们怎么转移呢？

我一开始的想法是不能，但是还是试着写了些，代码大概如下（错误的）

for(int i=1;i<=n;i++)
	for(int j=1;j<=m;j++)
	{
		f[i][j]=min(f[i][j],f[i-1][j]+map[i][j]);
		if(j!=1) f[i][j]=min(f[i][j],f[i][j-1]+map[i][j]);
		if(j!=m) f[i][j]=min(f[i][j],f[i][j+1]+map[i][j]);
	}

但是这样就有一个很严重的问题了，动态规划必须无后效性，然而我们退 f [ i ] [ j ] 的时候居然用到了它后面还没有计算的 f [ i ] [ j + 1 ] ！显然是不对的！

那应该如何处理呢？

我们可以分步递推，也就是先把所有从上一层下来的情况推倒完，再推到所有从左边走过来的情况，再推到所有从右边走过来的情况，这样每次推到都是相对独立的，最后求一个最小值即可

cena测评（比最短路时间少了很多）

/*
http://blog.csdn.net/jiangzh7
By Jiangzh
*/
#include<cstdio>
#include<cstring>
#include<queue>
#include<utility>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
const int N=500+10;
const int inf=0x3f3f3f3f;

int n,m;
int map[N][N];
int f[N][N];

int main()
{
	freopen("rectangle.in","r",stdin);
	freopen("rectangle.out","w",stdout);
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) scanf("%d",&map[i][j]);
	memset(f,0x3f,sizeof(f));
	for(int j=0;j<=m;j++) f[0][j]=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++) f[i][j]=min(f[i][j],f[i-1][j]+map[i][j]);
		for(int j=2;j<=m;j++) f[i][j]=min(f[i][j],f[i][j-1]+map[i][j]);
		for(int j=m-1;j>0;j--) f[i][j]=min(f[i][j],f[i][j+1]+map[i][j]);
	}
	int ans=inf;
	for(int j=1;j<=m;j++) ans=min(ans,f[n][j]);
	printf("%d\n",ans);
	return 0;
}