LeetCode 12.7

198.打家劫舍

//动态规划，当前最大值要么等于前面第二个的最大值加上这一家的值，要么就等于前一家的最大值。（动态规划优点难理解）
var rob = function(nums) {
    let dp = [];
    dp[0] = nums[0];
    if(nums.length===1) return dp[0];
    dp[1] = Math.max(nums[0],nums[1])
    if(nums.length===2) return dp[1];
    for(let i =2;i<nums.length;i++){
        dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1]);
    }
    return dp.pop()
};

155.最小栈

//Infinity正无穷大的数值。在pop弹栈时，其实每一个栈顶元素都对应了一个最小值，放在最小栈的栈顶，这个栈顶元素弹出后，对应的最小值也直接弹出了。一开始以为保存最小值就可以，没有考虑弹栈时最小值也改变了。
var MinStack = function() {
    this.stack = [];
    this.min = [Infinity];
};

/** 
 * @param {number} val
 * @return {void}
 */
MinStack.prototype.push = function(val) {
    this.stack.push(val);
    this.min.push(Math.min(this.min[this.min.length-1], val));
};

/**
 * @return {void}
 */
MinStack.prototype.pop = function() {
    this.stack.pop();
    this.min.pop();
    
};

/**
 * @return {number}
 */
MinStack.prototype.top = function() {
    return this.stack[this.stack.length-1];
};

/**
 * @return {number}
 */
MinStack.prototype.getMin = function() {
    return this.min[this.min.length-1];
};

384.打乱数组

//需要注意时shuffle的算法，这里用随机数交换，随机数的范围时当前索引后的索引大小，如果范围设置为0到数组长度。
//居然也是可以的。
var Solution = function(nums) {
    this.nums=nums;
    this.arr = [...this.nums];

};

/**
 * @return {number[]}
 */
Solution.prototype.reset = function() {
    return this.nums
};

/**
 * @return {number[]}
 */
Solution.prototype.shuffle = function() {
    for(let i =0;i<this.arr.length;i++){
        //const j = Math.floor(Math.random() * (this.arr.length-i))+i;
        const j = Math.floor(Math.random() * (this.arr.length));
        let tmp = this.arr[i];
        this.arr[i] = this.arr[j];
        this.arr[j] = tmp;
    }
    return this.arr;
};

412.Fizz Buzz

var fizzBuzz = function(n) {
    let arr = [];
    for(let i =0;i<n;i++){
        tmp = i+1;
        if(tmp%15===0){
            arr[i] = "FizzBuzz";
            continue;
        }
        if(tmp%3===0){
            arr[i] = "Fizz";
            continue;
        }
        if(tmp%5===0){
            arr[i] = "Buzz";
            continue;
        }
        arr[i]= tmp.toString();
    }
    return arr;
};

363.3的幂

//暴力递归
var isPowerOfThree = function(n) {
    if(n===1) return true;
    if(n<3) return false;
    return helper(n);
};
var helper = n =>{
    if(n===1) return true;
    if(n%3===0) return helper(n/3);
    return false;
}
//取巧，32位符号数最大的三的幂是3^19，判断是否为他的约数即可。
var isPowerOfThree = function(n) {
    let max = helper(19);
    // console.log(max)
    return n>0&&max%n===0;
};
var helper = n =>{
    if(n===0) return 1;
    return 3*helper(n-1);
}
//直接赋值。
var isPowerOfThree = function(n) {
    return n>0&&1162261467%n===0;
};

13.罗马数字转整数

//暴力哈希
var romanToInt = function(s) {
    let map = new Map([
        ["I",1],
        ["V",5],
        ["X",10],
        ["L",50],
        ["C",100],
        ["D",500],
        ["M",1000]
    ]);
    let res = 0;
    let pre = Number.MAX_SAFE_INTEGER;
    for(let i of s){
        let tmp = map.get(i);
        console.log(tmp)
        res += pre>=tmp?tmp:tmp-pre-pre;
        pre = tmp;
    }
    return res;
};
//改善后的哈希
var romanToInt = function(s) {
    let map = new Map([
        ["I",1],
        ["V",5],
        ["X",10],
        ["L",50],
        ["C",100],
        ["D",500],
        ["M",1000],
        ["a",4],
        ["b",9],
        ["c",40],
        ["d",90],
        ["e",400],
        ["f",900],
    ]);
    let res = 0;
    s = s.replace("IV","a");
    s = s.replace("IX","b");
    s = s.replace("XL","c");
    s = s.replace("XC","d");
    s = s.replace("CD","e");
    s = s.replace("CM","f");
    for(let i of s){
        let tmp = map.get(i);
        res += tmp;
    }
    return res;
};

204.计数质数

//根据因子对称性，遍历到sqrt(n)即可。这个算法其实就是，将每一个有非1因数的数对应索引值赋为false。
var countPrimes = function(n) {
    let store = new Array(n).fill(true);
    let res = 0;
    for(let i=2;i*i<n;i++){
        if(store[i]){
            for(let j=i*i;j<n;j+=i){
                store[j]=false;
            }
        }
    }
    //n=0||1时，质数数量为0；
    store.shift();
    store.shift();
    for(let i of store){
        i&&res++;
    }
    return res;
};