算法篇_动态规划

好像很多动规都会定义一个数组
连续子数组的最大和(最大子数组和）
状态方程：dp[i]=max(dp[i-1]+arr[i]，arr[i])

var maxSubArray = function(nums) {
    let max=nums[0];
    let dp=[nums[0]];
    for(let i=1;i<nums.length;i++){
        dp[i]=Math.max(dp[i-1]+nums[i],nums[i]);//此行是判断加与不加前面的dp[i-1]，如果dp[i-1]<0，那还不如不加，nums[i]独自美丽;
        max=Math.max(max,dp[i]);//此行是判断nums[i]的情况，如果nums[i]<0,那加上只会让dp[i]变小
    }
    return max;
};

另：参见剑指offer力扣官方题解

var maxSubArray = function(nums) {
    let pre=0, max=nums[0];
    nums.forEach(num=>{
        pre=Math.max(pre+num,num)
        max=Math.max(max,pre)//Math.max(pre+num,pre)把pre+num替换成max
    })
    return max
};

最长上升子序列

var lengthOfLIS = function(nums) {
    if(nums.length<=0) return 0;
    const arr=new Array(nums.length).fill(1);
    for(let i=0;i<nums.length;i++){
        for(let j=0;j<i;j++){
            if(nums[j]<nums[i]){
                arr[i]=Math.max(arr[i],arr[j]+1)
            }
        }
    }
    return Math.max(...arr)//Math.max不能接收数组
};

最长重复子数组
dp[i][j]含义：以下标i-1为结尾的nums1，和以下标j-1为结尾的nums2，最⻓重复⼦数组⻓度为dp[i][j]
递推公式：若nums1[i - 1] === nums2[j - 1]，则dp[i][j] = dp[i - 1][j - 1] + 1
dp初始化：dp[i][j]全都初始化为0

const findLength = (nums1, nums2) => {
    const [m, n] = [nums1.length, nums2.length];
    const dp = [];
    // dp数组初始化
    // 先让所有元素为0
    for (let i = 0; i <= m; i++) {
        dp[i] = [];
        for (let j = 0; j <= n; j++) {
            dp[i].push(0);
        }
    }
    let res = 0;
    for (let i = 1; i <= m; i++) {
        for (let j = 1; j <= n; j++) {
            if (nums1[i - 1] === nums2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            }
            res = dp[i][j] > res ? dp[i][j] : res;
        }
    }
    return res;
};

跳台阶
递归会超时，所以用动态规划
斐波那契数列：f(n)=f(n-1)+f(n-2)，跳上n台阶的跳法等于跳上n-1台阶的跳法+跳上n-2台阶的跳法，因为每次可跳一步或两步。

function jumpFloor(number)
{
    const arr=[];
    arr[0]=1
    arr[1]=1;
    for(let i=2;i<=number;i++){
        arr[i]=arr[i-1]+arr[i-2];
    }
    return arr[number];
}

斐波那契数列

var fib = function(n) {
    const arr=[];
    arr[0]=0;
    arr[1]=1;
    arr[2]=1;
    for(let i=3;i<=n;i++){
        arr[i]=(arr[i-1]+arr[i-2])%1000000007;
    }
    return arr[n];
};

变态跳台阶（跳台阶扩展问题）
找规律，每一层跳法为2^n-1

function jumpFloorII(number)
{
    return Math.pow(2,number-1);
}

矩形覆盖
也是斐波那契数列，f(n)=f(n-1)+f(n-2),f(1)=1,f(2)=2

function rectCover(number)
{
    if(number===0) return 0;
    if(number===1) return 1;
    if(number===2) return 2;
    const arr=[];
    arr[0]=0;
    arr[1]=1;
    arr[2]=2;
    for(let i=3;i<=number;i++){
        arr[i]=arr[i-1]+arr[i-2];
    }
    return arr[number];
}

把数字翻译成字符串
其实和跳台阶、斐波那契数列、矩形覆盖的状态方程一样，只不过中间多了些判断条件
dp[i]表示前i个数字翻译的可能数，
1，如果第i个数字单独翻译，dp[i-1]
2，第i个数字联合它前一个数字i-1一起翻译dp[i-2]
但是第2点是有条件的，即字符[i-1][i]组成的数字要满足在10和25之间,即大于等于10，小于等于25
力扣上从0-25开始编码版，传入的是一串数字：

var translateNum = function(num) {
    const arr=[];
    arr[0]=1;//num长度为0时规定只有一种翻译方法
    arr[1]=1;//num长度为1时只有一种翻译方法
    const str=num.toString();
    for(let i=2;i<=str.length;i++){
        let preNum=parseInt(str[i-2]+str[i-1]);
        if(preNum>=10&&preNum<=25){
            arr[i]=arr[i-2]+arr[i-1];
        }else{
            arr[i]=arr[i-1];
        }
    }
    return arr[str.length];
};

剑指offer上从1-26开始编码版（要考虑单独的0不能编码），而且剑指offer传入的是字符串，所以不需要再转成字符串
（不熟练）

function solve( nums ) {
    const arr=[];
    arr[0]=1;
    //arr[1]=1;
    //let str=nums.toString();
    for(let i=1;i<=nums.length;i++){
        //let preNum=parseInt(str[i-2]+str[i-1]);
        arr[i]= nums[i-1]==='0'? 0:arr[i-1];//单独一位编码
        if((i>=2)&&((nums[i-2]=='1')||(nums[i-2]=='2'&&nums[i-1]<=6))){
           arr[i]=arr[i]+arr[i-2];//两位编码
           }
    }
    return arr[nums.length];
}

买卖股票的最好时机（一）

function maxProfit( prices ) {
    let min_buy=Infinity;
    let max_profit=0;
    for(let price of prices){
        if(price<min_buy){min_buy=price;}//小于min_buy的值作为新的买入值
        else{//如果当前price不小于min_buy,考虑卖出
            max_profit=Math.max(max_profit,price-min_buy);//并比较当前卖出收益大还是之前卖出利润大
        }
    }
    return max_profit;
}

打家劫舍
dp[i]=max（（dp[i−2]+nums[i]），dp[i−1]）
边界条件：
dp[0]=nums[0] 只有一间房屋，则偷窃该房屋
dp[1]=max(nums[0],nums[1]) 只有两间房屋，选择其中金额较高的房屋进行偷窃

var rob = function(nums) {
    const arr=[];
    arr[0]=nums[0];
    arr[1]=Math.max(nums[0],nums[1]);
    for(let i=2;i<nums.length;i++){
        arr[i]=Math.max(arr[i-2]+nums[i],arr[i-1]);
    }
    return arr[nums.length-1]
};

礼物的最大价值（没自己敲，代码前半段也没看太懂）
设 res(i, j)为从棋盘左上角走至单元格 (i ,j)的礼物最大累计价值，易得到以下递推关系：res(i,j)等于res(i,j−1) 和 res(i-1,j)中的较大值加上当前单元格礼物价值grid(i,j)。
即：res(i,j)=max[res(i,j−1),res(i−1,j)]+grid(i,j)

var maxValue = function(grid) {
    if(!grid.length){
        return 0
    }
    // 设置res 储存每个节点最大值的数组
    let res = []
    for(let i=0;i<grid.length;i++){
        res[i] = []
        for(let j =0;j<grid[0].length;j++){
            res[i][j] = 0
        }
    }
    // 算出向下走第一行的取值
    let m = 0
    for(let i =0;i<res.length;i++){
        m += grid[i][0]
        res[i][0] = m
    }
    // 算出向右走第一行的取值
    let n = 0
    for(let i =0;i<res[0].length;i++){
        n += grid[0][i]
        res[0][i] = n
    } 
    // 根据第一行的取值求剩下行的取值
    for(let i=1;i<grid.length;i++){
        for(let j =1;j<grid[0].length;j++){
            res[i][j] = Math.max(res[i][j-1],res[i-1][j])+grid[i][j]
        }
    } 
    return res[grid.length-1][grid[0].length-1]

};