POJ 1088滑雪

题意：给定一个二维数组，可以从数组的任一点出发，求一条最长的递增路径。

Input：行数r，列数c；之后r行c列的二维数组。

Output：递增路径的长度p

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

思路一：

对于任一点都有四种走法走到当前位置(注意边界情况)，所以对于当前点可以得到一个小于自己值的前提下已走的最大路径数的格走到当前格形成走到当前格的最大路径长度。

即：对于当前点无论周围的四个点怎么走取四点路径的最大值再走到自己+1。

定义当前点dp[i][j]为走到当前点的最长路径：

得到状态转移方程： dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i][j+1], dp[i+1][j])+1;

约束条件：array[i][j] > array[x][y] and (x, y) {(i-1,j), (i,j-1),(i,j+1),(i+1,j)} 。

复杂度：由于对于一个点最多只和当前点周围四个点有关系并得到从本点开始的最长路径，即本点的4个路径，走下去有n个所以估计为 (n)，需要有n个点的开头找最长路径。得复杂度： (n^2)。

使用记忆化搜索（递归）：

#include<iostream>
#include<string.h>

using namespace std;

const int MaxNum = 101;

int r, c; //行，列
int maxnum;
int map[MaxNum][MaxNum], dp[MaxNum][MaxNum];
int step[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; //对于当前格的四个方向

void getPathNum(int x, int y)
{
	int maxnum = 0;
	for(int i = 0; i < 4; ++i)
	{
		if(x+step[i][0]<r && x+step[i][0]>=0 && y+step[i][1]<c && y+step[i][1]>=0) //边界条件
		{
			if(map[x+step[i][0]][y+step[i][1]] < map[x][y])
			{
				if(!dp[x+step[i][0]][y+step[i][1]])
                    getPathNum(x+step[i][0],y+step[i][1]);
                if(dp[x+step[i][0]][y+step[i][1]] > maxnum)
                    maxnum = dp[x+step[i][0]][y+step[i][1]];
			}
		}
	}
	dp[x][y] = maxnum+1;
}

int main()
{
	while(cin>>r>>c)
	{
		maxnum = 0;
		memset(dp, 0, sizeof(dp));
		
		for(int i = 0; i < r; ++i)
			for(int j = 0; j < c; ++j)
				cin>>map[i][j];
		
		for(int i = 0; i < r; ++i)
		{
			for(int j = 0; j < c; ++j)
			{
				if(!dp[i][j])
					getPathNum(i, j);
				if(maxnum < dp[i][j])
					maxnum = dp[i][j];
			}
		}
		cout<<maxnum<<endl;
	}
	return 0;
}

思路二：

本题还可以转化为在满足约束条件下的经典动态规划模型：最长递增子序列。

我们可以考虑能走到当前点需要满足两个约束条件：

1>数值小于当前值 2>不考虑数值大小能走到当前点（上、下、左、右）

这样我们就可以对二维数组转化为带权值的点集排序（可建立struct一维数组或array[r*c][3]的数组），这样就满足数组的左边为点值小于当前点值（默认从小到大排序），这样就转化为不考虑数值大小能否可走到当前点的最长递增子序列问题。

得到状态转移方程： dp[i][j] = max(dp[x][y])+1;

约束条件：array[i][j] > array[x][y] and (x, y) {(i-1,j), (i,j-1),(i,j+1),(i+1,j)} 。

复杂度：对n个点排序，使用排序算法，排序的复杂度在 (nlgn)~ (n^2)之间；然后到每个点对比自己值小的点进行遍历，即最长递增子序列的复杂度 (n^2)；由大头公式得本题算法复杂度为 (n^2)。由上述简要分析可知思路一复杂度常数会小一些。实际也是思路一快一些。

使用迭代（递推）：

#include<stdio.h>
#include<iostream>
#include<algorithm>

using namespace std;

struct Node {
	int x,y;
	int val;
}a[10001];

Node node;

int i, j, n, m;

int cnt, maxn;

int dp[10001];

bool cmp(Node x, Node y)
{
	return x.val > y.val;
}

int max(int a, int b)
{
	return a > b ? a : b;
}

void dphuaxue()
{
	maxn = 1;
	for(i = 0; i < n * m; ++i)
	{
		dp[i] = 1;
	}
	for(i = 0; i < n * m; ++i)
	{
		for(j = 0; j < i; ++j)
		{
			if(a[j].val != a[i].val)
			{
				if((a[j].x + 1 == a[i].x && a[j].y == a[i].y) 
				   || (a[j].x == a[i].x && a[j].y + 1 == a[i].y) 
				   || (a[j].x == a[i].x && a[j].y - 1 == a[i].y) 
				   || (a[j].x - 1 == a[i].x && a[j].y == a[i].y))
					dp[i] = max(dp[i], dp[j] + 1);
			maxn = max(dp[i], maxn);
			}	
		}
	}
}

int main()
{
	cnt = 0;
	scanf("%d%d", &n, &m);
	for(i = 0; i < n; ++i)
	{
		for(j = 0; j < m; ++j)
		{
			scanf("%d", &node.val);
			node.x = i;
			node.y = j;
			a[cnt] = node;
			cnt++;
		}
	}
	sort(a, a + (n * m), cmp);
/*	for(i = 0; i < n * m; ++i)
	{
		printf("%d ", a[i].val);
	}
	printf("\n");
*/
	dphuaxue();
	printf("%d\n", maxn);
	return 0;
}

                                                                                                                                                                                            仅为学习交流

                                                                                                                                                                                               2018.12.13