一维动态规划经典力扣题目（一）

目录

题一：斐波那契数列

题目二：最低票价

题三：解码方法

题一：斐波那契数列

递归方法是2的n次方的时间复杂度。

递归代码：

package DynaticPractice;

public class Problem1 {
    public static void main(String[] args) {
        System.out.println(fib(5));
    }
    public static int fib(int n){
        if(n==0) return 0;
        if(n==1) return 1;
        return fib(n-1)+fib(n-2);
    }
}

带有缓存的递归，会使时间复杂度得到大幅度优化。

时间复杂度为O(n)。

缓存即记录中间值

/**
 * 带有缓存的解法 * 时间复杂度为O(n) 
 */
 public static int fib2(int n){
    int[] dp=new int[n+1];
    Arrays.fill(dp,-1);
    return f2(n,dp);
}
public static int f2(int i,int[] dp){
    if(i==0){
        return 0;
    }
    if(i==1){
        return 1;
    }
    if(dp[i]!=-1){
        return dp[i];
    }
    int ans=f2(i-1,dp)+f2(i-2,dp);
    dp[i]=ans;
    return ans;
}

        优化的方法：

/**
 * 从底到顶计算的方法 
 */
public static int fib3(int n){
    if(n==0) return 0;
    if(n==1) return 1;
    int[] dp=new int[n+1];
    dp[1]=1;
    for(int i=2;i<=n;i++){
        dp[i]=dp[i-1]+dp[i-2];
    }
    return dp[n];
}
/**
 * 空间简化的从底向顶的计算 
 */
public static int fib4(int n){
    if(n==0) return 0;
    if(n==1) return 1;
    int LastLast=0;
    int Last=1;
    for(int i=2,cur;i<=n;i++){
        cur=Last+LastLast;
        LastLast=Last;
        Last=cur;
    }
    return Last;
}

题目二：最低票价

        代码：

package DynaticPractice;

import java.util.Arrays;

public class Problem2 {
    //步骤数组,方案数组    
    public static int[] durations={1,7,30};

    /**    
     * 方法一：暴力尝试     
     */    
     public static int mincostTickets1(int[] days,int[] costs){
        return f1(days,costs,0);
    }
    //从第i下标的天开始，最少花费多少    
    public static int f1(int[] days,int[] costs,int i){
        if(i==days.length){//后续没有了            
            return 0;
        }
        int ans=Integer.MAX_VALUE;
        for(int k=0,j=i;k<3;k++){//遍历方案            
        while (jdays[j]){
                j++;
            }
            ans=Math.min(ans,costs[k]+f1(days,costs,j));
        }
        return ans;
    }

    /**    
     * 带有缓存的递归     
     * 动态规划     
     */    
     public static int mincostTickets2(int[] days,int[] costs){
        int[] dp=new int[days.length];//dp数组中的元素值代表从该位置开始的最小费用        
        Arrays.fill(dp,Integer.MAX_VALUE);
        return f2(days,costs,0,dp);
    }
    public static int f2(int[] days,int[] costs,int i,int[] dp){
        if(i==days.length){//后续没有了            
            return 0;
        }
        if(dp[i]!=Integer.MAX_VALUE){
            return dp[i];
        }
        int ans=Integer.MAX_VALUE;
        for(int k=0,j=i;k<3;k++){//遍历方案            
            while (jdays[j]){
                j++;
            }
            ans=Math.min(ans,costs[k]+f2(days,costs,j,dp));
        }
        dp[i]=ans;
        return ans;
    }

    /**    
     * 非递归方式     
     * 从底到顶的动态规划     
     */    
    public static int MAXN=366;
    public static int[] dp=new int[MAXN];
    public static int mincostTickets3(int[] days,int[] costs){
        int n=days.length;
        Arrays.fill(dp,0,n+1,Integer.MAX_VALUE);
        dp[n]=0;
        for(int i=n-1;i>=0;i--){
            for(int k=0,j=i;k<3;k++){
                while (jdays[j]){
                    j++;
                }
                dp[i]=Math.min(dp[i],costs[k]+dp[j]);
            }
        }
        return dp[0];
    }
}

题三：解码方法

        代码：

package DynaticPractice;

import java.util.Arrays;

public class Problem3 {

    /**    
     * 方法一     
     * @param s     
     * @return     
     */    
    public static int numDecodings(String s){
        return f1(s.toCharArray(),0);
    }

    private static int f1(char[] s, int i) {
        if(i==s.length){
            return 1;
        }
        int ans;
        if(s[i]=='0'){
            ans=0;
        }else {
            ans=f1(s,i+1);//自己单独一个字符的情况            
            if(i+1=0;i--){
            if(charArray[i]=='0'){
                dp[i]=0;
            }else{
                dp[i]=dp[i+1];
                if(i+1