nyoj10 滑雪

dp[

i][j]=max(四个方向点)+1； 四个方向上的点应该存在，且大于i,j，表示以i,j开始的点最长路径，递归的结束条件不用判断，因为

dp[][]最大数位置肯定 直接结束，随后次大值肯定能结束，以此类推，所以可以执行，但自下而上动态规划不好写。因为要确定这些数的大小，麻烦。

 

 

#include<iostream>

#include<memory.h>

using namespace std;

int dp[101][101];

int arr[101][101];

int c;

int r;

int x[]={0,1,0,-1};



int y[]={1,0,-1,0};





bool isvalid(int row,int col,int r_off,int c_off)  //找到没有超过矩阵范围，且在点比arr[i][j]大

{

    int newr=row+r_off;

    int newc=col+c_off;

    if(newr>=0&&newr<r&&newc>=0&&newc<c&&arr[row][col]<arr[newr][newc])

    {

         return true;



    

    

    }



    return false;



}



int fun(int row,int col)

{

    int tem=0;

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

    {

        if(isvalid(row,col,x[i],y[i]))

        {

             int tfun=fun(row+x[i],col+y[i]);

             if(tem<tfun)

             {

              tem=tfun;

             }

        

        

        }

    

      

    }

    return tem+1;

    







}

//备忘录，自顶向下动态规划，dp矩阵防止重复计算

int fun2(int row,int col)

{

    if(dp[row][col]>0) return dp[row][col];

    int tem=0;

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

    {

        if(isvalid(row,col,x[i],y[i]))

        {

             int tfun=fun(row+x[i],col+y[i]);

             dp[row+x[i]][col+y[i]]=tfun;

             if(tem<tfun)

             {

              tem=tfun;

             }

        

        

        }

    

      

    }

    return tem+1;

    







}

int main()

{

    int len;

    cin>>len;

    while(len--)

    {

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

        

        cin>>r>>c;

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

        {

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

          {

              cin>>arr[i][j];

          

          }

        

        }

        int max=0;

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

        {

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

          {

            int tem= fun2(i,j); //以i,j为开始的最长点数

            if(max<tem) max=tem;

          

          }

        

        }

        

    cout<<max<<endl;

    

    }







    return 0;





}