滑雪问题的几个解法

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
输出最长区域的长度。


      最初看到这个问题，是在(http://www.cppblog.com/qywyh/archive/2006/03/01/3616.aspx) ，下面是该blog 作者的一个解法：  这个解法中的回溯很经典，在回溯中运用动态规划，代码如下：

#include <iostream>
using namespace std;

const int MAX = 102;
const int HIGHT = 10001;
struct pos {
    int i, j , p ;
};
int path(int [MAX][MAX], int [MAX][MAX] , int [MAX][MAX], int , int) ;

int main(int argc,char * argv[])
{
    int input[MAX][MAX];
    int result[MAX][MAX];
    int status[MAX][MAX];
    int m,n;

    int i,j;
    int max, ans;
    cin >> m >> n;
    for(i = 0 ; i <= m + 1; i ++)
        for(j = 0 ; j <= n + 1; j ++)
        {
            input[i][j] = HIGHT ;
            result[i][j] = 0;
            status[i][j] = 0;
        }
    for(i = 1; i <= m ; i++)
        for(j = 1; j <= n ; j++)
            cin >> input[i][j];
    clock_t  t1 = clock();
    for(i = 1; i <= m ; i++)
        for(j = 1; j <= n ;j ++)
            path(input,result,status,i,j);
    max = 0;
    for(i = 1; i <= m ; i++)
        for(j = 1; j <= n ; j ++)
            if( max < result[i][j])
                max = result[i][j];
    clock_t t2 = clock();
    cout <<"Time is : " << t2 - t1 <<endl;
    cout << max <<endl;
    return 0;
}

int path(int input[MAX][MAX], int result[MAX][MAX], int status[MAX][MAX],int i , int j)
{
    pos pack[MAX * MAX];
    int max,g,h;
    int ii;
    int top = 0;
    int p = 0;
    int incr[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};
    if(result[i] [ j] > 0 ) return 0;
    else {
        pack[top].i = i;
        pack[top].j = j;
        pack[top].p = p;
        status[i][j] = - 1;
    }
    while(top >= 0 || p < 4) {
        if(p < 4) {
            g = pack[top].i + incr[p][0];
            h = pack[top].j + incr[p][1] ;

            if(input[pack[top].i][pack[top].j] > input[g][h] )
            {
                if(result[g][h] > 0 || status[g][h] == -1)
                    p ++;
                else {
                    top ++ ;
                    pack[top].i = g;
                    pack[top].j = h;
                    pack[top].p = p;
                    status[g][h] = -1;
                    p = 0 ;
                }
            }
            else p++;
        } else {
            max = 0;
            for(ii = 0 ; ii < 4; ii ++) {
                g = pack[top].i + incr[ii][0];
                h = pack[top].j + incr[ii][1];
                if(input[pack[top].i][pack[top].j] > input[g][h] && max < result[g][h])
                    max = result[g][h];
            }
            result[pack[top].i][pack[top].j] = max + 1;
            top --;
            p = pack[top].p + 1;
        }
    }
    return 0;
}

   

     这个问题，可以完全用递归来解决，感这个问题完全用递归来解决好像比上面两种解法快一些：

#include <iostream>

using namespace std;
int hight[100][100]
;
int R,C ;
bool inline left_lower(int row,int col)
{
    if(col >= 1) {
        if(hight[row][col - 1] < hight[row][col]) return true;
        return false;
    }
    return false;
}
bool inline right_lower(int row,int col)
{
    if(col + 1 >= C) return false;
    if(hight[row][col+1] < hight[row][col]) return true;
        return false;    
}
bool inline up_lower(int row,int col)
{
    if(row >= 1) {
        if(hight[row-1][col] < hight[row][col]) return true;
        return false;
    }
    return false;
}
bool down_lower(int row, int col)
{
    if(row + 1 >= R) return false;
    if(hight[row+1][col] < hight[row][col]) return true;
    return false;
}
int step(int row, int col)
{
    if(row < 0 || col < 0 ) return 0;
    if(row >= R || col >= C) return 0;
    int m = 0 ;
    int tmp  = -1;
    if(left_lower(row,col) == true) {
        tmp = step(row ,col - 1);
    }
    if( tmp > m ) m = tmp;
    if(right_lower(row,col) == true) {
        tmp = step(row,col+1);
    }
    if(tmp > m ) m = tmp;
    if(up_lower(row,col) == true) {
        tmp = step(row-1,col);
    }
    if(tmp>m) m = tmp ;
    if(down_lower(row,col) == true) {
        tmp = step(row+1,col);
    }
    if(tmp > m) m = tmp;
    return m + 1;
}
int main()
{
    int i,j;
    int max = 0 ;
    int tmp;
    cin >>R >> C ;
    for(i = 0 ; i < R ; i ++)
        for(j = 0 ; j < C ; j++)
            cin >> hight[i][j];
    clock_t t1 = clock();
    for( i = 0 ; i < R; i ++)
        for (j = 0 ; j < C ; j ++)
        {
            //printf("[%d,%d] =%d ", i+1,j+1,step(i,j));
            tmp = step(i,j);
            if(tmp > max) {
                max = tmp;
            }
        }
    clock_t t2 = clock();
    cout << "Time is : " << t2 -t1 <<endl;
     out <<"The max is :   " << max <<endl;
    return 0;                
}

      附上生成测试数据的小程序：

#include <iostream>
#include <cstdio>
#include <ctime>

using namespace std;
int main(int argc,char * argv[])
{
    int i ,j , tmp ;
    int m,n;
    if(argc != 3) {
        cerr << "please input row-col" <<endl;
        exit(0);
    }
    //cin >> m >>n;
    m = atoi(argv[1]);
    n = atoi(argv[2]);
    cout << m << ' '<< n << endl;
    srand(time(NULL));
    for ( i = 0 ; i < m; i++) {
        for(j = 0; j < n; j ++)
        {
            tmp = 0 ;
            while(tmp == 0) {
             tmp = rand() % 10000;
             srand(time(NULL) + tmp);
            }
            cout << tmp << ' ';
        }
        cout <<endl;
    }
    return 0;

}