LeetCode 403. Frog Jump

最新推荐文章于 2021-04-29 21:25:49 发布

Llunnn

最新推荐文章于 2021-04-29 21:25:49 发布

阅读量300

点赞数

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

本文链接：https://blog.csdn.net/Llunnn/article/details/78951008

版权

算法分析专栏收录该内容

19 篇文章 0 订阅

订阅专栏

题目描述

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 < 2^31.
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.

算法分析
看起来像比较典型的动态规划？看起来就很麻烦..因为下一跳有k-1, k, k+1三种可能..而石头可能的位置有2^31种，这就不允许我们简单的以跳到某个位置上的步数作为一个状态。于是考虑用跳到某块石头上的步数作为一个状态。

实现的时候反而像是个递推。到达某个状态后再为后面的每个石头添加状态，因为可能的步数太多了。对于当前所在状态，从是否能到达最后一块石头往前判断，那么往后为每块石头所添加状态的步数会是倒序的，从而实现对每个状态线性时间的处理。

说起思路倒不难，可能方法太朴素所以if语句的嵌套比较复杂，不知道怎么有心思写完的这道题…

具体实现

class Solution {
public:
    bool canCross(vector<int>& stones) {
        vector< vector<int> > flags(1100);
        if (stones[0] != 0 || stones[1] != 1)
            return false;
        flags[0].push_back(0);
        flags[1].push_back(1);
        for (int i = 1 ; i < stones.size() - 1; i++) {
            int k = stones.size()-1;
            for (auto j : flags[i]) {
                if (k <= i)
                    break;
                while (j + 1 + stones[i] < stones[k]) {
                    if (k > i+1) k--;
                    else break;
                }
                if (j+1 + stones[i] > stones[k]) {
                    if (j + stones[i] > stones[k]) {
                        if (j - 1 + stones[i] > stones[k]) {
                            continue;
                        } else {
                            if (j - 1 + stones[i] == stones[k]) {
                                flags[k].push_back(j-1);
                            } else {
                                continue;
                            }
                        }
                    } else {
                        flags[k].push_back(j);
                        k--;
                        if (j - 1 + stones[i] == stones[k]) {
                            flags[k].push_back(j-1);
                        } else {
                            continue;
                        }
                    }
                } else {
                    if (j + 1 + stones[i] == stones[k]) {
                        if (flags[k].size() == 0 || flags[k][flags[k].size()-1] != j+1) {
                            flags[k].push_back(j+1);
                            k--;
                            if (j + stones[i] > stones[k]) {
                                if (j - 1 + stones[i] == stones[k]) {
                                    flags[k].push_back(j-1);
                                } else {
                                    continue;
                                }
                            } else {
                                flags[k].push_back(j);
                                k--;
                                if (j - 1 + stones[i] > stones[k]) {
                                    continue;
                                } else {
                                    if (j - 1 + stones[i] == stones[k]) {
                                        flags[k].push_back(j-1);
                                    } else {
                                        continue;
                                    }
                                }
                            }
                        }
                    } else {
                        break;
                    }
                }
            }
        }

        if (flags[stones.size()-1].size() != 0) return true;
        else return false;
    }
};