动态规划经典题

有问题直接评论，随时看博。

做动态规划的题思路

　　1、一般都是选和不选（选就是选当前值，不选就是不选当前值）

　　2、然后写出递归公式，然后利用递归公式写出动态规划的代码

 

经典题一：

红色字体代表佣金，x是时间段，1-8分别代表8个任务，每个人物都有不同的时间段，做不同任务时间段不能冲突，现在目的就是怎么选择任务才能够佣金最多

 

public class 动态规划1 {
    static int[] v= {0,5,1,8,4,6,3,2,4};
    static int[] prev= {0,0,0,0,1,0,2,3,5};
    /**
     * 递归解法
     * @param k
     * @return
     */
    public static int rec_opt(int k) {
        int max=0;
        if(k==0) {
            return 0;
        }
        if(k>=1) {
            int A = rec_opt(k-1);//不选
            int B = v[k]+rec_opt(prev[k]);//选
            max = max(A,B);
        }
        
        return max;
    }
    /**
     * 动态规划解法
     * @param k
     * @return
     */
    public static int dp_opt() {
        int[] subset = new int[v.length];
        subset[0]=0;
        
        for(int i=1;i<subset.length;i++) {
            int A = subset[i-1];//不选
            int B = v[i]+subset[prev[i]];//选
            subset[i] = max(A,B);
        }
        
        return subset[v.length-1];
    }
    
    public static int max(int a,int b) {
        if(a>b) {
            return a;
        }
        return b;
    }
    
    
    public static void main(String[] args) {
        int rec_opt = rec_opt(8);
        int dp_opt = dp_opt();
        System.out.println(rec_opt);
        System.out.println(dp_opt);
        
    }
}

View Code

经典题二：

　　从 1 2 4 1 7 8 3中找到不相邻相加之后最大的,不管有几个数字

 

　　

public class 动态规划2 {
    static int[] arr = {1,2,4,1,7,8,3};
    //递归解法
    public static int rec_opt(int k) {
        //出口
        if(k==0) return arr[k];
        if(k==1) return max(arr[k-1],arr[k]);
        int A = rec_opt(k-2)+arr[k];//选
        int B = rec_opt(k-1);//不选
        return max(A,B);
        
    }
    public static int max(int a,int b) {
        if(a>b) {
            return a;
        }
        return b;
    }
    //动态规划解法
    public static int dp_opt() {
        int[] res = new int[arr.length];//存放结果的数组
        res[0]=arr[0];
        res[1]=max(arr[1],arr[0]);
        for(int i=2;i<res.length;i++) {//处理大于1的其他结果
            int A = res[i-2]+arr[i];//选
            int B = res[i-1];//不选
            res[i]=max(A,B);
        }
        return res[res.length-1];
        
    }
    public static void main(String[] args) {
        System.out.println(rec_opt(arr.length-1));
        System.out.println(dp_opt());
    }
}

View Code

经典题三：

 

　　这道题我可能说的有点不清楚，可以评论，我不定时看博客。

　　arr={3,34,4,12,5,2}

　　给定一组数据，然后再给一个值s，然后从数组随便选然后相加，使得的值刚好够给定的值，比如说：s=9,那么数组中3+4+2=9，返回true。

public class 动态规划3 {
    public static int[] arr = {3,34,4,12,5,2};
    /**
     * 递归解法
     * @param arr
     * @param k
     * @param s
     * @return
     */
    public static boolean rec_subset(int[] arr,int k,int s) {
        if(s==0) return true;
        if(k==0) return arr[0]==s;
        if(arr[k]>s) return rec_subset(arr,k-1,s);
        boolean A = rec_subset(arr,k-1,s-arr[k]);//选
        boolean B = rec_subset(arr,k-1,s);//不选
        return A || B;
    }
    public static boolean dp_subset(int[] arr,int S) {
        boolean[][] subset = new boolean[arr.length][S+1];//创建一个二维数组，存放所有的结果
        
        for(int i=0;i<subset.length;i++) {//第一列都是T
            subset[i][0]=true;
        }
        for(int i=0;i<subset[0].length;i++) {//第一行都是f
            subset[0][i]=false;
        }
        subset[0][arr[0]]=true;//第一行的arr[0]是true
        
        for(int i=1;i<subset.length;i++) {//从第一行开始循环
            for(int s=1;s<subset[0].length;s++) {//从第一列开始循环
                if(arr[i]>s) {//数组值>凑数值
                    subset[i][s]=subset[i-1][s];//只考虑右边的
                }else {
                    boolean A =subset[i-1][s-arr[i]];//选
                    boolean B =subset[i-1][s];//不选
                    subset[i][s]=A || B;
                }
            }
        }
        return subset[arr.length-1][S];
    }
    public static void main(String[] args) {
        System.out.println(rec_subset(arr,arr.length-1,9));
        System.out.println(rec_subset(arr,arr.length-1,10));
        System.out.println(rec_subset(arr,arr.length-1,11));
        System.out.println(rec_subset(arr,arr.length-1,12));
        System.out.println(rec_subset(arr,arr.length-1,13));
        System.out.println("------------------------------");
        System.out.println(dp_subset(arr,9));
        System.out.println(dp_subset(arr,10));
        System.out.println(dp_subset(arr,11));
        System.out.println(dp_subset(arr,12));
        System.out.println(dp_subset(arr,13));
    }
}

View Code

 

转载于:https://www.cnblogs.com/zhazhaboke/p/10561154.html