算法题

动态规划

leetcode 64.最小路径和

/**
 * @param {number[][]} grid
 * @return {number}
 */
var minPathSum = function (grid) {
    const row = grid.length;
    const col = grid[0].length;
    const dp = new Array(row).fill(0).map(item => new Array(col).fill(0));
    dp[0][0] = grid[0][0];
    for (let i = 1; i < row; i++) { //初始化第一行
        dp[i][0] = dp[i - 1][0] + grid[i][0];
    }
    for (let i = 1; i < col; i++) { // 初始化第一列
        dp[0][i] = dp[0][i - 1] + grid[0][i];
    }
    for (let i = 1; i < row; i++) {
        for (let j = 1; j < col; j++) {
            dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]; //选最小
        }
    }

    return dp[row - 1][col - 1];
};

leetcode 55.跳跃游戏

var canJump = function (nums) {
    let mostFar = 0;

    for (let i = 0; i < nums.length; i++) {
        if (i >= mostFar) {
            return false;
        }
        mostFar = Math.max(mostFar, i + nums[i]);
    }
    return true;
};

leetcode 56.合并区间

var merge = function (intervals) {
    intervals.sort((a, b) => a[0] - a[0]);
    console.log("排序", intervals);
    const result = [];
    for (let i = 0; i < intervals.length; i++) {
        const len = result.length;
        const val = intervals[i];
        if (len > 0 && val[0] <= result[len - 1][1]) {
            result[len - 1][1] = Math.max(val[1], result[len - 1][1])
        } else {
            result.push(val);
        }
    }
    // console.log(result);
    return result;
}

leetcode 70.爬楼梯

/**
 * @param {number} n
 * @return {number}
 */
// var climbStairs = function (n) {
//     if (n <= 0) return 0;
//     if (n == 1) return 1;
//     if (n == 2) return 2;

//     return climbStairs(n - 1) + climbStairs(n - 2);
// };

// 优化时间复杂度
var climbStairs = function (n) {
    const memo = [0, 1, 2];
    if (n < 3) return memo[n];

    for (let i = 3; i <= n; i++) {
        memo[i] = memo[i - 1] + memo[i - 2];
    }
    return memo[n];
};

// 优化空间复杂度
var climbStairs = function (n) {
    if (n <= 0) return 0;
    if (n == 1) return 1;
    if (n == 2) return 2;

    let prepre = 1;
    let pre = 2;
    let result = 0;
    for (let i = 3; i <= n; i++) {
        result = pre + prepre;
        prepre = pre;
        pre = result;
    }
    return result;
};

leetcode 128.最长连续序列

/**
 * @param {number[]} nums
 * @return {number}
 */
var longestConsecutive = function (nums) {
    let maxLen = 0;
    const res = new Set(nums);

    for (const n of res) {
        // [100, 4, 200, 1, 3, 2] 会跳过4,3,2。 1是最小的从1开始while查找下一个，找完赋值
        if (res.has(n - 1)) { // 当前数字不能作为序列开始字符，有更小的选项
            continue;
        }
        let next = n + 1;
        while (res.has(next)) { // 不断查找是否有下一个
            next++;
        }
        // while结束，连续子串结束
        maxLen = Math.max(maxLen, next - n);
    }
    return maxLen
};

进制转换

/**
 * @param {number} num
 * @return {string}
 */
var convertToBase7 = function (num) {
    if (num > -7 && num < 7) return String(num);
    let bool = num < 0;
    num = Math.abs(num);
    const result = [];
    while (num > 0) {
        result.push(num % 7);
        num = Math.floor(num / 7);
    }
    if(bool){
        result.push("-");
    }

    return result.reverse().join('');
};