403. Frog Jump leetcode

最新推荐文章于 2020-04-16 21:08:41 发布

KiloMeterKM

最新推荐文章于 2020-04-16 21:08:41 发布

阅读量305

点赞数

分类专栏： leetcode 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/KingYMxe/article/details/78971135

版权

leetcode 专栏收录该内容

5 篇文章

订阅专栏

本文探讨了一个经典的青蛙过河问题，通过动态规划的方法解决了青蛙如何跳跃才能顺利过河的挑战。文章提供了两种不同的递归解决方案，并通过调整递归顺序提高了算法效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

A frog is crossing a river. The river is divided into x units and at each unit there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.

Given a list of stones' positions (in units) in sorted ascending order, determine if the frog is able to cross the river by landing on the last stone. Initially, the frog is on the first stone and assume the first jump must be 1 unit.

If the frog's last jump was k units, then its next jump must be either k - 1, k, or k + 1 units. Note that the frog can only jump in the forward direction.

Note:

The number of stones is ≥ 2 and is < 1,100.
Each stone's position will be a non-negative integer < 231.
The first stone's position is always 0.

Example 1:

[0,1,3,5,6,8,12,17]

There are a total of 8 stones.
The first stone at the 0th unit, second stone at the 1st unit,
third stone at the 3rd unit, and so on...
The last stone at the 17th unit.

Return true. The frog can jump to the last stone by jumping 
1 unit to the 2nd stone, then 2 units to the 3rd stone, then 
2 units to the 4th stone, then 3 units to the 6th stone, 
4 units to the 7th stone, and 5 units to the 8th stone.

Example 2:

[0,1,2,3,4,8,9,11]

Return false. There is no way to jump to the last stone as 
the gap between the 5th and 6th stone is too large.

题目大意：给定石头间的距离，第一块石头即起点为0，第一次跳跃的步数一定是1，之后每跳跃一次的距离为k-1，k或者k，k是上一次跳跃的大小，判断是否能够跳到终点，注意不能往后跳。

一开始我的想法很简单，直接递归调用，没有悬念的TLE。。。代码如下

class Solution {
    Map<Integer, Integer> map = new TreeMap<>();
	int max;
	public boolean canCross(int[] stones) {
		max=stones[stones.length-1];
		for(int i=0;i<stones.length;i++) {
			map.put(stones[i], 1);
		}
		return dfs(1,1);
	}
	boolean dfs(int now,int count) {
		if(now==max)
			return true;
		if(!map.containsKey(now))
			return false;
		if(count==1) {
			if(dfs(now+count,count))
				return true;
			if(dfs(now+count+1,count+1))
				return true;
		}
		else {
			if (dfs(now + count - 1, count - 1))
				return true;
			if (dfs(now + count, count))
				return true;
			if (dfs(now + count + 1, count + 1))
				return true;
		}
		return false;
	}
}

之后想了下，开了个数组来保存跳跃失败的信息，cannot[i][j]代表在第i块石头以步数j能否到达终点，每次递归调用时进行判断，然后就AC了

class Solution {
    Map<Integer, Integer> map = new TreeMap<>();
	int max;
	int[][] cannot;
	public boolean canCross(int[] stones) {
		max=stones[stones.length-1];
		cannot=new int[1000][1200];
		for(int i=0;i<stones.length;i++) {
			map.put(stones[i], i);
		}
		return dfs(1,1);
	}
	boolean dfs(int now,int count) {
		if(now==max)
			return true;
		if(!map.containsKey(now)||cannot[map.get(now)][count]==1)
			return false;
		if(count==1) {
			if(dfs(now+count,count))
				return true;
			if(dfs(now+count+1,count+1))
				return true;
		}
		else {
			if (dfs(now + count - 1, count - 1))
				return true;
			if (dfs(now + count, count))
				return true;
			if (dfs(now + count + 1, count + 1))
				return true;
		}
		cannot[map.get(now)][count]=1;
		return false;
	}
}

看了下discuss大佬们的代码，发现一个很有意思的评论。

大意如下：如果用1,5,100块钱来凑齐601块钱，最好就是先从大的钱开始凑起。就是说递归的顺序很重要，先把步数比较大的情况遍历完。

前面我是从步数小的开始遍历，改变了下遍历顺序后，果然速度有所提升。

class Solution {
    Map<Integer, Integer> map = new TreeMap<>();
	int max;
	int[][] cannot;
	public boolean canCross(int[] stones) {
		max=stones[stones.length-1];
		cannot=new int[1000][1200];
		for(int i=0;i<stones.length;i++) {
			map.put(stones[i], i);
		}
		return dfs(1,1);
	}
	boolean dfs(int now,int count) {
		if(now==max)
			return true;
		if(!map.containsKey(now)||cannot[map.get(now)][count]==1)
			return false;
		if(count==1) {
			if(dfs(now+count+1,count+1))               //这里的遍历顺序变了下，先遍历步数较大的情况
				return true;
			if(dfs(now+count,count))
				return true;
		}
		else {
			if (dfs(now + count + 1, count + 1))
				return true;
			if (dfs(now + count, count))
				return true;
			if (dfs(now + count - 1, count - 1))
				return true;
		}
		cannot[map.get(now)][count]=1;
		return false;
	}
}