螺旋矩阵(Leecode54)&跳跃游戏(Leecode55)

54. 螺旋矩阵

题目

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例 1:
输入:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
输出: [1,2,3,6,9,8,7,4,5]
示例 2:
输入:
[
[1, 2, 3, 4],
[5, 6, 7, 8],
[9,10,11,12]
]
输出: [1,2,3,4,8,12,11,10,9,5,6,7]

思路

1.如果数组为空，返回空数组2定义4个边界以及当i方向。
3当左边界小于等于右边界，且上边界小于等于下边界时，执行while循环：按照右,下,左,上的顺序，依次将路径上的字符添到结果里。
4.while循环结束后，返回结果。

push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
javascript。

/**
 * @param {number[][]} matrix
 * @return {number[]}
 */
var spiralOrder = function(matrix) {
    if(matrix.length===0){
        return [];
    }
    let top =0;
    let bottom =matrix.length-1;//矩阵列长
    let left=0;
    let right =matrix[0].length-1;//矩阵行长
    let direction="right",result=[];
    while(left<=right&&top<=bottom){
        if(direction==="right"){
            for(let i=left;i<=right;i++){
                result.push(matrix[top][i]);
            }
            top++;
            direction="down";
        }else if(direction==="down"){
            for(let i=top;i<=bottom;i++){
                result.push(matrix[i][right]);
               //push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
            }
            right--;
            direction="left";
        }else if(direction === "left"){
            for(let i=right;i>=left;i--){
                result.push(matrix[bottom][i]);
            }
            bottom--;
            direction="top";
        }
        else if(direction === "top"){
            for(let i=bottom;i>=top;i--){
                result.push(matrix[i][left]);
            }
            left++;
            direction="right";
    }
    }
    return result;
};

55. 跳跃游戏

题目

给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个位置。

示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

思路

方法一 运用动态规划法($dp$)

javascript。

/**
 * @param {number[]} nums
 * @return {boolean}
 */
//动态规划法
var canJump = function(nums) {
    const totalLength=nums.length;//记录数组长度
    const memo =Array(totalLength).fill(0);
    //dp
    memo[totalLength-1]=1;
    function jump(position){
        if(memo[position]===1){
        return true;}
        else if(memo[position]===-1){
        return false;
        }

    const maxJump =Math.min(position+nums[position],totalLength-1);
    for(let i=position+1;i<=maxJump;i++){
        const jumpResult =jump(i);
        if(jumpResult===true){
            memo[position]=1;
            return true;
        }
    }

    memo[position]=-1;
    return false;
}
let result=jump(0);
return result;
};

方法二 贪心法

下面我们使用贪心的思路看下这个问题，我们记录一个的坐标代表当前可达的最后节点，这个坐标初始等于$nums.length-1$，然后我们每判断完是否可达，都向前移动这个坐标，直到遍历结束。如果这个坐标等于0，那么认为可达，否则不可达。

class Solution {
    public boolean canJump(int[] nums) {
        
        if (nums == null) {
            return false;
        }
        int lastPosition = nums.length - 1;
        for (int i = nums.length - 1; i >= 0; i--) {
            // 逐步向前递推
            if (nums[i] + i >= lastPosition) {
                lastPosition = i;
            }
        }
        return lastPosition == 0;
    }
}

参考资料

人人都能看得懂的Leetcode刷题教程合集（最后更新：695 .岛屿的最
动态规划与贪心算法解决此问题