爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 3
输出： 3
解释：有三种方法可以爬到楼顶。

1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶
2 阶 + 1 阶

// 动态规划，总结规律f(n) = f(n-1)+f(n-2)
// 1,1
// 2,2
// 3,3
// 4,5
// 5,8

var climbStairs = function(n) {
    //创建一个数组，用于爬楼梯种类数组的数值
    const dp=[]
    //初始化数组，1楼1种方式，2楼两种方式
    dp[1] = 1,dp[2] = 2
    for(let i=3;i<=n;i++){
        dp[i] = dp[i-1]+dp[i-2]
    }
    console.log(dp[n])
    return dp[n]
};

买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

var maxProfit = function (prices) {
    // 初始化最大收益为0，最低买入价格为第一天股票价格
    let max_get = 0,min_price = prices[0]

    for(var i=0;i<prices.length;i++){
        if(min_price>prices[i]){ //如果当前价格比最低价格还低
            min_price = prices[i] //更新最低价格
        }else{ //如果当前利润比之前利润高，则更新利润
            max_get = Math.max((prices[i] - min_price),max_get)
        }
    }
    console.log(max_get)
    return max_get
}

最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
1、数组方式

var maxSubArray = function(nums) {
    let res = 0,arr = []
    for(let i=0;i<nums.length;i++){
        if(res>0){
            res+=nums[i]
        }else{
            res = nums[i]
        }
        arr.push(res)
    }
    console.log(Math.max(...arr))
};

2、// 动态规划

var maxSubArray = function(nums) {
    let bp = [] //初始化一个新数组
    bp[0] = nums[0] //第一个值存入数组中

    for(let i=1;i<nums.length;i++){
        if(bp[i-1]>0){ //如果前一个和大于0，继续加
            bp[i] = bp[i-1] + nums[i]
        }else{//如果前一个和小于零，值重置为当前值
            bp[i] = nums[i]
        }
    }
    console.log(bp)
    console.log(Math.max(...bp))
    return Math.max(...bp)
};

打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

// 动态规划
var rob = function(nums) {
    let pb = []
    pb[0] = nums[0]
    pb[1] = Math.max(nums[0],nums[1])
    pb[2] = Math.max(pb[0]+nums[2],pb[1])
    if(nums.length==1) return nums[0]
    if(nums.length==2) return pb[1]

    for(let i=2;i<nums.length;i++){
        pb[i] = pb[i-2]+nums[i]
        if(pb[i]<pb[i-1]){
            pb[i] = pb[i-1]
        }
    }
    console.log(pb)
    console.log(Math.max(...pb))
};