《算法分析与设计》练习10

最新推荐文章于 2022-07-19 19:45:12 发布
最新推荐文章于 2022-07-19 19:45:12 发布
阅读量231 收藏 1
点赞数
分类专栏： 题目 文章标签： 算法 java 贪心算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52949203/article/details/124777532
版权

问题 A: 最长递增子序列

注意数组大小，可能有测试数据范围导致的运行错误

import java.util.Scanner;

public class Main {

    static int[] a=new int[1010];//存原数据
    static int[] b=new int[1010];//b[i]为以a[i]为单调递增子序列最后一个元素时所得的最长单调子序列的和
    static int[] pre=new int[1010];//存前一个的位置
    static int[] str=new int[1010];
    static int n;
    static int maxLen;

    static void solve(){
        b[1]=1;
        for(int i=2;i<=n;i++){
            maxLen=0;
            for(int j=i-1;j>=1;j--){
                if(a[j]<a[i]&&b[j]>maxLen){
                    maxLen=b[j];
                    pre[i]=j;
                }
            }
            b[i]=maxLen+1;
        }

        maxLen=b[1];
        for(int i=2;i<=n;i++){
            maxLen= Math.max(b[i], maxLen);
        }
    }

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            n=sc.nextInt();
            for(int i=1;i<=n;i++){
                a[i]=sc.nextInt();
            }
            solve();
            System.out.println(maxLen);
        }
    }
}

问题 B: 构造最长递增子序列

这个没啥好说的，沿着上一题的思路来就是

import java.util.Scanner;
 
public class Main {
 
    static int[] a=new int[1010];//存原数据
    static int[] b=new int[1010];//b[i]为以a[i]为单调递增子序列最后一个元素时所得的最长单调子序列的和
    static int[] pre=new int[1010];//存前一个的位置
    static int[] str=new int[1010];
    static int n;
    static int maxLen;
    static int mark;
 
    static void solve(){
        b[1]=1;
        for(int i=2;i<=n;i++){
            maxLen=0;
            for(int j=i-1;j>=1;j--){
                if(a[j]<a[i]&&b[j]>maxLen){
                    maxLen=b[j];
                    pre[i]=j;
                }
            }
            b[i]=maxLen+1;
        }
 
        maxLen=b[1];
        mark=1;
        for(int i=2;i<=n;i++){
            if(b[i]>maxLen){
                maxLen=b[i];
                mark=i;
            }
        }
 
        int j=mark;
        int i=maxLen;
        while(pre[j]>0){
            str[i--]=a[j];
            j=pre[j];
        }
        str[i]=a[j];
    }
 
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            boolean flag=false;
            n=sc.nextInt();
            for(int i=1;i<=n;i++){
                a[i]=sc.nextInt();
            }
            solve();
            for(int i=1;i<=maxLen;i++){
                if(!flag){
                    System.out.print(str[i]);
                    flag=true;
                }else{
                    System.out.print(" "+str[i]);
                }
 
            }
            System.out.println();
 
//            System.out.println(maxLen);
        }
    }
}

问题 C: 出列人数

也没啥好说的，典型的LIS

import java.util.Scanner;
 
public class Main {
    static int[] a=new int[1010];//存原数据
    static int[] b=new int[1010];//b[i]为以a[i]为单调递增子序列最后一个元素时所得的最长单调子序列的和
    static int[] pre=new int[1010];//存前一个的位置
    static int[] str=new int[1010];
    static int n;
    static int maxLen;
    static int mark;
 
    static void solve(){
        b[1]=1;
        for(int i=2;i<=n;i++){
            maxLen=0;
            for(int j=i-1;j>=1;j--){
                if(a[j]<a[i]&&b[j]>maxLen){
                    maxLen=b[j];
                    pre[i]=j;
                }
            }
            b[i]=maxLen+1;
        }
 
        maxLen=b[1];
        mark=1;
        for(int i=2;i<=n;i++){
            if(b[i]>maxLen){
                maxLen=b[i];
                mark=i;
            }
        }
    }
 
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            boolean flag=false;
            n=sc.nextInt();
            for(int i=1;i<=n;i++){
                a[i]=sc.nextInt();
            }
            solve();
            System.out.println(n-maxLen);
        }
    }
}

问题 D: 0-1背包问题

典中典

import java.util.Arrays;
import java.util.Scanner;
 
public class Main {
 
    static int n;
    static int c;
    static int[] w=new int[1010];
    static int[] v=new int[1010];
    static int[][] s=new int[1010][1010];
    static int[] arr = new int[1010];
 
    static void solve(int[]w,int[]v,int[]arr,int n,int c){
        int jmax=Math.min(c,w[n]-1);//预防数组越界
        //先填最后一行
        for(int j=0;j<=jmax;j++){
            s[n][j]=0;//装不下
        }
        for(int j=w[n];j<=c;j++){
            s[n][j]=v[n];//装得下
        }
        //至此最后一行填完
        //接下来DP开始
        for(int i=n-1;i>=1;i--){
            jmax=Math.min(c,w[i]-1);
            for(int j=0;j<=jmax;j++){
                s[i][j]=s[i+1][j];//装不下
            }
            for(int j=w[i];j<=c;j++){
                s[i][j]=Math.max(s[i+1][j],s[i+1][j-w[i]]+v[i]);//装得下
            }
        }
        //至此DP结束
        int mark=c;
        for(int i=1;i<n;i++){
            if(s[i][mark]!=s[i+1][mark]){
                arr[i]=1;
                mark=mark-w[i];
            } else {
                arr[i]=0;
            }
        }
        arr[n]=s[n][mark]>0?1:0;
    }
 
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            n=sc.nextInt();
            c=sc.nextInt();
            for(int i=1;i<=n;i++){//价值
                v[i]=sc.nextInt();
            }
 
            for(int i=1;i<=n;i++){//重量
                w[i]=sc.nextInt();
            }
            solve(w,v,arr,n,c);
            System.out.println(s[1][c]);
            for(int i=1;i<=n;i++){
                System.out.print(arr[i]);
            }
            System.out.println();
            Arrays.fill(w,0);
            Arrays.fill(v,0);
            Arrays.fill(arr,0);
//            for(int i=0;i<=n;i++){
//                for(int j=0;j<=c;j++){
//                    System.out.print(s[i][j]+" ");
//                }
//                System.out.println();
//            }//测试输出
        }
    }
}

问题 E: XP的午餐

import java.util.Arrays;
import java.util.Scanner;
 
public class Main {
 
    static int n;
    static int c;
    static int[] w=new int[1010];
    static int[] v=new int[1010];
    static int[][] s=new int[1010][1010];
 
    static void solve(int[]w,int[]v,int n,int c){
        int jmax=Math.min(c,w[n]-1);//预防数组越界
        //先填最后一行
        for(int j=0;j<=jmax;j++){
            s[n][j]=0;//装不下
        }
        for(int j=w[n];j<=c;j++){
            s[n][j]=v[n];//装得下
        }
        //至此最后一行填完
        //接下来DP开始
        for(int i=n-1;i>=1;i--){
            jmax=Math.min(c,w[i]-1);
            for(int j=0;j<=jmax;j++){
                s[i][j]=s[i+1][j];//装不下
            }
            for(int j=w[i];j<=c;j++){
                s[i][j]=Math.max(s[i+1][j],s[i+1][j-w[i]]+v[i]);//装得下
            }
        }
        //至此DP结束
    }
 
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            c=sc.nextInt();
            n=sc.nextInt();
            for(int i=1;i<=n;i++){//价值
                w[i]=sc.nextInt();
                v[i]=sc.nextInt();
            }
            solve(w,v,n,c);
            System.out.println(s[1][c]);
            Arrays.fill(w,0);
            Arrays.fill(v,0);
        }
    }
}

问题 F: 补充能量

import java.util.Arrays;
import java.util.Scanner;
 
public class Main {
    static int n;
    static int c;
    static int[] w=new int[1010];
    static int[] v=new int[1010];
    static int[][] s=new int[1010][1010];
 
    static void solve(int[]w,int[]v,int n,int c){
        int jmax=Math.min(c,w[n]-1);//预防数组越界
        //先填最后一行
        for(int j=0;j<=jmax;j++){
            s[n][j]=0;//装不下
        }
        for(int j=w[n];j<=c;j++){
            s[n][j]=v[n];//装得下
        }
        //至此最后一行填完
        //接下来DP开始
        for(int i=n-1;i>=1;i--){
            jmax=Math.min(c,w[i]-1);
            for(int j=0;j<=jmax;j++){
                s[i][j]=s[i+1][j];//装不下
            }
            for(int j=w[i];j<=c;j++){
                s[i][j]=Math.max(s[i+1][j],s[i+1][j-w[i]]+v[i]);//装得下
            }
        }
        //至此DP结束
    }
 
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            n=sc.nextInt();
            c=sc.nextInt();
 
            for(int i=1;i<=n;i++){//重量
                w[i]=sc.nextInt();
            }
 
            for(int i=1;i<=n;i++){//价值
                v[i]=sc.nextInt();
            }
 
 
            solve(w,v,n,c);
            System.out.println(s[1][c]);
            Arrays.fill(w,0);
            Arrays.fill(v,0);
//            for(int i=0;i<=n;i++){
//                for(int j=0;j<=c;j++){
//                    System.out.print(s[i][j]+" ");
//                }
//                System.out.println();
//            }//测试输出
        }
    }
}

问题 G: 最少硬币（经典的贪心应用）

import java.util.Scanner;
 
public class Main {
 
    static int[] coins={1,5,10,25};
    static int solve(int n){
        int num=0;
        if(n<=0)return 0;
        for(int i=3;i>=0;i--){
            num+=n/coins[i];
            n=n%coins[i];
            if(n==0)break;
        }
        return num;
    }
 
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while (sc.hasNext()){
            int n=sc.nextInt();
            System.out.println(solve(n));
        }
 
    }
}

问题 H: 图书排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 
public class Main {
    public static class book implements Comparable<book>{
        String name;
        int sales;
        double price;
 
        public book(String s, int parseInt, double parseDouble) {
            super();
            name=s;
            sales=parseInt;
            price=parseDouble;
        }
 
 
        @Override
        public int compareTo(book o) {
            if(sales>o.sales){
                return -1;
            } else if(sales==o.sales){
                if(price>o.price)return 1;
                else if(price==o.price)return 0;
                else return -1;
            } else return 1;
        }
    }
 
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        List<book>books=new ArrayList<book>();
        int n=Integer.parseInt(sc.nextLine());
        while(n>0){
            n--;
            String[] msg=sc.nextLine().split(" ");
            books.add(new book(msg[0], Integer.parseInt(msg[1]), Double.parseDouble(msg[2])));
        }
        Collections.sort(books);
        for(book b:books){
            System.out.print(b.name+" "+b.sales+" ");
            System.out.printf("%.2f\n",b.price);
        }
    }
}

参考博客由此进🌸

醉后不知天在水，满船清梦压星河

因为牙疼深夜上分
是君倩
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
程振波 算法设计与分析_算法设计与分析
weixin_39747341的博客
12-21 1342
本书按照教育部*制定的计算机科学与技术专业规范的教学大纲编写，努力与国际计算机学科的教学要求接轨。强调 算法 与 数据结构 之间密不可分的联系，因而强调融数据类型与定义在该类型上的运算于一体的抽象数据类型，为面向对象的程序设计方法奠定基础，体现计算机科学方法论的理论、抽象和设计三个过程，知识面较宽，且有一定的深度；反复再现计算机科学中用到的大问题的复杂性、效率、抽象的层次、重用、折衷等带有普遍性的...
算法设计与分析学习总结
热门推荐
qq_40798278的博客
12-11 1万+
算法设计与分析学习总结 通过对《算法设计与分析》这门课的学习，似乎对算法有了一定的了解，之前对算法并没有太多的接触，只是一些普通的编程。选课的时候，觉得特别有意思，就选了这门课，通过学习各类算法，有了一定的认识。递归法，分治法，蛮力法，回溯法。贪心算法等等，对之后的编都有很大的帮助。 现在，我深刻的明白这门课的对软件工程专业的重要性，程序的编写都离不开它，对培养思维能力也有一定的帮助，还能培养我们...
LeetCode——300. 最长上升子序列（动态规划）
FYPPPP的博客
11-28 204
题目描述： 给定一个无序的整数数组，找到其中最长上升子序列的长度。 示例： 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。 例如： 定义：dp[i] 表示以 nums[i] 这个数结尾的最长递增子序列的长度。 根据对 dp 数组的定义，现在想求 dp[5] 的值，也就是想求以 nums[5] 为结尾的最长递增子序列。nums[5] = 3，既然是递增子序列，我们只要找到前面那些结尾比 3 小的子序列，然后把 3 接到最后
算法设计与分析练习题答案
https://blog.datasource.space
05-15 4491
第一章 答：由于算法具有有穷性、确定性和输出性，因而Ⅱ、Ⅲ、Ⅳ正确，而解决某一 类问题的算法不一定是唯一的。答案为 C。 答：选项 A 的时间复杂度为 O(n)。选项 B 的时间复杂度为 O(n2)。选项 C 的时间 复杂度为 O(log2n)。选项 D 的时间复杂度为 O(nlog2n)。答案为 C。 答：算法是求解问题的一系列计算步骤。算法具有有限性、确定性、可行性、输 入性和输出性 5 个重要特征。 答：（1）当 n 足够大时，(10n2-2n)/( n2)=10，所以 第二章 解：求 T(n)的过
2022年春季学期《算法分析与设计》练习13
不服输的小乌龟
07-19 2285
2022年春季学期《算法分析与设计》练习13
软件设计师-8.算法分析与设计
chenjian723122704的专栏
05-01 2665
8.1 算法设计与分析的基本概念 1）算法 算法是对特定问题求解步骤的一种描述，它是指令的有限序列，其中每条指令表示一个或多个操作。 算法特性： 有穷性 确定性 可行性 输入 输出 2）算法设计 一个好的算法应考虑多个目标，包括正确性、可读性、健壮性和高效性等。 算法设计技术主要有分治法、动态规划法、贪心法、回溯法、分支限界法，概率算法和近似算法等。 3）算法分析 算法分析技术的主要内容： 选择算法标准：正确性、可靠性、简单性、易理解性 算法的时间复杂度和空间复杂度要低 4）算法
HNUCM 算法分析与设计练习5之快速排序
H-rosy的博客
03-30 1217
编程实现快速排序算法，深入理解快速排序算法的基本思想。 输入 多组输入，每组第一个数字为数组长度，然后输入一个一维整型数组。 输出 输出快速排序之后的一维整型数组（升序） 样例输入Copy 6 1 8 6 5 3 4 5 12 42 2 5 8 样例输出Copy 1 3 4 5 6 8 2 5 8 12 42 提交 #include<bits/stdc++.h> using namespace std; typedef long long ll; voi...
算法设计与分析习题大全
Rightstar的博客
01-08 4670
算法设计与分析习题大全 By HB 题目来源:PTA 一、算法基础 办事大厅排队(STL) #include<iostream> #include<string> #include<list> #include<stdio.h> using namespace std; int main() { int n,i; string str; list<string> data; cin>>n;
算法设计与分析练习题
https://blog.datasource.space
05-15 4772
第一章 下列关于算法的说法中正确的有（ ）。 Ⅰ.求解某一类问题的算法是唯一的 Ⅱ.算法必须在有限步操作之后停止 Ⅲ.算法的每一步操作必须是明确的，不能有歧义或含义模糊 Ⅳ.算法执行后一定产生确定的结果 A. 1 个 B.2 个 C.3 个 D.4 个 T(n)表示当输入规模为 n 时的算法效率，以下算法效率最优的是（ ）。 A.T(n)= T(n-1)+1，T(1)=1 B.T(n)= 2n2 C.T(n)= T(n/2)+1，T(1)=1 D.T(n)=3nlog2n 什么是算法？算法有哪些特征？ 证
算法设计与分析习题
m0_45907559的博客
09-29 1987
1.摆渡的士兵 设两个小男孩为A、B，士兵为1，2....12。先考虑士兵1。 四趟可以渡过去一个士兵，所以n个士兵需要4n趟。 2.交替放置的玻璃杯 以两种杯子的交界为对称轴，左侧的杯子编号为2的倍数时与右侧对称位置的杯子交换。 当n为奇数时，需要交换的次数是（n-1）/2； 当n为偶数时，需要交换的次数是n/2。 3.标记单元格 依次类推，n每增加2，按图中规律增加。 n/2（n不为2）为奇数时，水平新增一个单...
计算机算法设计与分析练习题
10-06
计算机算法设计与分析练习题 word版 可直接打印
算法设计与分析 课程笔记
05-09
《算法设计与分析》课程笔记是对本科阶段算法学习的重要总结，涵盖了算法的基础概念、递归与分治策略、动态规划以及贪心算法等核心主题。笔记详尽且排版精美，适合作为复习资料。 1. **算法的概念与性质**： 算法...
HNUCM 2018级《算法分析与设计》练习一题解
01-20
HNUCM 2018级《算法分析与设计》练习一题解 A-无法重启的2020 题意： 给定一个四位数，判断是否符合ABAB类型 是输出Yes，否输出No 题解： 需要注意的坑点是第一个数和第二个数不能相等，否则就是AAAA类型了 B-XP...
算法设计与分析练习 1
08-03
8. 渐近算法分析是指当规模逐步增大时，对算法资源开销“增长率”的简化分析（B）。它关注最坏、最好和平均情况下的资源消耗，但主要是关注大O表示法描述的趋势。 9. 对一个算法的评价，通常不包括并发性（B）。...
算法设计技巧与分析
04-26
全书分七部分19章，从算法设计和算法分析的基本概念和方法入手，先后介绍了递归技术、分治、动态规划、贪心算法、图的遍历等技术，对NP完全问题进行了基本但清楚的讨论。对概率算法、近似算法和计算几何这些近年来...
HNUCMOJ题解
m0_52949203的博客
04-21 3121
HNUCMOJ 2022年春季学期《算法分析与设计》练习8 前6题为必做题，最后2题为选做题！ 写在前面： 题目还是没那么难的，只是有些东西不好理解，可以像老师一样画图帮助理解 1、 问题 A: 数字三角形之动态规划法 AC代码： import java.util.Arrays; import java.util.Scanner; public class Main { public static int n; public static int[][]arr,Maxsum;
搭建电路（最大生成树）
m0_52949203的博客
06-02 986
明明迷上了一个搭建电路的游戏。 在游戏中，每次在两个电子元件之间增加一条有效电路（两个元件之间先前没有电路相连）都将获得相应的积分奖励。 已知电子元件数量n和部分电子元件之间的奖励积分值。如何构建一个有效电路将所有元件全部连接起来，并且可以得到最多的积分奖励。每组输入数据包含m+1行。 第1行输入两个正整数n和m，其中n表示电子元件数量（n
2022年春季学期《算法分析与设计》练习12
m0_52949203的博客
05-28 704
问题 A: XP的素数 题目描述 XP最近对素数很痴迷，特别是那些特殊的素数，其中有一类素数被称为孪生素数。其定义如下：如果一个数k是素数，k+2也是素数，那么k和k+2成为一对孪生素数。请计算一个给定区间m和n（0<m<n）中孪生素数对的个数。 输入 单组输入数据 m n (0<m<n<1000) 输出 请输出一行结果:区间[m,n]中孪生素数对的个数 样例输入 1 999 样例输出 35 import java.util.Scanner; public class Mai
HNUCMOJ_题解
m0_52949203的博客
04-30 501
2022年春季学期《算法分析与设计》练习9 问题A ：最大子段和 这个题没啥要注意的，就是记得不要和我一样没注意多组输入 AC代码： 1、DP import java.util.Scanner; public class Main { public static int solve(int[] a) { int maxSum = Integer.MIN_VALUE; int tempSum = 0; int begin = 0;
算法分析与设计c++答案
最新发布
10-08
算法分析与设计是一门计算机科学中的重要课程，它主要研究的是如何设计和分析各种算法。 首先，算法是解决问题的步骤和方法的描述。它是计算机程序的基础，可以帮助解决我们面临的各种复杂问题。算法的设计是指选择...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

是君倩

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

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

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

打赏作者

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

抵扣说明：

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

余额充值