ACM_1088滑雪（递归的简单应用）

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

我的逻辑：
1.找到最大的数字，遍历行找到到行最大，之后再对比每个行的最大数；
2.向上下左右四个方向找到比最大数小（第一个数据不存在比最大数小，但是之后的递归会用到，没有这个条件会变成无线递归）但是和这个数相差最小的数字，将这个数设置成最大数，进入递归；
3.递归的跳出条件为 （1）周围已经没有数字比递归传进来的这个数字要小；（2）进入死角，且周围没有数字比递归传进来的数字要小
4.规定一个静态变量（count），让其在递归内，每执行一次递归，count++，便可以得到最后的结果；
ps：这个代码的实现过程和扫雷的得到雷的信息的过程类似，都有一个递归的过程，这两个问题搞清楚任意一个，都可以解决另外一个问题；点此进入扫雷代码分享
具体代码如下：

#include
int cal(int arr[100][100], int len, int col, int max, int maxlen, int maxcol)
{
    static int output = 0;
    if (maxlen != 0 && maxlen != 99 && maxcol != 0 && maxlen != 99)
    {
        int a[5];
        int i = 0;
        int tmp;
        int count = 0;
        a[0] = arr[maxlen - 1][maxcol];
        a[1]= arr[maxlen + 1][maxcol];
        a[2] = arr[maxlen][maxcol - 1];
        a[3] = arr[maxlen][maxcol + 1];
        a[4] = max;
        for (i = 3; i >= 0; i++)
        {
            int max1;
            max1 = a[4];
            if (a[i] > max1)
            {
                tmp = a[i];
                max1 = a[i];
                a[i] = tmp;
            }
        }
        for (i = 0; i <= 3; i++)
        {
            if (a[i] == max&&i != 0)
            {
                if (a[i - 1] == arr[maxlen - 1][maxcol])
                    cal(arr, len, col, a[i - 1], maxlen - 1, maxcol);
                else if (a[i - 1] == arr[maxlen + 1][maxcol])
                    cal(arr, len, col, a[i - 1], maxlen + 1, maxcol);
                else if (a[i - 1] == arr[maxlen][maxcol + 1])
                    cal(arr, len, col, a[i - 1], maxlen, maxcol + 1);
                else if (a[i - 1] == arr[maxlen][maxcol - 1])
                    cal(arr, len, col, a[i - 1], maxlen, maxcol - 1);
            }
            else
                return output;

        }

        //确定max在abcd中的地位 ，找出比max小但是最接近的数，递归调用这个数，及其位置
        //四个方向的比较
    }
    if (maxlen == 0 && maxlen != 99 && maxcol != 0 && maxlen != 99)
    {
        //三个方向比较  下 左 右
    }
    if (maxlen != 0 && maxlen == 99 && maxcol != 0 && maxlen != 99)
    {
        //三个方向比较 上 左 右
    }
    if (maxlen != 0 && maxlen != 99 && maxcol == 0 && maxlen != 99)
    {
        //三个方向比较 上 下 右
    }
    if (maxlen != 0 && maxlen != 99 && maxcol != 0 && maxlen == 99)
    {
        //三个方向比较 上下 左
    }
    if (maxlen == 0 && maxlen != 99 && maxcol == 0 && maxlen != 99)
    {
        //三个方向比较
    }
    if (maxlen == 0 && maxlen != 99 && maxcol != 0 && maxlen == 99)
    {
        //两个方向比较  边角元素
    }
}
int main()
{
    int arr[1000][1000];
    //赋值
    int len = 0, col = 0;
    int count = 0;
    scanf_s("%d%d", &len, &col);
    while (count != len)
    {
        int a = 0, b = 0;
        int max = arr[len][0];
        int maxlen = 0, maxcol = 0;
        for (b = 0; b < len; b++)
        {
            for (a = 1; a < col; a++)
            {
                if (arr[len][b] > max)
                {
                    max = arr[len][a];
                    maxlen = len;
                    maxcol = col;
                }
            }
        }//寻找整个数据中最大数

        //在最大数的四个方向寻找一个数字最接近最大数的数字
        //计数器++
        //边界访问问题 类似扫雷实现
        //最后的结果必是一个数字不断减小的数组

    }
    return 0; 
}