滑雪

NowCoder喜欢滑雪，因为滑雪的确很刺激。为了获得速度，必须从高处往低处滑。现在知道某片区域的海拔，如下所示
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是最长的一条。
现在给出区域的海拔，你能帮忙计算最长的滑道有多长吗？

输入描述:

输入包含多组数据。

每组数据的第一行包含两个正整数m和n (1≤m, n≤100)，紧接着是m*n的海拔矩阵，包含各个点的高度h (1≤h≤10000)。

输出描述:

对应每一组数据，输出该区域最长的滑道长度。

输入例子:

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
2 2
1 1
1 1

输出例子:

25
1
解题

DFS

记录中间结果
不记录中间结果

import java.util.*;
public class Main1{
    public static void main(String [] args){
        Scanner in = new Scanner(System.in);
        int m,n;
        int[][] A;
        int[][] value;
        int Max = -1;
        int subMax = -1;
        while(in.hasNext()){
            Max = -1;
            subMax = -1;
            m = in.nextInt();
            n = in.nextInt();
            A = new int[m][n];
            value = new int[m][n];
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                    A[i][j] = in.nextInt();
                    value[i][j] = -1;
                }
            }
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                    DFS(A,value,i,j,m,n);
                    subMax = value[i][j];
                    Max = Max>subMax?Max:subMax;
                }
            }
            System.out.println(Max+1);
            
        }
        in.close();
        
    }
    private static int  DFS(int[][] A,int[][] value,int x,int y,int row,int col){
        if(x<0 || x>=row || y<0 || y>=col){
            return 0;
        }
        if(value[x][y]!=-1){
            return value[x][y];
        }
        int len1 = 0;
        int len2 = 0;
        int len3 = 0;
        int len4 = 0;
        
        if(x-1>=0 && A[x-1][y] < A[x][y]){
            if(value[x-1][y]!=-1){
                len1 = value[x-1][y] + 1;
            }else
                len1 = DFS(A,value,x-1,y,row,col) + 1;
        }
        if(x+1<row && A[x+1][y] < A[x][y]){
            if(value[x+1][y]!=-1){
                len2 = value[x+1][y] + 1;
            }else
                len2 = DFS(A,value ,x+1,y,row,col) + 1;
        }
        if(y-1 >=0 && A[x][y-1] < A[x][y]){
            if(value[x][y-1]!=-1){
                len3 = value[x][y-1] + 1;
            }else
                len3 = DFS(A,value,x,y-1,row,col) + 1;
        }
        if(y+1 <col && A[x][y+1] < A[x][y]){
            if(value[x][y+1]!=-1){
                len4 = value[x][y+1] + 1;
            }else
                len4 = DFS(A,value,x,y+1,row,col) + 1;
        }
        value[x][y] = Max(len1,len2,len3,len4);
        return value[x][y];
        
    }
    private static int DFS(int[][] A,int x,int y,int row,int col){
        if(x<0 || x>=row || y<0 || y>=col){
            return 0;
        }
        int len1 = 0;
        int len2 = 0;
        int len3 = 0;
        int len4 = 0;
        if(x-1>=0 && A[x-1][y] < A[x][y]){
            len1 = DFS(A,x-1,y,row,col) + 1;
        }
        if(x+1<row && A[x+1][y] < A[x][y]){
            len2 = DFS(A,x+1,y,row,col) + 1;
        }
        if(y-1 >=0 && A[x][y-1] < A[x][y]){
            len3 = DFS(A,x,y-1,row,col) + 1;
        }
        if(y+1 <col && A[x][y+1] < A[x][y]){
            len4 = DFS(A,x,y+1,row,col) + 1;
        }
        return Max(len1,len2,len3,len4);
    }
    private static int Max(int a,int b,int c,int d){
        a = a>b?a:b;
        a = a>c?a:c;
        a = a>d?a:d;
        return a;
    }

}