28-滑雪

问题描述

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

25

方法一：动态规划(DP)+深度搜索(DFS)

对于输入的每个点，找到从该点出发的最长路径。然后在所有点中找最大值。

求解从某一点出发的最长路径使用递归求解。
递归终止条件：找到了已经求出的从路径最长的点。
问题分解：从某一点出发的最长路径等于周围四个可以到达的点加1的最大值，即dp[x][y] = max(dp[i][j]) + 1。dp[x][y] 表示从点 x，y 开始的最长路径，dp[i][j] 表示 x，y 的四个邻居中比 x，y 低的点的最长路径。

#include <iostream>
using namespace std;

#define maxn 102
int dp[maxn][maxn], hh[maxn][maxn];		//hh表示各店的高度，dp表示从每个点开始的最长路径长度
int row, col, mov[][2] = { -1, 0, 1, 0, 0, 1, 0, -1 };//输入数据有row行，col列，mm表示从一个点向上下左右移动

bool check(int i, int j)
{
	return i >= 0 && i < row && j >= 0 && j < col;
}

//计算从x,y出发的最长路径
int DFS(int x, int y)
{
	if (dp[x][y])			//找到已经求出最短路径的节点为止
		return dp[x][y];
	int i, j, k, t, pathlen = 1;
	for (k = 0; k < 4; ++k)
	{
		i = x; j = y;
		i += mov[k][0]; j += mov[k][1];
		if (check(i, j) && hh[i][j] < hh[x][y])
		{
			t = 1 + DFS(i, j);
			if (t > pathlen) pathlen = t;
		}
	}
	return dp[x][y] = pathlen;
}

int main()
{
	int i, j, pathlen;
	cin >> row >> col;
	for (i = 0; i < row; ++i)
	{
		for (j = 0; j < col; ++j)
			cin >> hh[i][j];
	}
	pathlen = 1;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			dp[i][j] = DFS(i, j);
			if (pathlen < dp[i][j])
				pathlen = dp[i][j];
		}
	}
	cout << pathlen << endl;
	return 0;
}

方法二：“人人为我”式递推

dp(i,j) 表示从点 (i,j) 出发的最长滑行长度。一个点 (i,j) 如果周围没有比它低的点，dp(i,j) = 1。

将所有点按高度从小到大排序。每个点的 dp 值都初始化为1，从小到大遍历所有的点。经过一个点 (i,j) 时，用递推公式求 dp(i,j)，该点的 dp 值等于周围四个高度比该点低的 dp 值加 1 的最大值。

#include<iostream>
#include<algorithm>
using namespace std;

int  row, col;
int dp[102][102];
int hh[102][102];
int dir[4][2] = { { 1, 0 }, { 0, 1 }, { -1, 0 }, { 0, -1 } };

struct ski
{
	int x;
	int y;
	int h;
	bool operator<(const ski &c)const
	{
		return h<c.h;
	}
}s[10100];

bool check(int i, int j)
{
	return i >= 0 && i < row && j >= 0 && j < col;
}

int main()
{
	cin >> row >> col;
	int r = 0;
	int pathlen = 1;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			cin >> hh[i][j];
			dp[i][j] = 1;			//每个点的最长路径初始化为1
			s[r].x = i;
			s[r].y = j;
			s[r].h = hh[i][j];
			r++;
		}
	}
	sort(s, s + r);
	for (int i = 0; i <= r - 1; i++)
	{
		int x = s[i].x;
		int y = s[i].y;
		for (int j = 0; j<4; j++)
		{
			int xx = x + dir[j][0];
			int yy = y + dir[j][1];
			if (check(xx, yy) && hh[x][y]>hh[xx][yy])//经过一个点(x,y) 的时候 ，更新自己 
			{
				dp[x][y] = max(dp[x][y], dp[xx][yy] + 1);
				pathlen = max(pathlen, dp[x][y]);
			}
		}
	}
	cout << pathlen << endl;
	return 0;
}

方法三：“我为人人”式递推

dp(i,j) 表示从点 (i,j) 出发的最长滑行长度。一个点 (i,j)，如果周围没有比它低的点，dp(i,j) = 1。

将所有点按高度从小到大排序。每个点的 L 值都初始化为1，从小到大遍历所有的点。经过一个点 (i,j) 时，要更新他周围的，比它高的点的 L 值。

例如：
if(H(i+1,j) > H(i,j)) // H代表高度
L(i+1,j) = max(L(i+1,j),L(i,j)+1)

#include<iostream>
#include<algorithm>
using namespace std;

int  row, col;
int dp[102][102];
int hh[102][102];
int dir[4][2] = { { 1, 0 }, { 0, 1 }, { -1, 0 }, { 0, -1 } };
struct ski
{
	int x;
	int y;
	int h;
	bool operator<(const ski &c)const
	{
		return h<c.h;
	}
}s[10100];

bool check(int i, int j)
{
	return i >= 0 && i < row && j >= 0 && j < col;
}

int main()
{
	cin >> row >> col;
	int r = 0;
	int ans = 1;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			cin >> hh[i][j];
			dp[i][j] = 1;
			s[r].x = i;
			s[r].y = j;
			s[r].h = hh[i][j];
			r++;
		}
	}
	sort(s, s + r);
	for (int i = 0; i <r; i++)
	{
		int x = s[i].x;
		int y = s[i].y;
		for (int j = 0; j<4; j++)
		{
			int xx = x + dir[j][0];
			int yy = y + dir[j][1];
			if (check(xx, yy) && hh[x][y]<hh[xx][yy])
			{
				dp[xx][yy] = max(dp[xx][yy], dp[x][y] + 1);
				ans = max(ans, dp[xx][yy]);
			}
		}
	}
	cout << ans << endl;
	return 0;
}