LeetCode动态规划(简单）

买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 =6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

解法一

//两个for循环暴力解决
	public static int maxProfit(int[] prices){
        int maxProfit=0;
        for (int i = 0; i < prices.length-1; i++) {
            for (int j = i+1; j < prices.length-1; j++) {
                int profit=prices[j]-prices[i];
                if (profit>maxProfit)
                    maxProfit=profit;
            }
        }
        return maxProfit;
    }

解法二

//只需要单次遍历
 /**
     * 找到最低价
     * @param prices
     * @return
     */
    public static int maxProfit2(int[] prices){
        int minPrice=Integer.MAX_VALUE;
        int maxProfit=0;
        for (int i = 0; i < prices.length; i++) {
            if (prices[i]<minPrice)
                minPrice=prices[i];
            else if (prices[i]-minPrice>maxProfit)
                maxProfit=prices[i]-minPrice;
        }
        return maxProfit;
    }

爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

public int climbStairs(int n) {
        int[] dp=new int[n+1];
            dp[0]=1;
            dp[1]=1;
        //动态规划通常是
        for(int i=2;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }

爬楼梯2

数组的每个索引做为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 costi。

每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。

您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。

示例 1:

输入: cost = [10, 15, 20]
输出: 15
解释: 最低花费是从cost[1]开始，然后走两步即可到阶梯顶，一共花费15。

示例 2:

输入: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
输出: 6
解释:最低花费方式是从cost[0]开始，逐个经过那些1，跳过cost[3]，一共花费6。

注意：

cost 的长度将会在 [2, 1000]。
每一个 cost[i] 将会是一个Integer类型，范围为 [0, 999]。

	/**
    * 爬楼梯问题，cost数组表示每一级楼梯的代价
    **/
    public int minCostClimbingStairs(int[] cost) {
        int memo[]=new int[cost.length+1];
        
        memo[0]=0;
        memo[1]=0;
        for(int i=2;i<=cost.length;i++){
            int a=memo[i-1]+cost[i-1];
            int b=memo[i-2]+cost[i-2];
            memo[i]=Math.min(a,b);
        }
        return memo[cost.length];
    }

入室盗窃

你作为一个江洋大盗进行入室盗窃，但是相邻两家不得侵入。给定一个数组，表示0到n-1家的财物，求可以盗取的最大值。

	public int rob2(int[] nums){
        int n=nums.length;
        if(n==0)
            return 0;
        int[] memo=new int[n];
        memo[n-1]=nums[n-1];
        for(int i=n-2;i>=0;i--){
           // memo[i] 表示考虑抢劫 nums[i...n-1] 所能获得最大收益（不是说一定从 i 开始抢劫）
           // memo[i] 的取值在考虑抢劫 i 号房子和不考虑抢劫之间取最大值
            memo[i]=Math.max(nums[i]+(i+2>=n?0:memo[i+2]),nums[i+1]+(i+3>=n?0:memo[i+3]));
        }
        return memo[0];
    }

除数博弈

爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。

最初，黑板上有一个数字 N 。在每个玩家的回合，玩家需要执行以下操作：

选出任一 x，满足 0 < x < N 且 N % x == 0 。
用 N - x 替换黑板上的数字 N 。
如果玩家无法执行这些操作，就会输掉游戏。

只有在爱丽丝在游戏中取得胜利时才返回 True，否则返回 false。假设两个玩家都以最佳状态参与游戏。

示例 1：

输入：2
输出：true
解释：爱丽丝选择 1，鲍勃无法进行操作。

示例 2：

输入：3
输出：false
解释：爱丽丝选择 1，鲍勃也选择 1，然后爱丽丝无法进行操作。

提示：

1 <= N <= 1000

归纳法可证明： 如果对N是为False,那么当N+1时只需要取x=1, 那么N+1结果必定为True 显然可以判断 1,2分别位False,True, 不妨假设对任意小于N的奇数为False,偶数为True 那么对于N: 如果N为偶数，那么N-1为奇数False,得N为True 如果N为奇数，那么N的因数x必定为奇数, 则N-x为偶数必定为True, 得到N为False

	public boolean divisorGame(int N) {
        return N%2==0;
    }

303.区域和检索——数组不可变

给定一个整数数组 nums，求出数组从索引 i 到 j (i ≤ j) 范围内元素的总和，包含 i, j 两点。

示例：

给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()

sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3

说明:

你可以假设数组不可变。
会多次调用 sumRange 方法。

class NumArray {

    private int[] sums;
    
    public NumArray(int[] nums) {
        sums=new int[nums.length];
        if(nums.length==0){
            return;
        }
        sums[0]=nums[0];
        for(int i=1;i<nums.length;i++){
            sums[i]+=sums[i-1]+nums[i];
        }
    }
    
    public int sumRange(int i, int j) {
        if(i==0){
            return sums[j];
        }else{
            return sums[j]-sums[i-1];
        }
    }
}

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * int param_1 = obj.sumRange(i,j);
 */