【5】最长回文串
重点回顾题
题外话：可能是以前参加ACM比赛时，被一道需要利用动态规划的题绊住了，导致到现在为止，只要看到跟动态规划有关的题，就打怵，这是留下了多大的阴影啊
假设当前判断的回文是从第 0 个字符，到第 4 个字符，那么就是推导 s[0] === s[4] && s[1-3] 是回文。
定义二维数组 dp，横坐标表示起始字符，纵坐标表示当前新加入字符，得到 dpi = s[i] === s[j] && dpi-1。
时间复杂度是 O(n*n/2)
var longestPalindrome = function(s) {
if (s === '') return ''
let arr = s.split('')
let dp = new Array(arr.length).fill([])
for (let i = 0; i < dp.length; i++) {
dp[i] = new Array(arr.length).fill(false)
}
let max = 1
let maxStart = 0
let maxEnd = 0
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j <= i; j++) {
if (i === j) {
dp[i][j] = true
}
if (i - j === 1) {
dp[i][j] = arr[i] === arr[j]
if (dp[i][j] && max < 2) {
max = 2
maxStart = j
maxEnd = i
}
}
if (i - j > 1) {
dp[i][j] = arr[i] === arr[j] && dp[i-1][j+1]
const len = i - j + 1
if (dp[i][j] && max < len) {
max = len
maxStart = j
maxEnd = i
}
}
}
}
let result = ''
for (let i = maxStart; i <= maxEnd; i++) {
result += arr[i]
}
return result
};
【8】字符串转换整数（atoi）
本题需要注意有符号和无符号，还有存储范围,按照程序化一步步操作就好
var myAtoi = function (str) {
const numreg = /^[0-9]*$/
const num = str.trim()
const result = parseInt(str) || 0
if (isNaN(result)) {
return 0;
}
if (num[0] == '-') {
const min = Math.pow(-2, 31)
return result < min ? min : result
}
else if (numreg.test(num[0]) || num[0] == '+') {//开头是数字
const max = Math.pow(2, 31) - 1
return result > max ? max : result
}
else {
return 0;
}
};
也可以用parseInt来处理
var myAtoi = function(str) {
str = str.trim();
var max = Math.pow(2,31)-1;
var min = -Math.pow(2,31);
str = parseInt(str);
if(str>=max){
return max;
}
if(str<=min){
return min;
}
if(isNaN(str)){
return 0;
}else{
return str;
}
};
【11】 盛最多水的容器
初看，转换成数学题，是求最大面积，所以又是一道动态规划题
看了官方题解的思路，双指针法是最优解法
var maxArea = function(height) {
let left = 0;
let right = height.length - 1;
let max = 0;
while(left < right) {
const area = (right - left) * Math.min(height[right], height[left]);
if (area > max) {
max = area
}
if (height[left] < height[right]) {
left++;
} else {
right--;
}
}
return max;
};
【238】除自身以外数组的乘积
看上去不难，但是有额外要求 :不要使用除法，且在 O(_n_) 时间复杂度
思路：记录每个元素左面所有元素的乘积（不包括自身）
右边的乘积不需要记录，直接和左面乘积相乘
/**
* @param {number[]} nums
* @return {number[]}
*/
var productExceptSelf = function (nums) {
let v = 1
let result=[1]
for (let i = 1; i < nums.length; i++) {
v *= nums[i - 1]
result[i] = v
}
v = 1
for (let i = nums.length - 1; i > 0; i--) {
v *= nums[i]
result[i - 1] *= v
}
return result
};
【78】子集
给定一组不含重复元素的整数数组 _nums_，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
看到 「子集」、「组合」这样的词语，首先想到回溯算法。
全排列：N!
组合：N!
子集：2^N ，每个元素都可能存在或不存在。
var subsets = function(nums) {
const n = nums.length;
const result = [];
if (nums.length < 1) return [[]];
const backTrace = (arr, currentIndex) => {
result.push(arr);
if (currentIndex >= n) return;
for (let i = currentIndex; i < n; ++i) {
arr.push(nums[i]);
backTrace(arr.slice(), i+1);
arr.pop();
}
}
backTrace([], 0);
return result;
};
小结：果然上了中等难度后，就真的开始变难了，好久不碰算法，记忆都模糊了，加油~