算法提高 最长滑雪道（递归）

1. 问题描述

　　小袁非常喜欢滑雪， 因为滑雪很刺激。为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。 小袁想知道在某个区域中最长的一个滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。如下：


一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。你的任务就是找到最长的一条滑坡，并且将滑坡的长度输出。 滑坡的长度定义为经过点的个数，例如滑坡24-17-16-1的长度是4。

输入格式，输入的第一行表示区域的行数R和列数C(1<=R, C<=10)。下面是R行，每行有C个整数，依次是每个点的高度h（0<= 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

样例输出

25

2. 思路分析：

① 由题目可以知道这个是一个经典的递归的题目，从二维数组的某一个位置出发，那么可以判断上下左右四个方向是否可以到达，由已知条件可以知道当当前位置的值大于下一个位置的时候那么可以到达下一个位置，并且对于当前的位置可以有四种选择，上下左右四个方向，也就是对应着四个平行状态，可以在一个for循环中模拟四个位置判断一下是否可以到达，假如可以到达那么可以递归下去，并且声明一个全局变量来记录最大值，每一次在递归方法的开头的时候应该判断是否更新最大值，因为在递归方法一开始这个地方，有可能递归到某个位置的时候就不能够往下执行了了所以需要判断一下来更新最大值，表示的是到达这个点的最大值并且与历史上的最大值进行比较来决定是否更新最大值

这里与之前的递归不同的是这里不需要进行return，因为这里是有if判断来决定是否可以递归下去，当条件不满足的时候回层层进行返回

② 代码如下：

1）使用if来表示四个平行状态的代码：

import java.util.Arrays;
import java.util.Scanner;
public class Main {
    /*使用一个全局变量来记录中间的最大结果*/
    static int max = 0;
    /*定义一个标记数组来标记之前已经访问过的点*/
    static int vis[][];
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int row = sc.nextInt();
        int col = sc.nextInt();
        int arr[][] = new int[row][col];
        vis = new int[row][col];
        for (int i = 0; i < row; ++i){
            for (int j = 0; j < col; ++j){
                arr[i][j] = sc.nextInt();
            }
        }
        /*因为不确定起点在哪里所以需要一个for循环来模拟在某个起点开始*/
        for (int i = 0; i < row * col; ++i){
            //System.out.println(i / col + " " + (i - col * (i / col)));
            /*将起点传递过去, 第三个参数表示的是当前的路径长度是多少*/
            dfs(i / col, i - col * (i / col), 1, arr);
            /*回溯*/
            vis[i / col][i - col * (i / col)] = 0;
        }
        System.out.println(max);
    }

    private static void dfs(int r, int c, int count, int arr[][]) {
        if (count > max) max = count;
        vis[r][c] = 1;
        if (r - 1 >= 0 && vis[r - 1][c]!= 1 && arr[r - 1][c] < arr[r][c]){
            dfs(r - 1, c, count + 1, arr);
            vis[r - 1][c] = 0;
        }
        if (r + 1 < arr.length && vis[r + 1][c] != 1 && arr[r + 1][c] < arr[r][c]){
            dfs(r + 1, c, count + 1, arr);
            vis[r + 1][c] = 0;
        }
        if (c - 1 >= 0 && vis[r][c - 1]!= 1&& arr[r][c - 1] < arr[r][c]){
            dfs(r, c - 1, count + 1, arr);
            vis[r][c - 1] = 0;
        }
        if (c + 1 < arr[0].length && vis[r][c + 1]!= 1 && arr[r][c + 1] < arr[r][c]){
            dfs(r, c + 1, count + 1, arr);
            vis[r][c + 1] = 0;
        }
    }
}

2）使用for循环与四个来模拟：

import java.util.Scanner;
public class Main {
    static int max = 0;
    static int vis[][];
    /*上下左右四个方向*/
    static int pos[][] = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int row = sc.nextInt();
        int col = sc.nextInt();
        int arr[][] = new int[row][col];
        vis = new int[row][col];
        for (int i = 0; i < row; ++i){
            for (int j = 0; j < col; ++j){
                arr[i][j] = sc.nextInt();
            }
        }
        for (int i = 0; i < row * col; ++i){
            dfs(i / col, i - col * (i / col), 1, arr);
            vis[i / col][i - col * (i / col)] = 0;
        }
        System.out.println(max);
    }

    private static void dfs(int r, int c, int count, int arr[][]) {
        if (count > max) max = count;
        vis[r][c] = 1;
        /*使用for循环了来模拟四个方向的平行状态*/
        for (int i = 0; i < 4; ++i){
            int x = r + pos[i][0];
            int y = c + pos[i][1];
            if (x >= 0 && x < arr[0].length && y >= 0 && y < arr[0].length && vis[x][y] == 0 && arr[x][y] < arr[r][c]){
                dfs(x, y, count + 1, arr);
                vis[x][y] = 0;
            }
        }
    }
}