【算法】-动态规划02

线性DP

 

 

 算法代码

import java.lang.*;
import java.util.*;
public class Main{
    public static int max_len=1;
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int N=sc.nextInt();
        int[] arr=new int[N+1];
        for(int cur=1;cur<=N;cur++){
            arr[cur]=sc.nextInt();
        }
        int[] dp=new int[N+1];
        int res=1;
        for(int i=1;i<=N;i++){
            dp[i]=1;
            for(int j=1;j<i;j++){
                if(arr[j]<arr[i])
                    dp[i]=Math.max(dp[i],dp[j]+1);
            }
            res=Math.max(res,dp[i]);
        }
        System.out.println(res);
    }
   
}

 

 

 

 

 

import java.lang.*;
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int len1=sc.nextInt();
        int len2=sc.nextInt();
        char[] str1=sc.next().toCharArray();
        char[] str2=sc.next().toCharArray();
        int[][] dp=new int[len1+1][len2+1];
        for(int i=1;i<=len1;i++){
            for(int j=1;j<=len2;j++){
                    dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
                    if(str1[i-1]==str2[j-1])
                        dp[i][j]=Math.max(dp[i][j],dp[i-1][j-1]+1);
            }
        }
        System.out.println(dp[len1][len2]);
    }
}

 区间DP

 

 

 

状态计算公式为f[i.j]=Min(f[i,k]+f[k+1,j]+s[j]-s[i-1]) k从1到j-1

 

 算法代码

import java.lang.*;
import java.util.*;
class Main{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int N=scanner.nextInt();
        final int num=301;
        int[] s=new int[num];
        int[][] dp=new int[num][num];
        for(int i=1;i<=N;i++){
            s[i]=scanner.nextInt();
            s[i]+=s[i-1];
        }
       for(int len=1;len<=N;len++){
           for(int i=1;i+len-1<=N;i++){
               int j=i+len-1;
               if(len==1)dp[i][j]=0;
               else{
                   dp[i][j]=Integer.MAX_VALUE;
                for(int k=i;k<j;k++){
                   dp[i][j]=Math.min(dp[i][j],dp[i][k]+dp[k+1][j]+s[j]-s[i-1]);
                    }
               }
           }
       }
        System.out.println(dp[1][N]);
    }
}