就是用DP，DP[i][j]是在这个（i,j）位置作为起点的最长长度。

因为可能会超时，DP的话每次就是记录，然后就不用回溯了。

很简单的DFS里面的记忆化搜索。

#include <stdio.h>

#include <iostream>

#include <string.h>

#include <math.h>

#include <stdlib.h>

#include <queue>

#include <set>

#include <stack>

#include <algorithm>

using namespace std;

#define PI acos(-1.0)

#define INF 0x7fffffff

#define N 110

int n,m;

int dp[N][N];

int a[N][N];

int dx[4]={0,0,-1,1};

int dy[4]={1,-1,0,0};

int dfs(int i,int j)

{

    if(dp[i][j])

        return dp[i][j];

    int tep=0;

    for(int k=0;k<4;k++)

    {

        int aa=dx[k]+i;

        int bb=dy[k]+j;

        if(aa>=0&&bb>=0&&aa<n&&bb<m&&a[i][j]>a[aa][bb])

           {

               tep=max(tep,dfs(aa,bb));

           }

    }

    return dp[i][j]=tep+1;

}

int main()

{

    while(~scanf("%d%d",&n,&m))

    {

        memset(dp,0,sizeof(dp));

        for(int i=0;i<n;i++)

        {

            for(int j=0;j<m;j++)

            {

                scanf("%d",&a[i][j]);

            }

        }

        int ans=0;

        for(int i=0;i<n;i++)

        {

            for(int j=0;j<m;j++)

            {

                dp[i][j]=dfs(i,j);

            }

        }

        ans=0;

        for(int i=0;i<n;i++)

        {

            for(int j=0;j<m;j++)

            {

                ans=max(dp[i][j],ans);

            }

        }

        printf("%d\n",ans);

    }

    return 0;

}