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 }

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

posted @ 2016-09-18 12:56  timeaftertime  阅读(216)  评论(0编辑  收藏  举报