动态规划汇总

动态规划的几个算法

入门级

1.爬楼梯

class Solution {
    public int climbStairs(int n) {
        int[] num=new int[n+1];
        if(n==1) return 1;
        num[1]=1;num[2]=2;
        for(int i=3;i<n+1;i++){
            num[i]=num[i-1]+num[i-2];
        }
        return num[n];
    }
}

2.买卖股票

class Solution {
    public int maxProfit(int[] prices) {
        int[] maxValue=new int[prices.length];
        if(prices.length==0)return 0;
        int low=prices[0];
        maxValue[0]=0;
        for(int i=1;i<prices.length;i++){

            if(maxValue[i-1]>prices[i]-low){
                maxValue[i]=maxValue[i-1];
            }
            else{
                maxValue[i]=prices[i]-low;
            }
            if(prices[i]<low){
                low=prices[i];
            }
        }
        return maxValue[prices.length-1];
    }
}

3.打家劫舍

首先看 n = 1 的情况，显然 f(1) =nums[1]
再看 n =2 ,f(2)=max(nums[1],nums[2])
对于 n = 3，有两个选项:
抢第三个房子，将数额与第一个房子相加。
不抢第三个房子，保持现有最大数额
所以公式为

class Solution {
    public int max(int a,int b){
        if(a>b){
            return a;
        }
        else
            return b;
    }
    public int rob(int[] nums) {
        int[] money=new int[nums.length];
        if(nums.length==0) return 0;
        if(nums.length==1) return nums[0];
        money[0]=nums[0];
        money[1]=max(nums[0],nums[1]);
        for(int i=2;i<nums.length;i++){
            money[i]=max(money[i-1],money[i-2]+nums[i]);
        }
        return money[nums.length-1];
    }
}

变种1： 删除与获得点数

    public int deleteAndEarn(int[] nums) {
                int[] temp=new int[10001];

        //变形的打家劫舍，把所有的这个数值之和作为这个房子的价值就成了打家劫舍
        //看到这种隔一个的就应该灵活的反应过来
        for (int i=0;i<nums.length;i++){
            temp[nums[i]]+=nums[i];
        }

        int[] dp=new int[10001];
        dp[0]=0;dp[1]=temp[1];
        for (int j=2;j<dp.length;j++){
            dp[j]=Math.max(dp[j-2]+temp[j],dp[j-1]);
        }
        
        return dp[10000];
    }
    

变种2：

4.最大子序列

class Solution {
    public int maxSubArray(int[] nums) {
        int ans = nums[0];
        int sum = 0;
        for(int num: nums) {
            if(sum > 0) {
                sum += num;
            } else {
                sum = num;
            }
            ans = Math.max(ans, sum);
        }
        return ans;
    }
}

分治算法
将数组分为两段
最大的字段可能1.左半部分2.右半部分3横跨中间
1.2可以递归 3就在左半边从左半边的最右边开始找找到最大的,右边同理
然后拼起来

class Solution {
    public int max(int[] nums,int left,int right){
        if(left==right) return nums[left];
        int n=nums.length;
        int mid=(left+right)/2;
        int leftmax=max(nums,left,mid);
        int rightmax=max(nums,mid+1,right);
        int midmax=findmax1(nums,mid)+findmax2(nums,mid+1);
      
        return max1(leftmax,rightmax,midmax);
    }
    public int findmax1(int[] nums,int r){
        int temp=nums[r];int max=temp;
        int i=r-1;
        while(i>-1){
            temp+=nums[i];
            if(temp>max){
                max=temp;
            }
            i--;
        }
        return max;
    }
    public int findmax2(int[] nums,int l){
    int temp=nums[l];int max=temp;
        int i=l+1;
        while(i<nums.length){
            temp+=nums[i];
            if(temp>max){
                max=temp;
            }
            i++;
        }
        return max;
    }
    public int max1(int a,int b,int c){
        if(a>=b&&a>=c){
            return a;
        }
        else if(b>=a&&b>=c){
            return b;
        }
        else return c;
    }
    public int max2(int a,int b){
        if(a>b){
            return a;
        }
        else return b;
    }
    public int maxSubArray(int[] nums) {
        return max(nums,0,nums.length-1);
    }
}

5.游艇问题

i到j的最优=min(i直接到j,i到k,+k到j),这里为什么只要一个中转而不是多个呢,因为多个的情况已经包括在内了 比如最短是1-3 3-5 5-7 7-9 那其实就是1-3-9 1-5-9 1-7-9中间最优的情况
用一个三层循环逐渐找到 1-2, 1-3…的最优,2-3,3-4,4-5的最优
s是长度,从1-2,2-3 …开始
i是遍历每段s

import java.util.Scanner;

public class youting {
    public static int min(int a,int b){
        if(a>b) {return b;}
        else {return a;}
    }

    public static void youting(int n,int[][] money){
        for(int s=2;s<=n;s++){
            for (int i=1;i<=n-s+1;i++){
                int j=i+s-1;
                for(int k=i;k<=j-1;k++){
                    money[i][j]=min(money[i][j],money[i][k]+money[k][j]);
                }
            }
        }
        System.out.println(money[1][n]);
    }

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int[][] x=new int[5][5];
        for (int i=1;i<n;i++){
            for (int j=i+1;j<n;j++){
                x[i][j]=scanner.nextInt();
            }
        }
        youting(n-1,x);
    }