算法实验报告—DP

最新推荐文章于 2024-07-18 22:19:19 发布
最新推荐文章于 2024-07-18 22:19:19 发布
阅读量493 收藏 3
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45786945/article/details/117511820
版权

算法实验报告——DP

最长公共子序列（LCS）

题目

    一个给定序列的子序列是在该序列中删去若干元素后得到的序列。确切地说，若给定序列X=<x1, x2,…, xm>，则另一序列Z=<z1, z2,…, zk>是X的子序列是指存在一个严格递增的下标序列 <i1, i2,…, ik>，使得对于所有j=1,2,…,k有Xij=Zj。

思路

在这里插入图片描述

    给定串s和t，求最长公共子序列 数组dp[i][j]:si和tj的公共子序列长度
dp[i+1][j+1] = Math.max(dp[i][j+1],dp[i+1][j],dp[i][j]+1),
                         如果si+1和tj+1是同一个字符
            = Math.max(dp[i][j+1],dp[i+1][j])
                         如果不是同一个字符

代码

public class Longest_Common_Substring {
    String[][] ans;
    public String solve(String s,String t){
        ans = new String[s.length()+1][t.length()+1];
        for(int i=0;i<s.length()+1;i++) {
            for (int j = 0; j < t.length()+1; j++) {
                ans[i][j] = "";
            }
        }
//        System.out.println(Arrays.deepToString(ans));
        for(int i=0;i<s.length();i++){
            for(int j=0;j<t.length();j++){
                if(s.charAt(i) == t.charAt(j)){
                    ans[i+1][j+1] = ans[i][j]+s.charAt(i);
                }else{
                    if(ans[i+1][j].length() > ans[i][j+1].length()){
                        ans[i+1][j+1] = ans[i+1][j];
                    }else{
                        ans[i+1][j+1] = ans[i][j+1];
                    }
                }
            }
        }
        return ans[s.length()][t.length()].toString();
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入两个串");
        String s = reader.readLine();
        String t = reader.readLine();
        Longest_Common_Substring demo = new Longest_Common_Substring();
        System.out.println(s+"和"+t+"的最长组序列为"+demo.solve(s,t));
    }
}

运行结果

在这里插入图片描述
在这里插入图片描述

计算矩阵连乘

题目

    计算一系列矩阵相乘所需要的最少步骤数。

题目分析

    两个矩阵相乘的必要条件是第一个矩阵的列和第二个矩阵的行相同。假设第一个矩阵是pq，第二个矩阵是qr，那么所需要的计算步骤是pqr次。
    因此假设有n个矩阵，只需要n+1个空间就可以表征这些矩阵的性质。为了便于下标处理，矩阵从下标1开始。

变量说明

p数组

    记录矩阵的规模，每一个元素对应相应下标矩阵的一维长度，最后一个元素是最后一个剧真的二维长度。

dp【i】【j】

    从小标i到j的矩阵相乘的步骤数，因为是求最小值，所以给一个大的初值，矩阵自己不和自己相乘，所以对角线值为0。

核心思想分析

    还是有分治的思想。从两个矩阵开始连乘，计算出结果并保存起来，规模扩大到两个，调用之前/查询之前计算出来的结果，取多种可能的最小值，当规模扩大到n的时候，对应下标dp【1】【n】的值就是结果。自底向上体现在从规模小开始，记录结果留给规模大的查看。
每次规模扩大有两种情况：
    如果原来的规模不进行划分，直接并上新加入的元素，那么就等于原来规模的结果加上合并的开销。
    如果在新的规模上重新进行划分，那么就设立标志k，从k位置切开，两个更小的部分规模小于备忘录的最大规模，是可以查得到的，所以直接查，加上合并的规模。

代码

package Algorithms_算法.实验.动规;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;

/**
 * @author Xinchen Liu
 * @date 2021/5/31 9:25
 */
//a[ai][aj],b[bi][bj]相乘的递推式
public class Multiple_Matrix {
    ArrayList<int[][]> matrix_set = new ArrayList<>();
    int[][] dp;//dp【i】【j】：从i到j的计算量，同样舍弃 0的那一行那一列
    int[][] ans;
    int[] p;//矩阵的宽度，第0个元素舍弃，1-size是对应矩阵的一维宽度，最后一位是最后一个矩阵的二维宽度
    int j=0;
    public int solve(){
        p = new int[matrix_set.size()+2];
        for(int i=1;i<=matrix_set.size();i++){
            p[i] = matrix_set.get(i-1).length;
        }//存储第i个矩阵的行数
        p[p.length-1] = matrix_set.get(matrix_set.size()-1)[0].length;
        //存储最后一个矩阵的列数
        System.out.println(Arrays.toString(p));

        dp = new int[matrix_set.size()+1][matrix_set.size()+1];
        for(int[] tmp:dp){
            Arrays.fill(tmp,998);//求最小值，就赋值一个大的数
        }
        for(int i=1;i<dp.length;i++){
            dp[i][i] = 0;//自乘不需要考虑，下表0的舍弃
        }

        for(int distance = 1;distance < matrix_set.size();distance++){//连乘范围
            for(int i=1;i + distance <= matrix_set.size();i++){
                j= i + distance;//连乘区间的右端点
                dp[i][j] = Math.min(dp[i][j-1] + p[i]*p[j]*p[j+1],
                        dp[i+1][j] + p[i+1]*p[i+2]*p[j]);//这边其实没搞懂
                //先计算不划分的情况，i到j的区间等于i到j-1的乘上第j个矩阵或者i+1到j的乘上第i个矩阵

                //开始划分，i-k一组，k+1-j一组，所以k可以等于i
                for(int k=i;k<j;k++){
                    System.out.println(i+","+j+","+k+".");
                    int a = dp[i][j];
                    int b = dp[i][k] + dp[k+1][j] + p[i]*p[k+1]*p[j+1];
                    System.out.println("当前最小:"+a+"；本次划分的大小:"+b);
                    dp[i][j] = Math.min(a,b);
                    //i的行数，k和j的列数
                }
            }
        }
        for(int[] t:dp){
            System.out.println(Arrays.toString(t));
        }
        return dp[1][matrix_set.size()];//从1到n的连乘次数
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        Multiple_Matrix demo = new Multiple_Matrix();
        int[][] tmp = new int[100][];
        int flag = 0;
        String s;
        while(true){
            System.out.println("请输入矩阵");
            s = reader.readLine();
            if(s.equals("-1")){
                break;
            }
            while(true){
                s = reader.readLine();
                if(s.equals("")){
                    break;
                }
                String[] t = s.split(" ");
                tmp[flag] = new int[t.length];
                for(int i=0;i<t.length;i++){
                    tmp[flag][i] = Integer.parseInt(t[i]);
                }
                flag++;
            }
            int[][] toadd = new int[flag][];
            for(int i=0;i< toadd.length;i++){
                toadd[i] = tmp[i];
            }
            demo.matrix_set.add(toadd);
            tmp = new int[100][];
            flag = 0;
        }
//        demo.matrix_set.add(new int[][]{{1,2},{3,4},{5,6}});//3*2
//        demo.matrix_set.add(new int[][]{{1,2,3,4},{2,3,4,5}});//2*4
//        demo.matrix_set.add(new int[][]{{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5}});//4*5
//        demo.matrix_set.add(new int[][]{{1,2},{3,4},{5,6},{3,4},{5,6}});//5*2
        System.out.println(demo.solve());
    }
}


 for(int i=0;i<dp.length;i++){
            dp[i][i] = 0;//自己到自己的距离为0
        }

    不考虑矩阵自乘，也就是区间长度为0表示没有矩阵 要相乘。

for(int distance = 1;distance < points.size();distance++)

    从两个矩阵相乘，跨度为1开始。

j= i + distance;//连乘区间的右端点
dp[i][j] = Math.min(dp[i][j-1] + p[i]*p[j]*p[j+1],
           dp[i+1][j] + p[i+1]*p[i+2]*p[j])

    先计算不重新划分的情况，也就是采纳前一个规模的划分，加上和现在矩阵相乘的开销。i到j的区间等于i到j-1的乘上第j个矩阵或者i+1到j的乘上第i个矩阵的最小值。

//开始划分，i-k一组，k+1-j一组，所以k可以等于i
for(int k=i;k<j;k++){
    System.out.println(i+","+j+","+k+".");
    int a = dp[i][j];
    int b = dp[i][k] + dp[k+1][j] + p[i]*p[k+1]*p[j+1];
    System.out.println("当前最小:"+a+"；本次划分的大小:"+b);
    dp[i][j] = Math.min(a,b);
//i的行数，k和j的列数

    从i到j，也就是划分当前规模，划分之后的规模一定小于当前规模，这些规模的结果都已经算出来了，只需要直接从备忘录取出，加上合并的开销，就得到这种划分的解，选取最小的。

return dp[1][matrix_set.size()];

    当区间宽度覆盖所有矩阵时结束。

运行结果

在这里插入图片描述
在这里插入图片描述
y9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzg2OTQ1,size_16,color_FFFFFF,t_70)

凸多边形的最优三角划分

题目

    (1)凸多边形的三角剖分：将凸多边形分割成互不相交的三角形的弦的集合T。

    (2)最优剖分：给定凸多边形P，以及定义在由多边形的边和弦组成的三角形上的权函数w。要求确定该凸多边形的三角剖分，使得该三角剖分中诸三角形上权之和为最小。

最优子结构证明

证：T确定的这两个子多边形的三角剖分也是最优的。
    因为若有{V0,V1……Vk}和{V0,V1……Vk}更小权的三角剖分，而当前的最小权划分是从前一个最小权划分得到的，如果存在，就和前一个规模的最小权划分矛盾，将导致T不是最优三角剖分。因此，凸多边形的三角剖分问题具有最优子结构性质。

递推关系

     设t [ i ][ j ] ,1 <= i < j<= n为凸多边形{V i - 1 ,V i……V j}的最优三角剖分所对应的权值函数值 / 最优值。
     那么新的最优剖分的权值包含：三角形V i - 1V kV j的权 + 子多边形{V i - 1,V i……V k}的权 + 子多边形{V k，V k + 1……V j}的权

在这里插入图片描述

    凸多边形最优三角剖分满足动态规划的最优子结构性质，可以从自底向上逐渐推出整体的最优。


（1）确定合适的数据结构
     采用二维数组weight[ ][ ]记录各个顶点之间的连接权值，二维数组t[ ][ ]存放各个子问题的最优值，二维数组s[ ][ ]存放各个子问题的最优策略。


（2）初始化

     输入顶点数n，然后依次输入各个顶点之间的连接权值存储在二维数组weight[ ][ ]中，令n=n-1（顶点标号从v0开始），t [ i ][ i ]=0，s[ i ][ i ]=0，其中i=1,2,3,4……,n-1。


（3）循环(自底向上 + 备忘录)（从三个顶点开始算）

    按照递归关系式计算3个顶点{vi - 1，vi，vi + 1}的最优三角剖分，j=i+1，将最优值存入t [ i ][ i ]，同时将最优策略存入s[ i ][ i ]，i=1，2，3，……，n-1。


     按照递归关系式计算4个顶点{v i-1，vi，vi+1，vi+2}的最优三角剖分，j=i+2，将最优值存入t [ i ][ i ]，同时将最优策略存入s[ i ][ i ]，i=1，2，3，……，n-2。


     以此类推，直到求出所有顶点{v0,v1,v2,……,vn}的最优三角剖分，并将最优值存入t [ 1 ][ n ]，将最优策略记入s[ 1 ][ n ]


（4）构造最优解
    根据最优决策信息数组s[ ][ ]递归构造最优解，即输出凸多边形的最优剖分的所有弦。s[ 1 ][ n ] 表示凸多边形最优三角剖分位置,即最优化分的顶点坐标。


    对于给定的一组顶点组成的凸多边形，选择最优化分位置s[ 1 ][ n ]，把多边形分成两个子多边形{ v0,v1,v2,……,Vs[1][n] } 和 { Vs[1][n] ,v1,v2,……,vn}。


    如果子问题1为空，即没有一个顶点，说明V0Vs[1][n]是一条边，不是弦，不需要输出，否则，输出该弦：V0<----->V（s[1][n]）


    如果子问题2为空，即没有一个顶点，说明Vs[1][n]Vn是一条边，不是弦，不需要输出，否则，输出该弦V（s[1][n]）<----->Vn


    递归构造两个子问题{ v0,v1,v2,……,Vs[1][n] } 和 { Vs[1][n] ,v1,v2,……,vn
}，一直递归到子问题为空停止。

在这里插入图片描述

代码

public class Triangulation {
    double[][] dp;
    ArrayList<int[]> points = new ArrayList<>();
    public double solve(){
        dp = new double[points.size()+1][points.size()+1];
        for(int i=0;i<dp.length;i++){
            dp[i][i] = 0;//自己到自己的距离为0
        }
        for(int i=0;i<points.size();i++){
            dp[i][i+1] = distance(points.get(i), points.get(i + 1));
        }
        int j = 0;
        for(int distance = 2;distance < points.size();distance++){
            for(int i=1;i + distance <= points.size();i++){
                j= i + distance;
                dp[i][j] = Math.min(dp[i][j-1] + distance(points.get(j), points.get(j+1))
                                +distance(points.get(i), points.get(j))+
                                distance(points.get(i), points.get(j-1)),
                        dp[i+1][j] + distance(points.get(i), points.get(i+1))
                                +distance(points.get(i), points.get(j))+
                                distance(points.get(i+1), points.get(j)));
                //开始划分，i-k一组，k+1-j一组，所以k可以等于i
                for(int k=i;k<j;k++){
                    System.out.println(i+","+j+","+k+".");
                    double a = dp[i][j];
                    double b = dp[i][k] + dp[k+1][j] + distance(points.get(k), points.get(k+1))
                            +distance(points.get(i), points.get(k+1))+
                            distance(points.get(j), points.get(k+1));
                    System.out.println("当前最小:"+a+"；本次划分的大小:"+b);
                    dp[i][j] = Math.min(a,b);
                }
            }
        }
        return dp[1][points.size()];
    }
    public double distance(int[] a,int[] b){
        return Math.pow(Math.pow(a[1]-b[1],2)+Math.pow(a[0]-b[0],2),0.5);
    }


 for(int i=0;i<dp.length;i++){
            dp[i][i] = 0;//自己到自己的距离为0
        }

    初始化，到自身没有边，也就是权值为0

for(int distance = 2;distance < points.size();distance++)

    三角形至少要三个点，因此跨度从2开始。

j= i + distance;//连乘区间的右端点
dp[i][j] = Math.min(dp[i][j-1] + distance(points.get(j), points.get(j+1))
        +distance(points.get(i), points.get(j))+
        distance(points.get(i), points.get(j-1)),
dp[i+1][j] + distance(points.get(i), points.get(i+1))
        +distance(points.get(i), points.get(j))+
        distance(points.get(i+1), points.get(j)));

    先计算不划分的情况，即采用之前一个规模的划分结果，加上和当前点连接的开销

//开始划分，i-k一组，k+1-j一组，所以k可以等于i
for(int k=i;k<j;k++){
	System.out.println(i+","+j+","+k+".");
    double a = dp[i][j];
    double b = dp[i][k] + dp[k+1][j] + distance(points.get(k), points.get(k+1))
             +distance(points.get(i), points.get(k+1))+
             distance(points.get(j), points.get(k+1));
    System.out.println("当前最小:"+a+"；本次划分的大小:"+b);
    dp[i][j] = Math.min(a,b);

    从i到j，也就是多边形的顶点之间遍历选取一个划分点，划分之后的规模一定小于当前规模，这些规模的结果都已经算出来了，只需要直接从备忘录取出，加上合并的开销，就得到这种划分的解，选取最小的。

return dp[1][points.size()];

    当区间宽度覆盖所有顶点时结束。

防卫导弹

题目

    一种新型的防卫导弹可截击多个攻击导弹。它可以向前飞行，也可以用很快的速度向下飞行，可以毫无损伤地截击进攻导弹，但不可以向后或向上飞行。但有一个缺点，尽管它发射时可以达到任意高度，但它只能截击比它上次截击导弹时所处高度低或者高度相同的导弹。现对这种新型防卫导弹进行测试，在每一次测试中，发射一系列的测试导弹（这些导弹发射的间隔时间固定，飞行速度相同），该防卫导弹所能获得的信息包括各进攻导弹的高度，以及它们发射次序。现要求编一程序，求在每次测试中，该防卫导弹最多能截击的进攻导弹数量，一个导弹能被截击应满足下列两个条件之一：
    a)它是该次测试中第一个被防卫导弹截击的导弹；
    b)它是在上一次被截击导弹的发射后发射，且高度不大于上一次被截击导弹的高度的导弹。

思路

    求出在我后面发射的，高度比我小的导弹数目，的最大值。

代码

public class Cruise_Missile {
    int[][] message;//时间，高度
    int[] dp;
    public Cruise_Missile(int[][] message){
        this.message = message;
        dp = new int[message.length];
    }
    public int solve(){
        Arrays.sort(message, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] < o2[0] ? -1:1;
            }
        });
        for(int i= message.length-1;i>=0;i--){
            for(int j=i;j< message.length;j++){
                if(message[j][1] < message[i][1]){
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
        }
        return dp[0];
    }
}

石子合并

题目

    在一个圆形操场的四周摆放着n堆石子(n<= 100)，现要将石子有次序地合并成一堆。规定每次只能选取相邻的两堆合并成新的一堆,并将新的一堆的石子数,记为该次合并的得分。编一程序，由文件读入堆栈数n及每堆栈的石子数(<=20)。
    选择一种合并石子的方案,使得做n－1次合并,得分的总和最小；

思路

    和前几题非常相似，自底向上，任选相邻的两堆合并，记录合并开销，然后逐渐扩大规模，每次扩大在采纳前一规模划分和不采纳前一规模，重新划分中选取最小的，同时计算合并开销。

代码

public class _石子合并 {
    int[] costs;
    int[][] dp;
    int j;
    public _石子合并(int[] costs){
        this.costs = costs;
        this.dp = new int[costs.length][costs.length];
        for(int[] tmp:dp){
            Arrays.fill(tmp,998);//求最小值，就赋值一个大的数
        }
        for(int i=0;i<dp.length;i++){
            dp[i][i] = 0;//自乘不需要考虑，下表0的舍弃
        }
    }
    public int solve(){
        for(int div=1;div < costs.length;div++){
            for(int i=0;i + div < costs.length;i++){
                j = i+div;
                dp[i][j] = Math.min(dp[i][j-1] ,dp[i+1][j] );

                for(int k=i;k<j;k++){
                    System.out.println(i+","+j+","+k+".");
                    dp[i][j] = Math.min(dp[i][j],dp[i][k]+dp[k+1][j]);
                    System.out.println("当前最小:"+dp[i][j]+"；本次划分的大小:"+(dp[i][k]+dp[k+1][j]));
                }
                dp[i][j]+=sum(i,j);
            }
        }
        for(int[] t:dp){
            System.out.println(Arrays.toString(t));
        }
        return dp[0][costs.length-1];
    }
    public int sum(int a,int b){
        int sum = 0;
        for(int i=a;i<=b;i++){
            sum+=costs[i];
        }
        return sum;
    }
    public static void main(String[] args) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入你的石子");
        String stones = reader.readLine();
        String[] stone = stones.split(" ");
        int[] data = new int[stone.length];
        for(int i=0;i<stone.length;i++){
            data[i] = Integer.parseInt(stone[i]);
        }
        _石子合并 demo = new _石子合并(data);
        int ans = demo.solve();
        System.out.println(ans);
    }
}

运行结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

01背包问题

思路

    有多种思路，也就是不同意义的dp数组。
    （1）最基础的，递归，不用dp。

public int recursion(int i,int j){
        int res;
            if(w[i] > W){
                res = recursion(i+1,j);//选不了该物品
            }else if(i == n){
                res = 0;//物品遍历完了
            }else{
                res = Math.max(recursion(i+1,j),recursion(i+1,j-w[i])+v[i]);
                //    不选第i个                选第i个
            }
            return res;
    }

    和斐波那契一样有很多重复计算，每次状态转移都是从第i个向第i+1个转变，
    （2）如果能存下第i+1次计算的结果，就不用了在后面的状态再计算前一个状态的值了。

public int recursion(int i,int j){
        if(dp[i][j] > 0){
            return dp[i][j];
        }//如果是之前算过的状态，就直接用。
        int res;
        if(w[i] > W){
            res = recursion(i+1,j);//选不了该物品
        }else if(i == n){
            res = 0;//物品遍历完了
        }else{
            res = Math.max(recursion(i+1,j),recursion(i+1,j-w[i])+v[i]);
            //    不选第i个                选第i个
        }
        return dp[i][j] = res;//保存数值
    }

		dp = new int[n+1][W+1];
        Arrays.fill(dp,-1);
        int ans1 = recursion(0,W);
        System.out.println(ans1);

    （3）减少递归对系统栈的消耗，把dp的定义和使用带入循环

    dp[n][j] = 0;
    dp[i][j] = dp[i+1][j],无法选择第i个物品
            max(dp[i+1][j],dp[i+1][j-w[i]] + v[i])
在这里插入图片描述

for(int i = n-1;i>=0;i--){
            for(int j=0;j<=W;j++){
                if(j<w[i]){
                    dp[i][j] = dp[i+1][j];
                }else{
                    dp[i][j] = Math.max(dp[i+1][j],dp[i+1][j-w[i]] + w[i]);
                }
            }
        }
        return dp[0][W];

     （4）再进一步，能不能用一位数组暂存结果，节约空间，因为每一次计算都只与前一个状态有关，不同于多边形的三角划分，子问题规模可变，背包问题子问题划分规模是固定的，不会涉及到一次以前的状态。

public int solve_01(){
        for(int i = 0;i<n;i++){
        for(int j = W;j>=0;j--){
        	dp[j] = Math.max(dp[j],dp[j - w[i]]+v[i]);
        }
    }
        return dp[W];
}
public int solve_full(){
        for(int i = 0;i < n;i++){
        for(int j = w[i];j<=W;j++){
        dp[j] = Math.max(dp[j],dp[j - w[i]]+v[i]);
        }
    }
        return dp[W];
}

其他的dp数组

在这里插入图片描述

1.dp[ i+1 ][ j ]表示0到i这i+1个物品中重量不超过j的最大价值

public int solve1(){
        for(int i=0;i<n;i++){
            for(int j=0;j<=W;j++){
                if(j<w[i]){
                    dp[i+1][j] = dp[i][j];
                }else{
                    dp[i+1][j] = Math.max(dp[i][j],dp[i][j-w[i]] + v[i]);
                }
            }
        }
        return dp[n][W];
    }
    //对于j从0取到w的原因
    //因为你不知道上一次选了之后，还剩下多少重量可选，所以要把每种可能的重量都遍历一遍

2.dp[ i ][ j ]表示从0到i-1这i个物品重量不超过j的最大价值

public int solve2(){
        for(int i=0;i<n;i++){
            for(int j=0;j<=W;j++){
                dp[i+1][j] = Math.max(dp[i+1][j],dp[i][j]);
                if(j + w[i] < W){
                    dp[i+1][j+w[i]] = Math.max(dp[i+1][j+w[i]],dp[i][j] + v[i]);
                }
            }
        }
        return dp[n][W];
    }

在这里插入图片描述

3.dp[ i+1 ][ j ]表示从前i个物品中选择：价值为j的最小的w

这种解法适合于重量的大小远小于价值的大小时，如果用原来的方法会超时

int[][] dp = new int[n+1][(n+1)*(m+1)];
public int solve(){
        Arrays.fill(dp,99999999);
        for(int i=0;i<n;i++){
            for(int j=0;j<(n+1) * (m+1);j++){
                if(j < v[i]){
                    dp[i+1][j] = dp[i][j];
                }else{
                    dp[i+1][j] = Math.min(dp[i][j],dp[i][j - v[i]] + w[i]);
                }
            }
        }
        int ans = 0;
        for(int i=0;i<=(n+1)*(m+1);i++){
            if(dp[n][i] <= W){
                ans = i;
            }
        }
        return ans;
    }
星辰的野望
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法分析与设计实验报告
m0_62222486的博客
05-26 69
3.更新邻居：对于每条边进行松弛操作，时间复杂度为(O(ElogV))，因为每条边都会导致一次优先队列的插入或更新操作，而插入或更新操作的时间复杂度为(O(logV))。dp[i][w] = 最大值(dp[i-1][w], dp[i-1][w-物品[i-1].重量] + 物品[i-1].价值)2.主循环：从优先队列中取出具有最小距离的顶点，总共有(V)个顶点，每次操作的时间复杂度为(O(logV))。空间复杂度为(O(V))。alt ← dist[u] + edge(u, v) (计算从源点到v的距离)
算法设计与分析实验报告：实验三 动态规划
小柴
04-22 745
由于各作业的特点和机器的性能关系，很可能对于某些i，有ai>=bi，而对于某些j,j≠i，有aj<bj。设计一个动态规划算法，使得这2台机器处理完这n个作业的时间最短(从任何一台机器开工到最后一台机器停工的总时间)。研究一个实例： (a1,a2,a3,a4,a5,a6)＝(2,5,7,10,5,2)；算法设计：对于给定的2 台处理机A 和B处理n 个作业，找出一个最优调度方案，使2台机器处理完这n 个作业的时间最短。
最长公共子序列
m0_74742430的博客
05-09 727
掌握使用动态规划法解决最长公共子序列问题
华北电力大学算法实验报告
最新发布
m0_73428882的博客
07-18 948
华电算法实验报告
算法设计与分析实验报告（完整代码）
Z_JY2333的博客
11-28 3368
最后，输出需要加油的加油站的索引。通过本次实验，熟练掌握回溯法的基本设计思想与原则，回溯法是借鉴树的深度优先遍历实现的算法，相较于普通的遍历，大大的节省了时间。我在项目中进行了实践以及检验，代码部分：根据先入后出的特性采用栈作为背包，选取数组作为相应的参数输入，回溯法部分采用栈的出栈入栈，取出栈顶元素进行实现，在细节部分也进行了相关优化，经过本次实验，对于回溯法的和核心思想以及原理已经熟练掌握。最后，通过遍历数组中的元素，统计每个元素出现的次数，并根据出现次数比较左右两部分的众数，返回出现次数较多的那个。
《算法设计与分析》实验报告（3）
Q180905的博客
10-04 955
动态规划算法实验
《智能优化算法》实验报告：基于Matlab或Python的粒子群算法实现
Koonan-Edogawa的博客
02-25 1695
《智能优化算法》实验报告：基于Matlab或Python的粒子群算法实现
算法——实验 3《动态规划算法实验》
insouciant_22的博客
01-23 1978
1. 编写一个简单的程序， 解决 0-1 背包问题。设 N=5， C=10， w={2， 2 ， 6 ， 5 ，4}, v={6, 3, 5, 4, 6} 2. 合唱队形安排问题 【问题描述】N 位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的 K位同学排成合唱队形。合唱队形是指这样的一种队形：设 K 位同学从左到右依次编号为 1， 2… ， K ， 他 们 的 身 高 分 别 为 T1 ， T2 ， … ， TK ，则 他 们 的 身 高 满 足T1
理工大算法实验报告
秀
07-10 4723
实验一  递归与分治算法1.1  实验目的与要求1．进一步熟悉C/C++语言的集成开发环境；2．通过本实验加深对递归与分治策略的理解和运用。1.2  实验课时2学时1.3  实验原理分治（Divide-and-Conquer）的思想：一个规模为n的复杂问题的求解，可以划分成若干个规模小于n的子问题，再将子问题的解合并成原问题的解。需要注意的是，分治法使用递归的思想。划分后的每一个子问题与原问题的性...
算法程序设计实验报告
weixin_42418315的博客
07-17 1735
题目1：设A是n个非0实数构成的数组，设计一个算法重新排列数组中的数，使得负数都排在正数前面，要求用多种算法实现，并保证至少算法中有一种算法使用O(n)的时间和O(1)的空间。 题目2：给定n个不同数的数组S和正整数i，i≤n1/2，求S中最大的i个数，并且按照从大到小的次序输出。用至少3种算法来实现，并分析其时间复杂度。 题目3：求两个序列的最长公共子序列。 题目4：最大子段和问题，用至少三种方法求解，并比较它们的复杂度。
华工算法实验报告+代码
06-16
【华工算法实验报告+代码】是一份涵盖了华中科技大学（简称“华工”）算法实验的详细报告，包括了实验一至实验四的全程记录和相关代码实现。这个资源对于学习C++编程语言和算法设计的学生来说是极具价值的。在本篇...
计算机算法实验报告.pdf
03-16
在本实验报告中，主要探讨了三种解决“0/1 背包问题”的算法：贪心算法、动态规划和回溯算法。 1. **贪心算法**： 贪心算法是一种局部最优策略，它每次选择当前状态下最优的解决方案，以期望最终达到全局最优。在0...
西南交大算法分析实验实验报告5.1.docx
10-23
【实验报告】 实验5.1 动态规划算法设计与实验 实验目的： 1. 理解动态规划算法的基本思想和求解流程，通过实际操作深入体会动态规划的解决问题方式。 2. 分析动态规划算法的时间复杂度，对比其与其他算法的效率...
太原理工大学2018级算法实验报告.zip
05-05
太原理工大学2018级的算法实验报告是一个深入学习和实践算法的重要资源，这份文档详细记录了学生们在学习过程中所接触的各种算法及其应用。通过这份报告，我们可以了解到一系列的算法知识，包括但不限于排序、搜索、...
LSM-tree基本原理及应用
ZERO的博客
05-16 2645
LSM-tree基本原理及应用 LSM-tree是什么 log-structed merge-tree 日志结构的：系统日志是不会出错的，只需要在后面追加。所以日志结构就代指追加型结构。 原理：把磁盘看做一个日志，在日志中存放永久性数据及其索引，每次都添加到日志的末尾。文件传输（存取）大多是顺序的，提高磁盘带宽利用率。 LSM-tree是专门为key-value存储系统设计的，主要业务是查找和插入。 LSM的特点是利用磁盘的顺序写，写入速度比随机写入的B-树更快。 LSM-tree来自哪里 Bigta
统计子序列个数
ZERO的博客
03-22 1721
LeeCode复习-115-统计子序列个数 一、题目 给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。 字符串的一个子序列是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。 例如，"ACE"是"ABCDE"的一个子序列，而"AEC"不是） 题目数据保证答案符合 32 位带符号整数范围。 二、解题 1.思路 我一开始的想法是，设dp[i][j] 是以 i为母串，j为子串的符合条件的串的个数。 题解：dp[i][j] 是母串s从i到末尾的子串，
算法实验报告2——贪心
ZERO的博客
05-20 1634
算法实验报告2——贪心目录一、背包问题题目思路细节代码运行结果二、照亮的山景题目思路细节代码运行结果三、搬桌子问题题目思路细节代码运行结果四、八皇后问题题目思路细节代码运行结果 目录 一、背包问题 题目 有一个背包，背包容量是M=150。有7个物品，物品可以分割成任意大小。 要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。 物品 A B C D E F G 重量 35 30 60 50 40 10 25 价值 10 40 30 50 35 40 30 思路 把所有物品的平均价值求出..
"磁盘调度算法实验报告及模拟系统设计
本次实验的目的是设计一个磁盘调度模拟系统，并实现磁盘调度算法，使其更加形象化，易于理解。同时，通过实验，加深对先来先服务算法、最短寻道时间优先算法、扫描算法和循环扫描算法的理解。 实验内容包括系统主...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

星辰的野望

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值