首页目录 点击查看

第一题

• 难度：中等
• 题目：5. 最长回文子串
  给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

输入: "cbbd"
输出: "bb"

解题思路

• 这道题我也是看了题解的解题思路才想出来的，具体分为两种方式，动态规划还有中心扩展
• 动态规划
  解决这类问题的核心思想就是两个字“延伸”，具体来说
  如果一个字符串是回文串，那么在它左右分别加上一个相同的字符，那么它一定还是一个回文串
  如果在一个不是回文字符串的字符串两端添加任何字符，或者在回文串左右分别加不同的字符，得到的一定不是回文串
  事实上，上面的分析已经建立了大问题和小问题之间的关联，基于此，我们可以建立动态规划模型。
  我们可以用 dp[i][j] 表示 s 中从 i 到 j（包括 i 和 j）是否可以形成回文，状态转移方程只是将上面的描述转化为代码即可：

if (s[i] === s[j] && dp[i + 1][j - 1]) {
  dp[i][j] = true;
}

• 中心扩展法
  回文串一定是对称的
  每次选择一个中心，进行中心向两边扩展比较左右字符是否相等
  中心点的选取有两种
  aba，中心点是b
  aa，中心点是两个a之间
  所以共有两种组合可能
  left：i，right：i
  left：i，right：i+1

  
  
  image.png

我的答案

• 动态规划：

          var longestPalindrome = function (s) {
            if (s.length === 1) {
                return s;
            }
            if (!s.length) {
                return ""
            }
            let dp = [],
                res = s[0]
            for (let i = s.length - 1; i >= 0; i--) {
                dp[i] = []
                for (let j = i; j < s.length; j++) {
                    if (j - i === 0) {
                        dp[i][j] = true
                    } else if (s[i] === s[j] && (j - i === 1)) {
                        dp[i][j] = true
                    } else if (s[i] === s[j] && dp[i + 1][j - 1]) {
                        dp[i][j] = true
                    }
                    if (dp[i][j] && j - i + 1 > res.length) {
                        res = s.slice(i, j + 1)
                    }
                }
            }
            return res
        };
        console.log(longestPalindrome("123212"))

image.png

        var longestPalindrome = function (s) {
            let result = s[0] || "";
            for (let i = 0; i <= s.length - 1; i++) {
                for (let j = 1; j <= 2; j++) {
                    let left = i;
                    right = i + j;
                    while (left >= 0 && right < s.length && s[left] === s[right]) {
                        left--;
                        right++
                    }
                    let length = right - left - 1; //(right - 1) - (left + 1) + 1
                    if (length > result.length) {
                        result = s.substr(left + 1, length);
                    }
                }
            }
            return result
        };
        console.log(longestPalindrome("123212"))

这两个性能差距实在太大了，动态规划的性能实在太差，所以如果真遇到相同情况，强烈推荐中心扩展的方法。

第二题

• 难度：简单
• 题目：53. 最大子序和
  给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例

输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

解题思路

• 这道题采用动态规划，如果当前sum加当前nums[i]，大于nums[i]，则代表至少加上这个数不会成为负数，如果是小于nums[i],则直接使用nums[i]，代表它比之前的所有数的和都要大就没必要要前面的值了。

我的答案

var maxSubArray = function (nums) {
    let ans = nums[0];
    let sum = 0;
    for (let i = 0; i <= nums.length - 1; i++) {
        if (sum + nums[i] > nums[i]) {
            sum += nums[i];
        } else {
            sum = nums[i]
        }
        ans = Math.max(ans, sum)
    }
    return ans
};

• 时间复杂度：O(N)

  
  
  image.png

第三题

• 难度：中等
• 题目：62. 不同路径
  一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

问总共有多少条不同的路径？

image.png

例如，上图是一个7 x 3 的网格。有多少可能的路径？

示例

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右

输入: m = 7, n = 3
输出: 28

解题思路

• 这道题考验的是动态规划，当前dp[n,m] = dp[n+1][m] + dp[n][m+1]如下图：

  
  
  image.png

我的答案

var uniquePaths = function (m, n) {
    let arr = []
    for (let i = n - 1; i >= 0; i--) {
        for (let j = m - 1; j >= 0; j--) {
            if (i == n - 1 || j == m - 1) {
                if (!arr[i]) {
                    arr[i] = []
                }
                arr[i][j] = 1
            } else {
                arr[i][j] = arr[i + 1][j] + arr[i][j + 1]
            }
        }
    }
    return arr[0][0]
};

image.png

第四题

• 难度：中等
• 题目：64. 最小路径和

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。

示例

image.png

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。

输入：grid = [[1,2,3],[4,5,6]]
输出：12

解题思路

• 这道题只是需要在走下一步时，比较一下上下哪个元素更小，只需要加上最小的那个元素即最小路径和

我的答案

var minPathSum = function (grid) {
    let n = grid.length;
    let m = grid[0].length
    let arr = []
    for (let i = 0; i <= n - 1; i++) {
        for (let j = 0; j <= m - 1; j++) {
            if (i === 0 && j === 0) continue;
            if (j === 0) {
                grid[i][j] = grid[i - 1][j] + grid[i][j];
            } else if (i === 0) {
                grid[i][j] = grid[i][j - 1] + grid[i][j];
            } else {
                grid[i][j] = Math.min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j]
            }
        }
    }
    return grid[n-1][m-1]
};

image.png