Tyvj_P1004

trs喜欢滑雪。他来到了一个滑雪场，这个滑雪场是一个矩形，为了简便，我们用r行c列的矩阵来表示每块地形。为了得到更快的速度，滑行的路线必须向下倾斜。
例如样例中的那个矩形，可以从某个点滑向上下左右四个相邻的点之一。例如24-17-16-1，其实25-24-23…3-2-1更长，事实上这是最长的一条。
输入格式

输入文件

第1行: 两个数字r，c(1<=r,c<=100)，表示矩阵的行列。
第2..r+1行:每行c个数，表示这个矩阵。
输出格式

输出文件

仅一行: 输出1个整数，表示可以滑行的最大长度。
测试样例1

输入

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
输出

25

import java.util.Scanner;
public class Main {
    private static int r;
    private static int c;
    private static int[][] mat;
    private static int[][] dp;
    private static boolean[][] hasVisited;

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        r = sc.nextInt();
        c = sc.nextInt();
        mat = new int[r][c];
        dp=new int[r][c];
        hasVisited=new boolean[r][c];
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                mat[i][j] = sc.nextInt();
            }
        }

        for(int i=0;i<r;i++){
            for(int j=0;j<c;j++){
                fun(i,j);
            }
        }

        int max=Integer.MIN_VALUE;
        for(int i=0;i<r;i++){
            for(int j=0;j<c;j++){
                max=Math.max(max,dp[i][j]);
            }
        }
        System.out.println(max);
    }

    private static void fun(int i, int j) {
        if (hasVisited[i][j]) {
            return;
        }
        dp[i][j] = 1;// 加入哪都走不了
        // 向上走
        if (i != 0) {
            if (mat[i][j] > mat[i - 1][j]) {
                if (hasVisited[i - 1][j]) {
                    dp[i][j] = dp[i - 1][j] + 1;
                } else {
                    fun(i - 1, j);
                    dp[i][j] = dp[i - 1][j] + 1;
                }
            }
        }

        // 向下走
        if (i != r - 1) {
            if (mat[i][j] > mat[i + 1][j]) {
                if (hasVisited[i + 1][j]) {
                    dp[i][j] = Math.max(dp[i][j],dp[i + 1][j] + 1);
                } else {
                    fun(i + 1, j);
                    dp[i][j] = Math.max(dp[i][j],dp[i + 1][j] + 1);
                }
            }
        }

        // 向左走
        if (j != 0) {
            if (mat[i][j] > mat[i][j-1]) {
                if (hasVisited[i][j-1]) {
                    dp[i][j] = Math.max(dp[i][j],dp[i][j-1] + 1);
                } else {
                    fun(i, j-1);
                    dp[i][j] = Math.max(dp[i][j],dp[i][j-1] + 1);
                }
            }
        }

        //向右走
        if (j != c-1) {
            if (mat[i][j] > mat[i][j+1]) {
                if (hasVisited[i][j+1]) {
                    dp[i][j] = Math.max(dp[i][j],dp[i][j+1] + 1);
                } else {
                    fun(i, j+1);
                    dp[i][j] = Math.max(dp[i][j],dp[i][j+1] + 1);
                }
            }
        }

        hasVisited[i][j]=true;
    }

}