CSP202212 03.18 JAVA 现值计算 训练计划 JPEG解码 聚集方差 星际网络 持续更新欢迎交流..

已于 2023-03-18 15:17:01 修改
阅读量806 收藏 1
点赞数
文章标签： java 开发语言 算法
于 2023-03-18 11:14:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45322373/article/details/129633545
版权

目录

当前结果

现值计算

训练计划

JPEG 解码

聚集方差

星际网络

更新时间：2023.03.18

当前结果

 

题目地址：首页 - 计算机软件能力认证考试系统

注意：想直接运行需要把下列代码class名和main函数改成Main再加入即可

现值计算

思路

按题目模拟即可

代码

import java.util.*;

public class xzjs20221201 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int n = scan.nextInt();
        double i = scan.nextDouble();
        int[] a = new int[n + 1];
        double res = 0;
        for (int x = 0; x <= n; x++) {
            a[x] = scan.nextInt();
            res += a[x] * Math.pow(1 + i, -x);
        }
        System.out.printf("%.3f", res);
        scan.close();
    }
}

训练计划

思路

假定箭头指向为爸爸，箭头指出为儿子 

  1. 接收输入
  2. 先处理最早开始时间
    1. 如果项目无爸爸，最早开始时间为1
    2. 如果有依赖
      1. 最早时间为爸爸j最早时间+j耗时
      2. 如果当前最早时间+本身i耗时超过n则说明完成不了
      3. j儿子列表加入i
  3. 输出最早开始时间，如果完成不了则直接退出否则下一步
  4. 倒叙遍历
    1. 默认最晚从n+1减当前项i耗时算
    2. 找儿子们的最晚时间的最早项，用这个减当前项耗时即为当前最晚耗时
  5. 输出最晚开始时间

代码

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class xljh20221202 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt(), m = scan.nextInt();
        int[] p = new int[m];
        for (int i = 0; i < m; i++) {
            p[i] = scan.nextInt();
        }
        int[] t = new int[m];
        for (int i = 0; i < m; i++) {
            t[i] = scan.nextInt();
        }
        int[] pre = new int[m];
        int[] last = new int[m];
        List<List<Integer>> fromList = new ArrayList<>();
        boolean isPrint2 = true;
        for (int i = 0; i < m; i++) {
            if (p[i] == 0) {
                pre[i] = 1;
            } else {
                int j = p[i] - 1;
                pre[i] = pre[j] + t[j];
                if (pre[i] + t[i] - 1 > n) isPrint2 = false;
                List<Integer> from = fromList.get(j);
                from.add(i);
            }
            fromList.add(new ArrayList<>());
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < m - 1; i++) {
            sb.append(pre[i]).append(' ');
        }
        System.out.println(sb.append(pre[m - 1]));
        if (isPrint2) {
            for (int i = m - 1; i >= 0; i--) {
                int min = n + 1;
                for (int f : fromList.get(i)) {
                    min = Math.min(min, last[f]);
                }
                last[i] = min - t[i];
            }
            sb = new StringBuilder();
            for (int i = 0; i < m - 1; i++) {
                sb.append(last[i]).append(' ');
            }
            System.out.println(sb.append(last[m - 1]));
        }
        scan.close();
    }
}

JPEG 解码

思路

模拟即可

扫描数据思路：

按照箭头方向扫，注意如果i>7的情况处理。

代码

import java.util.Scanner;

public class jpeg20221203 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int[][] matrix = new int[8][8];
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                matrix[i][j] = scan.nextInt();
            }
        }
        int n = scan.nextInt(), T = scan.nextInt();
        // 第三步
        int[][] m = new int[8][8];
        int index = 0;
        for (int i = 0; i < 15 && index < n; i++) {
            int a, b;
            // 右上
            if (i % 2 == 0) {
                a = i > 7 ? 7 : i;
                b = i - a;
                while (index < n && a >= 0 && b <= 7) {
                    m[a--][b++] = scan.nextInt();
                    index++;
                }
            }
            // 左下
            else {
                b = i > 7 ? 7 : i;
                a = i - b;
                while (index < n && b >= 0 && a <= 7) {
                    m[a++][b--] = scan.nextInt();
                    index++;
                }
            }
        }
        if (T == 0) {
            for (int i = 0; i < 8; i++) {
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < 8; j++) {
                    sb.append(m[i][j]).append(" ");
                }
                System.out.println(sb);
            }
            scan.close();
            return;
        }
        // 第四步
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                m[i][j] *= matrix[i][j];
            }
        }
        if (T == 1) {
            for (int i = 0; i < 8; i++) {
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < 8; j++) {
                    sb.append(m[i][j]).append(' ');
                }
                System.out.println(sb);
            }
            scan.close();
            return;
        }

        // 第五步
        double[][] m5 = new double[8][8];
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                double temp = 0.0;
                for (int u = 0; u < 8; u++) {
                    for (int v = 0; v < 8; v++) {
                        double a = u == 0 ? Math.sqrt(0.5) : 1, b = v == 0 ? Math.sqrt(0.5) : 1;
                        double cos = Math.cos(Math.PI / 8 * (i + 0.5) * u) * Math.cos(Math.PI / 8 * (j + 0.5) * v);
                        temp += (a * b * m[u][v] * cos);
                    }
                }
                temp *= 0.25;
                m5[i][j] = temp;
            }
        }
        // 第六步
        int[][] m6 = new int[8][8];
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                m6[i][j] = (int) Math.round(m5[i][j] + 128);
                if (m6[i][j] > 255) m6[i][j] = 255;
                else if (m6[i][j] < 0) m6[i][j] = 0;
            }
        }
        if (T == 2) {
            for (int i = 0; i < 8; i++) {
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < 8; j++) {
                    sb.append(m6[i][j]).append(' ');
                }
                System.out.println(sb);
            }
            scan.close();
        }
    }
}

聚集方差

感觉做的思路没问题，但是没得分，欢迎指出问题

思路

初始时，各节点的子树节点只有自身。

逆序遍历，将后序节点的所有子树节点集合加入到前序节点的子树集合中。

对各子树按偏好时间进行排序，求相邻节点最小时间差的平方和。

代码

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class jjfc20221204 {
    // id a set T res
    private static int[] res;
    private static int[][] Ts;
    private static Set<Integer>[] sets;
    private static int[] a;

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        init(n);
        for (int i = 1; i <= n; i++) {
            sets[i] = new HashSet<>();
            sets[i].add(i);
            Ts[i][1] = i;
            Ts[i][0] = 1;
        }

        // 每个员工的老板
        int[] p = new int[n + 1];
        for (int i = 2; i <= n; i++) {
            p[i] = scan.nextInt();
        }

        // 逆序遍历，将后序节点的所有子树节点集合加入到前序节点的子树集合中。
        for (int i = n; i >= 2; i--) {
            addSons(p[i], i);
        }
        // 每个员工偏好时间
        for (int i = 1; i <= n; i++) {
            a[i] = scan.nextInt();
        }
        // 所有节点子节点按照a的大小排序
        for (int i = 1; i <= n; i++) {
            getRes(i);
            System.out.println(res[i]);
        }
        scan.close();
    }

    private static void getRes(int id) {
        int size = Ts[id][0];
        Integer[] T = new Integer[size];
        for (int i = 0; i < size; i++) {
            T[i] = Ts[id][i + 1];
        }
        Arrays.sort(T, (o1, o2) -> a[o1] - a[o2]);
        if (size == 1) {
            res[id] = 0;
            return;
        }
        int ans = 0;
        int m0 = a[T[0]] - a[T[1]];
        ans += m0 * m0;
        for (int i = 1; i < size - 1; i++) {
            int m = a[T[i]] - a[T[i - 1]];
            int n = a[T[i]] - a[T[i + 1]];
            ans += Math.min(m * m, n * n);
        }
        int ml = a[T[size - 2]] - a[T[size - 1]];
        ans += ml * ml;
        res[id] = ans;
    }

    private static void init(int n) {
        int len = n + 1;
        res = new int[len];
        // 0 儿子数量 1 自己 后续：儿子们
        Ts = new int[len][len];
        sets = new HashSet[len];
        a = new int[len];
    }

    private static void addSons(int fa, int son) {
        int sSize = Ts[son][0];
        int fSize = Ts[fa][0];
        for (int i = 1; i <= sSize; i++) {
            int grandSon = Ts[son][i];
            Set<Integer> set = sets[fa];
            if (set.add(grandSon)) {
                Ts[fa][++fSize] = grandSon;
            }
        }
        Ts[fa][0] = fSize;
    }
}

星际网络

感觉做的思路没问题，但是只得了20分，欢迎指出问题

目前感觉错误原因有超时，以及星际时间存在超限制的情况未处理

思路

Dijkstra(迪杰斯特拉)算法

注意响应时间用long存放（仍存在超限情况）

代码

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main {
    private long[] d;// 从起始开始经过其他节点
    private long[] re;
    private Set<Integer> set;
    private int n, m;
    private int[][] datas;
    private int mo = (int) Math.pow(10, 9) + 7;
    private long[] ts;

    public static void main(String[] args) {
        new Main().solution();
    }

    public void solution() {
        init();
        djikD();
        clear();
        djikR();
        print();
    }

    private void clear() {
        set = new HashSet<>();
    }

    private void djikR() {
        // 所有星球都遍历
        if (set.size() == n) return;
        // 找最小点
        int minId = 0;
        long min = Long.MAX_VALUE;
        for (int i = 1; i <= n; i++) {
            if (set.contains(i)) continue;
            if (re[i] < min) {
                minId = i;
                min = re[i];
            }
        }
        // 从该点出发 找最小路径
        for (int i = 1; i <= m; i++) {
            // 遍历中继卫星 中继卫星可用
            if (datas[i][2] <= minId && minId <= datas[i][3]) {
                int l = datas[i][0], r = datas[i][1];
                long temp = min + ts[i];
                // 使用该中继卫星
                for (int j = l; j <= r; j++) {
                    // 更新d
                    if (temp < re[j]) re[j] = temp;
                }
            }
        }
        // 加入处理队列
        set.add(minId);
        djikR();
    }

    private long getT(int a, int b) {
        long t = a;
        while (b-- > 0) {
            t <<= 1;
        }
        return t;
    }

    private void print() {
        StringBuilder sb = new StringBuilder();
        for (int i = 2; i <= n; i++) {
            if (d[i] == Long.MAX_VALUE || re[i] == Long.MAX_VALUE) sb.append(-1).append(' ');
            else sb.append((d[i] + re[i]) % mo).append(' ');
        }
        System.out.println(sb);
    }

    private void djikD() {
        // 所有星球都遍历
        if (set.size() == n) return;
        // 找最小点
        int minId = 0;
        long min = Long.MAX_VALUE;
        for (int i = 1; i <= n; i++) {
            if (set.contains(i)) continue;
            if (d[i] < min) {
                minId = i;
                min = d[i];
            }
        }
        // 从该点出发 找最小路径
        for (int i = 1; i <= m; i++) {
            // 遍历中继卫星 中继卫星可用
            if (datas[i][0] <= minId && minId <= datas[i][1]) {
                int l = datas[i][2], r = datas[i][3];
                long temp = min + ts[i];
                // 使用该中继卫星
                for (int j = l; j <= r; j++) {
                    // 更新d
                    if (temp < d[j]) d[j] = temp;
                }
            }
        }
        // 加入处理队列
        set.add(minId);
        djikD();
    }

    public void init() {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        m = scan.nextInt();
        datas = new int[m + 1][6];
        ts = new long[m + 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 0; j < 6; j++) {
                datas[i][j] = scan.nextInt();
            }
            ts[i] = getT(datas[i][4], datas[i][5]);
        }
        d = new long[n + 1];
        re = new long[n + 1];
        Arrays.fill(d, Long.MAX_VALUE);
        Arrays.fill(re, Long.MAX_VALUE);
        d[1] = 0;
        re[1] = 0;
        set = new HashSet<>();
        scan.close();
    }
}

羊不白丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
yolov4-csp.weights
03-09
yolov4-csp.weights
csp13-21java100分.zip
12-08
标题 "csp13-21java100分.zip" 暗示这是一个与 CSP（中国计算机软件能力资格认证）考试相关的资源包，聚焦于 Java 编程语言，特别是针对该考试中的一、二题。CSP 考试是由中国计算机学会组织的一项旨在评测个人...
CSP 202212题解：现值计算，训练计划，JPEG 解码，聚集方差，星际网络
fmy_xfk的博客
03-08 2248
CSP 202212题解：现值计算，训练计划，JPEG 解码，聚集方差，星际网络
CSP202212（300分题解）现值计算、训练计划、JPEG编码满分代码＋注释
weixin_51136247的博客
02-21 1943
第28次CSP：202212。前三题满分题解
CCF-CSP真题《202212-1 现值计算》思路+python，c++，c满分题解
weixin_53919192的博客
02-17 1万+
本文为大家题解了CCF-CSP真题《202212-1 现值计算》，希望对你有帮助~~
CSP202212-4---＞聚集方差
weixin_51954774的博客
02-22 2897
CSP
java.lang.IllegalStateException: Cannot load configuration class: com.alibaba.csp.sentinel.dashboard
qq_52421664的博客
03-23 5808
初学sentinel，用命令行运行后，访问localhsot:8080一直出现无法访问，打开命令窗口后，发现没有正常启动，在启动时报错，出现该异常java.lang.IllegalStateException: Cannot load configuration class: com.alibaba.csp.sentinel.dashboard.DashboardApplication。 在解压jar包后发现，其需要特定的jdk版本才行。 于是我们可以才cmd命令窗口指定jdk版本的bin路径，进行运行
Sentinel com.alibaba.csp.sentinel.ErrorEntryFreeException
Simo_YiN的博客
09-24 4669
<spring-cloud-alibaba.version>2.2.1.RELEASE</spring-cloud-alibaba.version> 详细报错如下： 2020-09-24 15:37:55.339 ERROR 31004 --- [nio-9405-exec-3] o.s.web.servlet.HandlerExecutionChain : HandlerInterceptor.afterCompletion threw exception com.a...
使用sentinelResource报com.alibaba.csp.sentinel.slots.block.flow.FlowException: null
qq_41451744的博客
06-25 6053
问题：在使用@SentinelResource中的blockHandler时，一直报：com.alibaba.csp.sentinel.slots.block.flow.FlowException: null 问题代码： @GetMapping("/testZhuJie") @SentinelResource(value = "testZhuJie",blockHandler = "failBlockHandler") @ResponseBody public String
ClassNotFoundException: com.alibaba.csp.sentinel.log.Logger
咸花生的博客
06-30 1815
com.alibaba.csp.sentinel.log.Logger 类没找到 sentinel-core-1.7.1 以下 缺少 com.alibaba.csp.sentinel.log.Logger 接口 异常依赖 <!-- sentinel依赖--> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-st
sentinel限流兜底报错：com.alibaba.csp.sentinel.slots.block.flow.FlowException: null
qq_38037088的博客
09-03 1958
可能原因：1.设置的自定义限流规则类中的方法应该为静态方法 //测试服务降级 @GetMapping("/customerBlockHandler") @SentinelResource(value = "customerBlockHandler", blockHandlerClass = CustomerHandler.class, blockHandler = "h...
[汇总]计算机专业相关证书大全（持续更新...）
热门推荐
3hex的博客
08-26 7万+
声明 所有数据来源于网络，来源会附在结尾处。笔者只负责搜集整理，对于各证书含金量不做评价。文章内容仅作参考，没有任何培训广告。 内容会尽量保持持续更新。由于能力有限，难免出现各种错误和不足，如内容有任何问题，请私信通知，核实后会及时修改。 证书排序按照收集的顺序，没有任何排名。 ...
csp.dll.rar_CSP. DLL_CSP.d_csp_csp.dll
09-14
**CSP.dll详解** 在Windows操作系统中，CSP（Cryptographic Service Provider）是核心加密模块，它是微软开发的安全基础设施的一部分，用于实现各种加密算法和安全功能。CSP.dll是密码服务提供者的动态链接库，它...
CSP.rar_csp_java csp_回溯法
09-19
标题中的"CSP.rar_csp_java csp_回溯法"提到了三个主要概念：CSP（Constraint Satisfaction Problem，约束满足问题）、Java以及回溯法。约束满足问题是一种经典的计算机科学问题，通常涉及到在一组变量中找到合适的...
AI.rar_ch3_csp_games1.pdf
09-19
在“AI.rar_ch3_csp_games1.pdf”这一章节，我们聚焦于第三章的内容，主要围绕约束满足问题（CSPs）和游戏策略，这些都是人工智能中的重要组成部分。 首先，让我们来理解什么是约束满足问题。CSP是计算机科学中一种...
NOIP竞赛辅导专题CSP计算机等级考试辅导提高组普及组复赛辅导.pdf原创资料下载
最新发布
05-17
NOIP竞赛辅导专题CSP计算机等级考试辅导提高组普及组复赛辅导.pdf原创资料下载，CSP考级，CSP非专业级别的能力认证，CSP考级辅导资料，算法入门资料，青少年编程集训资料，信息学奥赛，信息学奥林匹克竞赛，NOIP普及...
CSP-J1 CSP-S1 第1轮 初赛（2023.09.03）.rar
09-04
CSP-J1 CSP-S1 初赛（2023.09.03）是针对青少年的信息学奥林匹克竞赛的第一轮比赛，旨在测试参赛者在计算机科学和算法方面的基础能力。这个压缩包文件包含了丰富的学习资源，帮助参赛者准备这次比赛。 首先，我们...
[ZA]NOIP26初赛普及组计算机试题及答案029CSP竞赛比赛CSP考级.pdf
05-14
NOIP比赛，NOIP竞赛历年真题及答案，CSP比赛，CSP竞赛，CSP考级；NOIP普及组，NOIP提高组。
csp详细介绍.zip
03-31
**CSP（Content Security Policy）详解** CSP，全称为Content Security Policy，中文通常译为“内容安全策略”。它是Web安全领域的一项重要机制，旨在帮助网站防御跨站脚本（XSS）攻击和其他某些类型的注入攻击。...
CCF CSP 2017.09：分组计算与公共钥匙盒问题解码
在CCF CSP 2017.09的编程竞赛中，两道题目分别是“CCF201709-1 打酱油”和“CCF201709-2 公共钥匙盒”，均为满分100分的C++代码实现。 CCF201709-1 打酱油 这是一道关于货币兑换的问题。题目要求以5瓶一组购买，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值