poj 1088 滑雪 深搜（谁说是DP了！）

滑雪

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 72671		Accepted: 26825

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

===================================================================================

题目大意：中文题不解释。

解题思路：

老实说我是查简单DP找到这道题的，但是做着做着，就做成深搜了，因为传统DP时间效率O(10^8)，判超时。

先按DP思路来，DP需要打一张状态表，横轴是下降路径的最后一个点，纵轴是为路径寻找新点的次数，状态值是最后一个点为点n时对应的最长路径长度。

用上一行生成下一行时，逐个点尝试上下左右方向是否有高度更低且更新后比原状态值更大的点，符合条件则更新即覆盖旧路径。

一张图最多100*100个点，故打DP表时间效率O(10^8)，1000ms的边缘时间效率本来应该在O(10^9)左右，既然超时看来是左非右了。

先看看我用DP最后的挣扎。

#include<cstdio>

const int N = 100;
int r, c, g[N][N], dp[2][N][N];             //N^4个int铁定爆内存，于是用了滚动数组，只保存最后两行DP状态表
int main()
{
    int i, j, k, oki = 0, newDp, i0, i1;    //把多次使用的变量集中定义，能省点时间就省一点吧
    bool ok;
    scanf("%d%d", &r, &c);
    for( i = 0 ; i < r ; i++ )
        for( j = 0 ; j < c ; j++ )
            scanf("%d", &g[i][j]);
    for( i = 1 ; i < r*c ; i++ )            //逐行打DP状态表
    {
        ok = true;                          //默认已没有更优的路径
        for( j = 0 ; j < r ; j++ )
            for( k = 0 ; k < c ; k++ )
            {
                i0 = (i-1)&1;               //上一行DP状态
                i1 = i&1;                   //将生成的DP状态
                newDp = dp[i0][j][k]+1;     //准备填写的新状态值
                if( k > 0 && g[j][k-1] < g[j][k] && dp[i0][j][k-1] < newDp && dp[i1][j][k-1] < newDp )//高度更低的点，且可更新
                {
                    dp[i1][j][k-1] = newDp; //更新状态值
                    ok = false;             //标记还可能有更优路径
                }
                if( k < c-1 && g[j][k+1] < g[j][k] && dp[i0][j][k+1] < newDp && dp[i1][j][k+1] < newDp )
                {
                    dp[i1][j][k+1] = newDp;
                    ok = false;
                }
                if( j > 0 && g[j-1][k] < g[j][k] && dp[i0][j-1][k] < newDp && dp[i1][j-1][k] < newDp )
                {
                    dp[i1][j-1][k] = newDp;
                    ok = false;
                }
                if( j < r-1 && g[j+1][k] < g[j][k] && dp[i0][j+1][k] < newDp && dp[i1][j+1][k] < newDp )
                {
                    dp[i1][j+1][k] = newDp;
                    ok = false;
                }
            }
        if(ok)
            break;                          //没有更优路径则结束打表
        oki++;                              //打表行数加1
    }
    int ans = 0;
    for( i = 0 ; i < r ; i++ )
        for( j = 0 ; j < c ; j++ )
            if( dp[oki&1][i][j] > ans )
                ans = dp[oki&1][i][j];      //在DP状态表的最后一行找最优状态值
    printf("%d\n", ans+1);
    return 0;
}

嗯太无情了。

那么看看深搜，遍历起点，向高度更低的各点扩散，无法扩散的点记状态值即路径长度为1。

在回溯到起点的过程中每个点取四个方向扩散点的最大状态值再加1作为自己的状态值。

遍历起点时已经拥有状态值的起点直接返回状态值，不再重复搜索。不重复搜索也就是这道题用深搜在时间效率上巨大优势的源头了。

令人发指的线性时间效率O(10^4)。

最后遍历N*N的状态值记录数组，找最大值。

//Memory: 456K	Time: 0MS

#include<cstdio>

const int N = 100;                           //下面的扩散就是搜索，因为有平面图，我觉得说扩散更形象好理解点
int r, c, g[N][N], dp[N][N];                 //dp数组存各点最优状态值

int DP(int j, int k)
{
    if(dp[j][k])                             //已被扩散过的点直接返回上一次算出的状态值
        return dp[j][k];
    int t = 0;
    if( k > 0 && g[j][k-1] < g[j][k] )       //向上下左右四个方向尝试扩散
    {
        int tmp = DP(j,k-1);                 //进行扩散，或取上一次扩散得到的状态值
        if(tmp > t)                          //回溯时找到扩散点的最大状态值
            t = tmp;
    }
    if( k < c-1 && g[j][k+1] < g[j][k] )
    {
        int tmp = DP(j,k+1);
        if(tmp > t)
            t = tmp;
    }
    if( j > 0 && g[j-1][k] < g[j][k] )
    {
        int tmp = DP(j-1,k);
        if(tmp > t)
            t = tmp;
    }
    if( j < r-1 && g[j+1][k] < g[j][k] )
    {
        int tmp = DP(j+1,k);
        if(tmp > t)
            t = tmp;
    }
    return dp[j][k] = t+1;                   //给点赋状态值，回溯
}

int main()
{
    scanf("%d%d", &r, &c);
    for( int i = 0 ; i < r ; i++ )
        for( int j = 0 ; j < c ; j++ )
            scanf("%d", &g[i][j]);
    for( int j = 0 ; j < r ; j++ )           //遍历起点确保每个点都扩散过
        for( int k = 0 ; k < c ; k++ )
            DP(j,k);
    for( int i = 0 ; i < r ; i++ )           //遍历dp数组找最优状态值即最大值
        for( int j = 0 ; j < c ; j++ )
            if( dp[i][j] > dp[0][0] )
                dp[0][0] = dp[i][j];
    printf("%d\n", dp[0][0]);
    return 0;
}

我深搜函数都没用dfs起名可见我对DP还怀有深深地执念与遗憾。

哦，poj破百了。