POJ 1088

看完该题，第一个想法是，找到 数组中 最大的数，然后在其周围找一个仅次于它大小的数，然后这样循环下去，不过这样好像比较麻烦。当某点上下左右四个点 都是一样大时，需要保留四个方向的值。

后来采用 动态规划＋递归，用len[i][j] 表示从(i,j)点开始的最大深度，动态转移方程: len[i][j] = max(len[i-1][j],len[i+1][j],len[i][j-1],len[i][j+1])+1,也就是四个方向的最大值 再加1

#include <iostream>
using namespace std;

#define MAX 110

int R,C;
int map[MAX][MAX];
int len[MAX][MAX];
int dir[4][2] = {{0,1},{0,-1},{-1,0},{1,0}};

int dp(int i,int j){
    if(len[i][j]!=0)    return len[i][j];
    int s;
    int max = 0;
    for(int t=0;t<4;t++){
        int x = i+dir[t][0];
        int y = j+dir[t][1];
        if(x>=0&&x<R&&y>=0&&y<C&&map[i][j]>map[x][y]){
            s = dp(x,y);
            if(s>max)
                max = s;
        }
    }
    len[i][j] = max + 1;
    return len[i][j];
}

int main(){
    cin>>R>>C;
    int i,j;
    int temp = -1;
    memset(map,0,sizeof(map));
    memset(len,0,sizeof(len));
    for(i=0;i<R;i++){
        for(j=0;j<C;j++){
            cin>>map[i][j];
        }
    }
    for(i=0;i<R;i++){
        for(j=0;j<C;j++){
            len[i][j] = dp(i,j);
            if(len[i][j]>temp)
                temp = len[i][j];
        }
    }
    cout<<temp<<endl;
    return 0;
}

这里比较关键的一点是， 在dp里面，如果发现len[i][j]不为0，就要立即返回。因为len[i][j]表明该点已经更新过了，如果不加这步，必然是超时的，会导致算过的点重复算好几遍。