动态规划5--滑雪

动态规划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。输出输出最长区域的长度。
输入
输入的第一行表示区域的行数R和列数C
(1 <= R,C <= 100)。下面是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

先定义结构体把每个点的x，y和h都装起来，依次储存每个点。
那这个问题就从二维化成了一维。
按每个点高度从大到小排好。
其实就变成了不下降子序列那个问题。
具体做法：
我按高度依次往后面找，看看后面的点是否满足点在这个点旁边的规则。
满足的话就路径长度加1。

L(i,j)表示从点(i,j)出发的最长滑行长度。
一个点(i,j), 如果周围没有比它低的点，L(i,j) = 1
否则
递推公式： L(i,j) 等于(i,j)周围四个点中,比(i,j)低，且L值最大的那个点的L值，再加1
复杂度：O(n2)

解法1） “人人为我”式递推
L(i,j)表示从点(i,j)出发的最长滑行长度。
一个点(i,j), 如果周围没有比它低的点，L(i,j) = 1
将所有点按高度从小到大排序。每个点的 L 值都初始化为1
从小到大遍历所有的点。经过一个点(i,j)时，用递推公式求L(i,j)

解法2） “我为人人”式递推
L(i,j)表示从点(i,j)出发的最长滑行长度。
一个点(i,j), 如果周围没有比它低的点，L(i,j) = 1
将所有点按高度从小到大排序。每个点的 L 值都初始化为1
从小到大遍历所有的点。经过一个点(i,j)时，要更新他周围的，比它高的点的L值。例如：
if H(i+1,j) > H(i,j) // H代表高度
L(i+1,j) = max(L(i+1,j),L(i,j)+1)

三、代码和结果

/*
心得：
找路径时，递推的方法和递归一样，也是知道递推表达式之后就特别好写了
也是直接把递推表达式写进循环里面就好了
递推和递推写法的区别：
递归是调用的系统栈，递推没有调用栈，其它一模一样了  

将题目转化为了求不下降子序列的长度 
*/ 
#include <iostream>
#include <algorithm>
#define Max 105
using namespace std;

struct node{//表示每一个点 
    int r;//每一个点的行位置 
    int c;//每一个点的列位置 
    int h;//每一个点的高 
};
//排序规则，将结构从大到小排序 
int my_comp(const node &p1,const node &p2){
    return p1.h>p2.h;
    //本来顺序是p1,p2，如果p1的高大于p2的高，我们就不交换 
}
node a[Max*Max];//储存每一个节点，按高度排序后将二维数组化成了一维数组 
//dp[i]表示第i个点对应的最长区域的长度 
int R,C,dp[Max*Max];//R表示行，R表示列 
int pre[Max*Max];//记录每个点的路径 
int maxn=0,maxn_i=R*C;//记录最长路径对应的点的值和编号 

void input();//输入数据 
void test_input(int R,int C);//测试输入数据 
void init_dp();//动态规划前的初始化，初始化dp数组 
void dpFunction();//dp操作 
bool isClose(node a,node b);//判断两个点是否相连 
void printRoad1(int i);//递归方法打印路径 
void printRoad2(int i);//递推方法打印路径 




int main(){
    freopen("in.txt","r",stdin);
    
    input();//输入数据 
    
    sort(a+1,a+R*C+1,my_comp);//对每个点按高度进行排序 
    //test_input(R,C); //测试输入数据 
    init_dp();//动态规划前的初始化，初始化dp数组
    dpFunction();//dp操作 
    //递归找路径 
    printRoad1(pre[maxn_i]);
    cout<<a[maxn_i].r<<","<<a[maxn_i].c<<endl;//输出第一个点 
    
    //递推找路径 
    //cout<<a[maxn_i].r<<","<<a[maxn_i].c;//输出第一个点
    //printRoad2(pre[maxn_i]);//输出后面的点 
    return 0;
} 

//递推方法打印路径 
void printRoad2(int i){
    /*
    递推表达式是： 
    如果pre[i]==0，表示是起始点，return
    如果不是0，递归呗 
    */ 
    /*
    找路径时，递推的方法和递归一样，也是知道递推表达式之后就特别好写了
    也是直接把递推表达式写进循环里面就好了
    递推和递推写法的区别：
    递归是调用的系统栈，递推没有调用栈，其它一模一样了 
    */ 
    while(true){
        if(i==0){
            break;
        }
        else{
            cout<<"-->"<<a[i].r<<","<<a[i].c;
            i=pre[i];
        }
    }
}

//递归方法打印路径 
void printRoad1(int i){
    /*
    递推表达式是： 
    如果pre[i]==0，表示是起始点，return
    如果不是0，递归呗 
    */ 
    if(i==0){
        return ;
    }    
    else{
        printRoad1(pre[i]);
        cout<<a[i].r<<","<<a[i].c<<"-->";    
    }
}

//dp操作
void dpFunction(){
    //从高往低走，如果靠近，上下左右相邻四个点之一，最长区域就加1 
    for(int i=1;i<=R*C;i++){
        for(int j=1;j<i;j++){
            if(isClose(a[i],a[j])){
                if(dp[j]+1>=dp[i]){
                    dp[i]=dp[j]+1;
                    pre[i]=j;
                }
            }
        }
    }
    //路径最长的点并不是一定从最后面出来的那个点，所以cout<<dp[R*C]<<endl;是不对的 
    //还要找到dp里面那个最大的值，和那个值对应的编号 
    
    for(int i=1;i<=R*C;i++){ 
        if(dp[i]>maxn){
            maxn=dp[i];
            maxn_i=i;
        }
    }
    //cout<<maxn<<" "<<maxn_i<<endl;
    cout<<maxn<<endl;
    
}

//判断两个点是否相连 
bool isClose(node a,node b){
    /*
            r-1
     c-1    r,c        c+1
            r+1
    */ 
    //对应上下左右,
    //r在前列子在后
    int direction[4][2]={{1,0},{-1,0},{0,-1},{0,1}}; 
//    cout<<direction[0][0]<<endl;
//    cout<<direction[0][1]<<endl;
//    cout<<direction[1][0]<<endl;
//    cout<<direction[1][1]<<endl;
    
    for(int i=0;i<4;i++){
        //a在中心 
        if((a.r+direction[i][0]==b.r)&&(a.c+direction[i][1]==b.c)){
            return true;
        }
    }
    return false;
    
}

//动态规划前的初始化，初始化dp数组 
void init_dp(){
    for(int i=1;i<=R*C;i++){
        dp[i]=1;
    }
}

//输入数据 
void input(){
    cin>>R>>C;
    int num=1;
    for(int i=1;i<=R;i++){
        for(int j=1;j<=C;j++){
            a[num].r=i;
            a[num].c=j; 
            cin>>a[num++].h;
        }
    } 
}

//测试输入数据 
void test_input(int R,int C){
    for(int i=1;i<=R*C;i++){
        cout<<a[i].r<<" "<<a[i].c<<" "<<a[i].h<<endl;
    }
}