DP:Skiing（POJ 1088）

　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　 北大教你怎么滑雪

　　题目是中文的，要读懂题目其实不难

　　其实这道题挺经典的，我们这样想，他最终要找到一个最大值，这个时候我们就想到要用动态规划

　　那怎么用呢？我们同时这样想，由于滑雪的最高点我们不能立马找出来，而且也不一定是最高点就是最长路径的起点。所以我们要不断搜索，我们知道对图的搜索有BFS和DFS，从题目上看，我们应该需要从头走到尾直到找不到路为止，所以我们这题要用DFS，同时，结合我们要用动态规划的思想，我们应该再弄一个矩阵，来保存前面搜索过的路经长，一个点的邻接点如果还没有被搜索过，我们就进入搜索，否则，我们应该直接引用前面已经保存过的路经长，并把搜索过的节点进行标记。

　　而这样的方法，就是经典的记忆化搜索方法

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX(a,b) (a)>(b)?(a):(b)

typedef struct map
{
    int Known;
    int dist;
}Dist_Map;

Dist_Map dp[100][100];
int Input_Map[100][100];

int Search(const int, const int, int *const, int, int);

int main(void)
{
    int R, C, i, j, Max_Length;
    while (~scanf("%d%d",&R,&C))
    {
        Max_Length = 0;

        memset(dp, 0, sizeof(dp));
        for (i = 0; i < R; i++)//读图
            for (j = 0; j < C; j++)
                scanf("%d", &Input_Map[i][j]);

        for (i = 0; i < R; i++)
            for (j = 0; j < C; j++)
                if (!dp[i][j].Known)
                    Search(R, C, &Max_Length, i, j);
        printf("%d
", Max_Length);
    }
    return 0;
}

int Search(const int R, const int C, int *const Max_Length, int py, int px)
{
    int re_ans;
    dp[py][px].Known = 1; dp[py][px].dist = 1;

    if (py - 1 >= 0 && Input_Map[py][px] > Input_Map[py - 1][px])
    {
        if (!dp[py - 1][px].Known)
            re_ans = Search(R, C, Max_Length, py - 1, px);
        else
            re_ans = dp[py - 1][px].dist;
        dp[py][px].dist = MAX(re_ans + 1, dp[py][px].dist);
        
    }
    if (py + 1 < R && Input_Map[py][px] > Input_Map[py + 1][px])
    {
        if (!dp[py + 1][px].Known)
            re_ans = Search(R, C, Max_Length, py + 1, px);
        else
            re_ans = dp[py + 1][px].dist;
        dp[py][px].dist = MAX(re_ans + 1, dp[py][px].dist);
    }
    if (px - 1 >= 0&& Input_Map[py][px] > Input_Map[py][px - 1])
    {
        if (!dp[py][px - 1].Known)
            re_ans = Search(R, C, Max_Length, py, px - 1);
        else
            re_ans = dp[py][px - 1].dist;
        dp[py][px].dist = MAX(re_ans + 1, dp[py][px].dist);
    }
    if (px + 1 < C && Input_Map[py][px] > Input_Map[py][px + 1])
    {
        if (!dp[py][px + 1].Known)
            re_ans = Search(R, C, Max_Length, py, px + 1);
        else
            re_ans = dp[py][px + 1].dist;
        dp[py][px].dist = MAX(re_ans + 1, dp[py][px].dist);
    }

    *Max_Length = MAX(dp[py][px].dist, *Max_Length);
    return dp[py][px].dist;
}