POJ1088 滑雪

原题：

Description

Michael喜欢滑雪百这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子 

 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更长。事实上，这是最长的一条。

Input

输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。

Output

输出最长区域的长度。

Sample Input

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

Sample Output

25

我的代码：

import java.util.Scanner;
public class Main {
    static int n=4;
    static int column;
    static int row;
    static int[][] plate;
    static int max_count=0;

    public static void BFS(int x,int y,int count) {
        if(!Check(x,y))
            return ;
        if(Check(x+1,y)&&plate[x+1][y]<=plate[x][y]) {
            BFS(x + 1, y, count+1);
        }
        if(Check(x-1,y)&&plate[x-1][y]<=plate[x][y]) {
            BFS(x - 1, y, count+1);
        }
        if(Check(x,y+1)&&plate[x][y+1]<=plate[x][y]) {
            BFS(x, y + 1, count+1);
        }
        if(Check(x,y-1)&&plate[x][y-1]<=plate[x][y]) {
            BFS(x, y - 1, count+1);
        }
        if(max_count<count)
            max_count=count;
        return ;
    }

    public static boolean Check(int x,int y) {
        if(x<0||y<0||x>=row||y>=column)
            return false;
        return true;
    }

    public static void main(String...args) {
        Scanner input=new Scanner(System.in);
        row=input.nextInt();
        column=input.nextInt();
        plate=new int[row][];
        for(int i=0;i<row;i++) {
            plate[i] = new int[column];
            for(int j=0;j<column;j++)
                plate[i][j]=input.nextInt();
        }
        for(int i=0;i<row;i++) {
            for (int j = 0; j < column; j++) {
                System.out.print(plate[i][j] + " ");
            }
            System.out.println();
        }

        for(int i=0;i<row;i++)
            for(int j=0;j<column;j++) {
                BFS(i, j, 0);
            }
        System.out.println(max_count+1);
    }
}