NKOJ P1009 滑雪路径题解

最新推荐文章于 2024-07-24 22:13:06 发布

NY_C20

最新推荐文章于 2024-07-24 22:13:06 发布

阅读量949

点赞数 28

文章标签：深度优先算法 c++

本文链接：https://blog.csdn.net/NY_fighting/article/details/134630293

版权

前言

这个系列是我和我的同学一起写的，收录了NKOJ的部分题目的题解，用不断更，NK的同学们可以借鉴学习一下，其他学信竞的也可以看一下，刷新一下题库。总帖在这里
点个赞再看叭~

题目

问题描述

Michael 喜欢滑雪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。 Michael想知道在一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表该点的高度（类似于等高线）。
01 02 03 04 05
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更长，事实上，这是最长的一条（如图B所示）。你的任务就是要在给出的地图中，帮Michael找一条最长的滑坡。

输入格式

输入第一行包含两个整数，分别表示区域的行数R和列数C(1 <= R,C <= 100)。接下来是R行，每行有C个整数，代表高度h，0<=h<=10000

输出格式

输出包括一行，这一行只包含一个整数，即是最长的滑坡的长度（每个点的长度为1）。

样例输入 1

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

样例输出 1

样例输入 2

5 6
1 2 3 4 5 6
7 8 9 10 11 12
18 17 16 15 14 13
12 45 65 76 76 8
123 4 55 7 67 4

样例输出 2

提示

对于50％的数据，保证有R+C<=20 h<=100.
对于全部的数据，保证有R+C<=200 h<=10000.

题解

题目翻译

这个题目写的有点复杂，翻译一下大概就是说：给你一个二维数组，求出这个二维数组中的“最长下降子序列”。诶，别被误导了，这道题不是dp。因为如果用dp来写的话，一做不到避免重复和漏算，二不知道从何处开始遍历。所以这题应该用什么方法写呢？

思路

像这种求路径长度的题，应该很容易就能想到搜索。bfs用队列搜，适合求最短路径长度一类的题；dfs递归搜，适合求具体路径的题。而这道题，正好两边都沾点，所以两种搜索算法都可以。

bfs

这道题如果用bfs做，那就肯定得开结构体。因为一个状态最少都要用3个参数来表示：两个表示位置，剩下一个表示当前划了多长的距离。每次循环，将队首元素取出，再将这个状态往四个方向划的状态从队尾插入。注意，再将新状态插入对位时，应判断其是否合法：他是不是比它前一个状态数字小？他是否在R，C的范围内？如果不合法，则不插入，并更新最大值。

#include <bits/stdc++.h>
using namespace std;
struct node{
	int x, y, step;
};
queue<node> q;
int r, c, Map[103][103], ans=-0x3f3f3f3f;
node cnt, x, z;

void bfs(){
	while(q.size()){
		x=q.front();
		q.pop();
		if(x.step>ans)ans=x.step;
		if(x.x+1<=r&&Map[x.x+1][x.y]<Map[x.x][x.y]){
			z=x;
			z.x++;
			z.step++;
			q.push(z);
		}
		if(x.x-1>=1&&Map[x.x-1][x.y]<Map[x.x][x.y]){
			z=x;
			z.x--;
			z.step++;
			q.push(z);
		}
		if(x.y+1<=c&&Map[x.x][x.y+1]<Map[x.x][x.y]){
			z=x;
			z.y++;
			z.step++;
			q.push(z);
		}
		if(x.y-1>=1&&Map[x.x][x.y-1]<Map[x.x][x.y]){
			z=x;
			z.y--;
			z.step++;
			q.push(z);
		}
	}
}

int main() {
	scanf("%d%d",&r,&c);
	for(int i=1;i<=r;i++){
		for(int j=1;j<=c;j++){
			scanf("%d",&Map[i][j]);
			z.step=0;
			z.x=i;
			z.y=j;
			q.push(z);
		}
	}
	bfs();
	printf("%d",ans+1);
}

dfs

上文提到了，这道题至少得有三个变量才能表示一个状态。所以dfs的参数应该也有三个。每次调用dfs函数，先判断当前状态是否可以停止递归：四个方向都不可以再划了，即四个方向的数都比本数大，就更新最大值，并return停止递归。然后是怎么递归的问题：想判断某个方向是否能划，如果能，就dfs这个位置，并将次数+1。
（本蒟蒻很久之前的代码，码风有点奇怪，还请各位大佬见谅）

#include<bits/stdc++.h>
using namespace std;
int maxx = -1;
int a,b,Map[105][105],sum;
int dp[105][105];
void dfs(int x,int y,int len){
    if(x<1 || y<1 || x>a || y>b){
    	return;
	}
    if(dp[x][y] != 0){
        sum = max(sum,len+dp[x][y]-1);
        return;
    }
    sum = max(sum,len);
    if(Map[x][y+1] < Map[x][y]){
    	dfs(x,y+1,len+1);
	}
    if(Map[x+1][y] < Map[x][y]){
    	dfs(x+1,y,len+1);
	}
    if(Map[x][y-1] < Map[x][y]){
    	dfs(x,y-1,len+1);
	}
    if(Map[x-1][y] < Map[x][y]){
    	dfs(x-1,y,len+1);
	}
}
int main()
{
    scanf("%d%d",&a,&b);   
    for(int i = 1; i <= a; i++){
        for(int j = 1; j <= b; j++){
            scanf("%d",&Map[i][j]);
        }
    }
    for(int i = 1; i <= a; i++){
        for(int j = 1; j <= b; j++){
            sum = 0;
            dfs(i,j,1);
            dp[i][j] = sum;
            maxx = max(maxx,sum);
        }
    }
    printf("%d",maxx);
    return 0;
}