ACM skiing （Java）

skiing
时间限制：3000 ms | 内存限制：65535 KB
难度：5
描述
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更长。事实上，这是最长的一条。

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

输出
输出最长区域的长度。

样例输入
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 Skiing {
    static int[] res; // 结果
    static int[][] map; // 存放各点高度
    static int[][] move = {{0,-1},{0,1},{-1,0},{1,0}}; // 上下左右移动
    static int[][] record; // 记录各点的最长区域长度，为节省时间
    static int s_i, s_j, longPath; // s_i:行、s_j:列、longPath:该点的最长区域长度
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        res = new int[n];
        for (int i = 0; i < n; i++) {
            int R = sc.nextInt();
            int C = sc.nextInt();
            map = new int[R][C];
            record = new int[R][C];
            for (int j = 0; j < map.length; j++) 
                for (int j2 = 0; j2 < map[j].length; j2++) 
                    map[j][j2] = sc.nextInt();

            // 从数组第一个数开始计算，直至最后一个
            // 写完后提交出现运行错误，结果找了半天发现j和i写混了   ……T_T……
            for (int j = 0; j < map.length; j++) {
                for (int j2 = 0; j2 < map[j].length; j2++) {
                    longPath = 1;
                    s_i = j; s_j = j2;
                    dfs(1,R,C);
                    record[j][j2] = longPath;
                }
            }

            // 从record中找出最大的长度
            int max = 0;
            for (int j = 0; j < record.length; j++) 
                for (int j2 = 0; j2 < record[j].length; j2++) 
                    max = record[j][j2] > max ? record[j][j2] : max;
            res[i] = max;
        }
        sc.close();
        for (int i = 0; i < res.length; i++)
            System.out.println(res[i]);
    }
    // 深度优先搜索
    static void dfs(int path, int R, int C){
        for (int i = 0; i < 4; i++) {
            // 判断是否越界，移动的点是否合理
            if(s_i+move[i][0]<R && s_i+move[i][0]>=0 && s_j+move[i][1]<C && 
            s_j+move[i][1]>=0 && map[s_i][s_j]>map[s_i+move[i][0]][s_j+move[i][1]]){
                int t_i = s_i, t_j = s_j, t_path = path;
                s_i += move[i][0]; s_j += move[i][1];
                if(record[s_i][s_j]!=0){ // 记录中有最长区域，直接相加，没有再执行else
                    path += record[s_i][s_j];
                    longPath = path > longPath ? path : longPath;
                }
                else{
                    path++;
                    dfs(path,R,C);
                }
                // 回溯
                s_i = t_i; s_j = t_j; path = t_path;
            }else{
                longPath = path > longPath ? path : longPath;
            }
        }
    }

}

<有帮助就顶一下吧 ^_^>