POJ-1088滑雪，典型的动态规划题，与NYOJ-10skiing一样，但NYOJ上时限是3s,用搜索可以过，但在POJ上就超时了~~

滑雪

Time Limit: 1000MS		Memory Limit: 65536k
		http://poj.org/problem?id=1088

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

25

Source

SHTSC 2002

   看到POJ上有这道题我就笑了，这跟我在南阳oj(NYOJ)上做的”skiing“一样，NYOJ上难度为5，当时用搜索做出来还蛮激动的，因为看到数据范围并不是很大，用搜索应该可以过，答案倒是立马出来了，但毫无疑问-超时，这里时限是1s，只能换一种思路了；

   动归是大一寒假集训学的，学长发了一个PPT里面包含了POJ上大部分动归题思路代码详解，来看它所提供的两种思路：

  (1)

       

   (2) 

        

      思路一和二都是差不多的，它只给出了思路，但代码实现起来可能有点困难，我们可以用结构体将坐标高度存放起来，按高度sort排序，然后从小到大遍历判断周围的点的高度关系，然后再用以上两种思路任何一种都可以求出答案；

       

     下面来看超时搜索代码：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
int a[100][100],maxn;
void dfs(int x,int y,int s,int h,int l)
{
    if(x<h&&y<l&&a[x][y]!=0)//判断边界条件，然后往四个方向搜索下去；
    {
        if(a[x-1][y]>a[x][y])
            dfs(x-1,y,s+1,h,l);
        if(a[x][y-1]>a[x][y])
            dfs(x,y-1,s+1,h,l);
        if(a[x+1][y]>a[x][y])
            dfs(x+1,y,s+1,h,l);
        if(a[x][y+1]>a[x][y])
            dfs(x,y+1,s+1,h,l);
        maxn=max(maxn,s);
    }
}
int main()
{
    int hang,lie,i,j;
    scanf("%d%d",&hang,&lie);
    for(i=0; i<hang; i++)
        for(j=0; j<lie; j++)
            scanf("%d",&a[i][j]);
    maxn=0;
    for(i=0; i<hang; i++)
        for(j=0; j<lie; j++)
            dfs(i,j,1,hang,lie);
    printf("%d\n",maxn);
    return 0;
}//看起来代码简短易懂，但就是超时了；；

      AC代码：

<span style="color:#ff0000;">#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
const int N=10000+10;
struct node
{
    int x,y,h;//坐标及高度
} a[N];
int cmp(node a,node b)//按高度排序；
{
    return a.h<b.h;
}
int d[110][110],dp[110][110];
int main()
{
    int hang,lie,i,j,k=0;
    scanf("%d%d",&hang,&lie);
    for(i=1; i<=hang; i++)
        for(j=1; j<=lie; j++)
        {
            a[++k].x=i,a[k].y=j;
            scanf("%d",&d[i][j]);
            dp[i][j]=1;
            a[k].h=d[i][j];
        }
    sort(a+1,a+k+1,cmp);
    int maxx=0;
    for(i=1; i<=k; i++)//这里用的是思路一，人人为我型；
    {
        if(d[a[i].x][a[i].y]>d[a[i].x+1][a[i].y])判断旁边四个方向的高度关系，然后递推公式如下；
            dp[a[i].x][a[i].y]=max(dp[a[i].x][a[i].y],dp[a[i].x+1][a[i].y]+1);
        if(d[a[i].x][a[i].y]>d[a[i].x-1][a[i].y])
            dp[a[i].x][a[i].y]=max(dp[a[i].x][a[i].y],dp[a[i].x-1][a[i].y]+1);
        if(d[a[i].x][a[i].y]>d[a[i].x][a[i].y+1])
            dp[a[i].x][a[i].y]=max(dp[a[i].x][a[i].y],dp[a[i].x][a[i].y+1]+1);
        if(d[a[i].x][a[i].y]>d[a[i].x][a[i].y-1])
            dp[a[i].x][a[i].y]=max(dp[a[i].x][a[i].y],dp[a[i].x][a[i].y-1]+1);
        maxx=max(dp[a[i].x][a[i].y],maxx);
    }
    printf("%d\n",maxx);
    return 0;
}</span>