• 1434 滑雪


    难度:普及/提高-

    题目类型:记忆化搜索

    提交次数:1

    涉及知识:动态规划

    题目描述

    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(从24开始,在1结束)。当然25-24-23―┅―3―2―1更长。事实上,这是最长的一条。

    输入输出格式

    输入格式:

    输入的第一行为表示区域的二维数组的行数R和列数C(1≤R,C≤100)。下面是R行,每行有C个数,代表高度(两个数字之间用1个空格间隔)。

    输出格式:

    输出区域中最长滑坡的长度。

    代码:

     1 #include<iostream>
     2 #include<algorithm>
     3 #include<vector>
     4 using namespace std;
     5 int m, n;
     6 const int MAXX = 110;
     7 const int MAXY = 110;
     8 int d[MAXX][MAXY];
     9 bool boundary(int x, int y){
    10     if(x>=1&&x<=m&&y>=1&&y<=n) return true;
    11     return false;
    12 }//判断是否越界
    13 struct Node{
    14         int x;
    15         int y;
    16         int h;
    17     };
    18 bool com(Node a, Node b){
    19     return a.h < b.h;
    20 } 
    21 int main(){
    22     int i, j, k, x, y;//m行n列 
    23     cin>>m>>n;
    24     int a[m+1][n+1];
    25     k = 0;
    26     vector<Node>s(m*n);
    27     for(i = 1; i <= m; i++)
    28         for(j = 1; j <= n; j++){
    29             cin>>a[i][j];
    30             s[k].h = a[i][j];
    31             s[k].x = i;
    32             s[k].y = j;
    33             k++;  
    34         }
    35     sort(s.begin(), s.end(), com);//按高度从小到大排序 
    36     
    37     for(i = 0; i <= MAXX; i++)
    38         for(j = 0; j <= MAXY; j++)
    39             d[i][j] = 1;
    40     
    41     for(i = 0; i < m*n; i++){
    42         if(boundary(s[i].x-1, s[i].y) && a[s[i].x-1][s[i].y] < a[s[i].x][s[i].y])
    43             d[s[i].x][s[i].y] = max(d[s[i].x][s[i].y], d[s[i].x-1][s[i].y] + 1);
    44         
    45         if(boundary(s[i].x+1, s[i].y) && a[s[i].x+1][s[i].y] < a[s[i].x][s[i].y])
    46             d[s[i].x][s[i].y] = max(d[s[i].x][s[i].y], d[s[i].x+1][s[i].y] + 1);
    47         
    48         if(boundary(s[i].x, s[i].y-1) && a[s[i].x][s[i].y-1] < a[s[i].x][s[i].y])
    49             d[s[i].x][s[i].y] = max(d[s[i].x][s[i].y], d[s[i].x][s[i].y-1] + 1);
    50         
    51         if(boundary(s[i].x, s[i].y+1) && a[s[i].x][s[i].y+1] < a[s[i].x][s[i].y])
    52             d[s[i].x][s[i].y] = max(d[s[i].x][s[i].y], d[s[i].x][s[i].y+1] + 1);
    53     }
    54     int ans = 0;
    55     for(i = 1; i <= m; i++){
    56         for(j = 1; j <= n; j++)
    57             ans = max(ans, d[i][j]);
    58         }
    59     cout<<ans<<endl;
    60     return 0;
    61 } 

    备注:

    暑假北大课讲动规时说过的一道题,回家后写了一遍,洛谷上看到就直接过了。这是比较典型“人人为我”动规。先把点的高度从小到大排序,每个点都初始化为1。从最矮的点开始(每个点都可以从它前后左右任何一个比它高的点滑过来),一步步更新,最后取最大值。

    11-26更新:

    用递归的方法写了一遍,代码简单一点:

     1 //滑雪 
     2 //2019-11-26 
     3 
     4 #include<iostream>
     5 using namespace std;
     6 int d[105][105]; //存放状态,以(i,j)为终点的最长线路 
     7 int a[105][105];
     8 int dirx[4]={0,0,1,-1};
     9 int diry[4]={1,-1,0,0}; 
    10 int m, n;
    11 //递推的顺序:高度从低到高
    12 //用记忆化搜索就不用考虑顺序问题 
    13 bool check(int x, int y){//判断(x,y)是否越界 
    14     if(x>=1&&x<=m&&y>=1&&y<=n) return true;
    15     return false; 
    16 }
    17 int dp(int x, int y){
    18     if(d[x][y]) return d[x][y]; //如果已经有数据,直接返回 
    19     int maxx = 1; //这个地方注意一定是初始化为1,考虑最高点,这时候不会进入循环,这个点的d值应该是1而不是0 
    20     for(int i = 0; i < 4; i++){ //遍历四个方向,选一个最长的 
    21         int nx = x+dirx[i], ny = y+diry[i];
    22         if(check(nx,ny)&&a[nx][ny]>a[x][y])
    23             maxx = max(maxx,dp(nx,ny)+1); 
    24     } 
    25     d[x][y] = maxx; //要记得给状态数组赋值 
    26     return maxx;
    27 }
    28 int main(){
    29     cin>>m>>n;
    30     int i, j;
    31     for(i = 1; i <= m; i++)
    32         for(j = 1; j <= n; j++){
    33             cin>>a[i][j];
    34         }
    35     for(i = 1; i <= m; i++)
    36         for(j = 1; j <= n; j++)        
    37             int x = dp(i,j); //把d数组跑出来 (每一个点都要跑,才能跑出来整个表) 
    38     int ans = 0;
    39     for(i = 1; i <= m; i++)
    40         for(j = 1; j <= n; j++)
    41             ans = max(ans, d[i][j]);
    42     cout<<ans<<endl; 
    43     return 0;
    44 }

    重要的点都写在注释里了。感觉可以作为一个模板来熟悉。记忆化搜索的边界条件就是有记忆。

  • 相关阅读:
    Pick-up sticks
    The Doors
    Intersecting Lines
    Segments
    TOYS
    Palindrome
    Distinct Substrings
    Milk Patterns
    Musical Theme
    JavaScript基于时间的动画算法
  • 原文地址:https://www.cnblogs.com/fangziyuan/p/5881201.html
Copyright © 2020-2023  润新知