POJ1088滑雪(dp)

最新推荐文章于 2019-09-22 09:45:40 发布

原创最新推荐文章于 2019-09-22 09:45:40 发布 · 207 阅读

0 ·

CC 4.0 BY-SA版权

ACM 同时被 2 个专栏收录

130 篇文章

订阅专栏

24 篇文章

订阅专栏

本文介绍了一种寻找二维数组中从任意点出发所能达到的最长递减排列路径的方法。通过动态规划思想，采用递归方式预计算每个点的最长路径长度，并记录下来避免重复计算，最终找出所有点中的最长路径。

滑雪

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 96422		Accepted: 36568

Description

Michael喜欢滑雪百这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

 1  2  3  4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

Input

输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。

Output

输出最长区域的长度。

Sample Input

5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

Sample Output

Source

SHTSC 2002

解题思路:根据要求，可以枚举每个点，然后判一下上下左右要走长度取max，所以dp转移方程是

dp[i][j]=max(dp[i-1][j],dp[i+1][j],dp[i][j-1],dp[i][j+1])+1

#include<iostream>    
#include<cstdio>  
#include<stdio.h>  
#include<cstring>    
#include<cstdio>    
#include<climits>    
#include<cmath>   
#include<vector>  
#include <bitset>  
#include<algorithm>    
#include <queue>  
#include<map>  
using namespace std;

int x, n, m;
int dix[5] = { 1,0,-1,0 };
int diy[5] = { 0,1,0,-1 };
int a[105][105], b[105][105];
int check(int x, int y)
{
	int i;
	if (b[x][y] > 0)
	{
		return b[x][y];
	}
	for (i = 0; i < 4; i++)
	{
		if (a[x][y] > a[x + dix[i]][y + diy[i]]&& (x + dix[i]) >= 1 && (x + dix[i]) <= n && (y + diy[i]) >= 1 && (y + diy[i]) <= m)
		{
			check(x + dix[i], y + diy[i]);
			b[x][y] = max(b[x][y], b[x + dix[i]][y + diy[i]]+ 1);
		}
		else
		{
			b[x][y] = max(b[x][y], 1);
		}
	}
}
int main()
{
	int i, j, k;
	cin >> n >> m;
	int ans = 0;
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= m; j++)
		{
			cin >> a[i][j];
		}
	}
	memset(b, 0, sizeof(b));
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= m; j++)
		{
			for (k = 0; k < 4; k++)
			{
				if (a[i][j] > a[i + dix[k]][j + diy[k]]&&(i+dix[k])>=1&&(i+dix[k])<=n&&(j+diy[k])>=1&&(j+diy[k])<=m)
				{
					check(i + dix[k], j + diy[k]);
					b[i][j] = max(b[i][j], b[i + dix[k]][j + diy[k]]+1);
				}
				else
				{
					b[i][j] = max(b[i][j], 1);
				}
			}
		}
	}
	ans = 0;
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= m; j++)
		{
			ans = max(ans, b[i][j]);
		}
	}
	cout << ans << endl;
}