CSP认证-202212

最新推荐文章于 2024-06-23 22:33:26 发布
最新推荐文章于 2024-06-23 22:33:26 发布
阅读量895 收藏 22
点赞数 29
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70220973/article/details/137080461
版权
前言

        使用java，根据官方模拟考试的试题列表刷题 试题清单

        目前只更新了前三题的满分思路，后面两题先放一放，随缘更新~

202212

202212-1 现值计算

满分思路：计算第k年的x元在今年的价值x/Math.pow(1+i,k)，将每年结果累加

注意：题目要将未来的款项转换为今年的价值

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(); // 年数
        double res = 0, i = scanner.nextDouble(); // 年利率
        for (int k = 0; k < n + 1; k++) { // 每年金额
            res += scanner.nextDouble() / Math.pow(1 + i, k);
        }
        System.out.println(res);
    }
}

202212-2 训练计划

（1）70分思路：time[]为每个科目所需时间，dep[i]为每个科目的依赖科目，earliest[]为每个科目的最早开始时间；依次计算earliest[]，如果该科目无依赖，则earliest[i]为1，如果有依赖dep[i]，则earliest[i]为earliest[dep[i]]+time[dep[i]]

（2）满分思路（优）：在70分思路的基础上，latest[]为每个科目的最晚开始时间；在计算earliest[]时，如果earliest[i]+time[i]-1>n，则说明计划不能完成，只需要输出earliest[]即可；如果能完成，先初始化latest[i]为假设无依赖的最晚开始时间n-time[i]+1，再从前往后遍历，由于编号大的科目一定依赖编号小的科目，对于有依赖的科目latest[dep[i]]=min(latest[dep[i]],latest[i]-time[dep[i])，即得latest[i]

import java.util.*;
public class Main {
    static int[] dep; // 依赖关系
    static int[] time; // 需要时间
    static int[] earliest, latest; // 最早开始时间，最晚开始时间

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt(); // 天数，科目数
        dep = new int[m + 1];
        time = new int[m + 1];
        earliest = new int[m + 1];
        latest = new int[m + 1];
        boolean isFinish = true; // 是否能完成
        for (int i = 1; i <= m; i++) {
            dep[i] = sc.nextInt(); // 依赖
        }
        for (int i = 1; i <= m; i++) {
            time[i] = sc.nextInt(); // 需要时间
            if (dep[i] == 0) earliest[i] = 1; // 无依赖
            else earliest[i] = earliest[dep[i]] + time[dep[i]]; // 有依赖
            if (earliest[i] + time[i] - 1 > n) isFinish = false;
        }
        // 最早开始时间
        for (int i = 1; i <= m; i++) System.out.print(earliest[i] + " ");
        System.out.println();
        if (isFinish) {
            // 最晚开始时间
            for (int i = m; i > 0; i--) latest[i] = n - time[i] + 1; // 假设都没有依赖
            for (int i = m; i > 0; i--) {
                if (dep[i] != 0 && latest[dep[i]] > latest[i] - time[dep[i]]) // 如果有依赖
                    latest[dep[i]] = latest[i] - time[dep[i]];
            }
            for (int i = 1; i <= m; i++) System.out.print(latest[i] + " ");
            System.out.println();
        }
    }
}

（3）满分思路：对earliest[]的处理与之前一致，对latest[]的处理引入List<Integer>[]next记录每个科目的下一个科目列表，以及last[i]记录该科目后续依赖需要的最大时间；使用递归计算每个科目的之后依赖所需最大时间maxTime，则得到该科目的last[i]=maxTime+time[i]，对于每个没有依赖的科目都要进行递归，最终打印latest[i]为n-last[i]+1。下面代码中times[i][0]对应最早开始时间earliest[i]，times[i][1]对应每个科目所需时间time[i]

import java.util.*;
public class Main {
    static List<Integer>[] next; // 下一个科目
    static int[] dep; // 依赖关系
    static int[][] times; //最早开始时间、完成时间
    static int[] last; // 后续时间
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt(); // 天数，科目数
        next = new List[m+1];
        dep = new int[m + 1];
        times = new int[m + 1][2];
        last = new int[m + 1];
        boolean isFinish = true; // 是否能完成
        for (int i = 1; i <= m; i++) {
            dep[i] = sc.nextInt();
            next[i] = new ArrayList<>();
            if(dep[i]!=0)next[dep[i]].add(i);
        }
        times[0][0] = 1; // 初始化
        for (int i = 1; i <= m; i++) {
            times[i][0] = times[dep[i]][0] + times[dep[i]][1];
            times[i][1] = sc.nextInt();
            if (times[i][0]+times[i][1]-1 > n) isFinish = false;
        }
        // 最早开始时间
        for (int i = 1; i <= m; i++) System.out.print(times[i][0] + " ");
        System.out.println();
        if (isFinish) {
            // 最晚开始时间
            for (int i = 1; i <= m; i++) if(dep[i]==0)getLast(i);
            for (int i = 1; i <= m; i++) System.out.print((n - last[i] + 1) + " ");
            System.out.println();
        }
    }

    public static void getLast(int index){
        int maxTime = 0;
        for(int i : next[index]){
            getLast(i);
            maxTime = Math.max(maxTime,last[i]);
        }
        last[index] = maxTime + times[index][1];
    }
}

202212-3 JPEG解码

        该题的核心主要是矩阵填充和逆余弦变换的计算，计算照着公式一步步来就行，这里思路主要介绍矩阵填充的方法

（1）满分思路：多个if进行边界判断。使用x、y记录下一个要填的下标，填充主要包括斜线和转向两种情况，逐个填充n个数，对于矩阵每个边界进行分析，可得：

a.换向情况：

        ①x==0&&y==0时y+=1

        ②(x==0&&y<7)||(x==7&&y<7)时y+=1

        ③(x<7&&y==0)||(x<7&&y==7)时x+=1

b.斜线情况：

        ①当转向为(x==0&&y<7)||(x<7&&y==7)时，循环x+=1;y-=1，直到边界

        ②当转向为(x==7&&y<7)||(x<7&&y==0)时，循环x-=1;y+=1，直到边界

每次坐标转变后都要进行填充，并判断是否填充了n个

int x = 0, y = 0; // 从左上角开始
imageMatrix[x][y] = sc.nextInt();
for (int k = 1; k < n; ) {
    if (x == 0 && y == 0) y += 1;
    else if ((x == 0 || x == 7) && y < 7) y += 1;
    else if ((y == 0 || y == 7) && x < 7) x += 1;
    imageMatrix[x][y] = sc.nextInt();
    k++;
    if (k == n) break;
    if ((x == 0 && y < 7) || (y == 7 && x < 7)) {
        do {
            x += 1;
            y -= 1;
            imageMatrix[x][y] = sc.nextInt();
            k++;
            if (k == n) isFull = true;
        } while (!isFull && x != 0 && x != 7 && y != 0 && y != 7);
    } else if ((x == 7 && y < 7) || (y == 0 && x < 7)) {
        do {
            x -= 1;
            y += 1;
            imageMatrix[x][y] = sc.nextInt();
            k++;
            if (k == n) isFull = true;
        } while (!isFull && x != 0 && x != 7 && y != 0 && y != 7);
    }
}

（2）满分思路（优）：借用下标矩阵。将读入的数据记录在int[64]中，创建一个int[8][8]的矩阵依次存放填充位置对应数据读入的下标，根据i、j找到下标再找到填充数据

int[] scan = new int[64];
int[][] index = {{0, 1, 5, 6, 14, 15, 27, 28},
                {2, 4, 7, 13, 16, 26, 29, 42},
                {3, 8, 12, 17, 25, 30, 41, 43},
                {9, 11, 18, 24, 31, 40, 44, 53},
                {10, 19, 23, 32, 39, 45, 52, 54},
                {20, 22, 33, 38, 46, 51, 55, 60},
                {21, 34, 37, 47, 50, 56, 59, 61},
                {35, 36, 48, 49, 57, 58, 62, 63}};
for (int i = 0; i < n; i++) scan[i] = sc.nextInt();
for (int i = 0; i < 8; i++)
    for (int j = 0; j < 8; j++)
        imageMatrix[i][j] = scan[index[i][j]]; // 图像矩阵

（3）满分思路：根据矩阵下标特性填充。scan[]记录读入的数据；根据矩阵左下右上的斜线性质i+j为常数，会发现i+j为偶数时，从左下到右上，i+j为奇数时，从右上到左下；然后再计算出前面有多少个数，就可以确定填充对应的下标。

a.左下到右上，即i+j为偶数：

        ①上半部分：前面的斜线(1+...+(i+j)等差) + 所在斜线前面个数(j) =  (1+i+j)*(i+j)/2+j

        ②下半部分：上半所有(1+...+7等差=36) + 前面斜线(7+...+(16-i-j)等差) + 所在斜线前面个数(7-i) = 36+(23-i-j)*(i+j-8)/2+7-i

b.右上到左下，即为奇数：

        ①上半部分：前面的斜线(同上) + 所在斜线前面个数(i) =  (1+i+j)*(i+j)/2+i

        ②下半部分：上半所有(同上) + 前面斜线(同上) + 所在斜线前面个数(7-j) = 36+(23-i-j)*(i+j-8)/2+7-j

详细分析+图解见文章：第28次csp认证T3 JPEG 解码解析_cspjt3数据-CSDN博客

int[] scan = new int[64];
for (int i = 0; i < n; i++) scan[i] = sc.nextInt();
for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) {
        if ((i + j) % 2 == 0) {//偶数，左下到右上
            if (i + j <= 7) { // 上半
                // 1+...+(i+j) + j
                imageMatrix[i][j] = scan[(1 + i + j) * (i + j) / 2 + j];
            } else {// 下半
                // 上半 (1+8)*8/2=36
                // 下半 7+...+(16-i-j) + 7-i
                imageMatrix[i][j] = scan[36 + (23 - i - j) * (i + j - 8) / 2 + 7 - i];
            }
        } else {//奇数，右上到左下
            if (i + j <= 7) { // 上半
                // 1+...+(i+j) + i
                imageMatrix[i][j] = scan[(1 + i + j) * (i + j) / 2 + i];
            } else { // 下半
                // 上半36
                // 下半 7+...+(16-i-j) + 7-j
                imageMatrix[i][j] = scan[36 + (23 - i - j) * (i + j - 8) / 2 + 7 - j];
            }
        }
    }
}

注意：

        ①离散余弦变换中double运算的每个数值都要为double，包括写的常数

        ②结果使用Math.round()进行四舍五入，（为啥我使用(int)(res+0.5)进行四舍五入但是提交不对，蹲个大佬解答一下）

        ③结果大于255取255，小于0取0

剩余部分三种思路都是一样的，这里给一下第二个满分思路的完整代码

import java.util.*;
public class Main {
    static int[][] quantifyMatrix = new int[8][8]; // 量化矩阵
    static int[][] imageMatrix = new int[8][8]; // 图像矩阵
    static double[][] transMatrix = new double[8][8]; // 变换矩阵
    static int[][] decodeMatrix = new int[8][8]; // 解码矩阵

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 8; i++)
            for (int j = 0; j < 8; j++)
                quantifyMatrix[i][j] = sc.nextInt(); // 量化矩阵
        int n = sc.nextInt();
        int T = sc.nextInt();
        int[] scan = new int[64];
        int[][] index = {{0, 1, 5, 6, 14, 15, 27, 28},
                {2, 4, 7, 13, 16, 26, 29, 42},
                {3, 8, 12, 17, 25, 30, 41, 43},
                {9, 11, 18, 24, 31, 40, 44, 53},
                {10, 19, 23, 32, 39, 45, 52, 54},
                {20, 22, 33, 38, 46, 51, 55, 60},
                {21, 34, 37, 47, 50, 56, 59, 61},
                {35, 36, 48, 49, 57, 58, 62, 63}};
        for (int i = 0; i < n; i++) scan[i] = sc.nextInt();
        for (int i = 0; i < 8; i++)
            for (int j = 0; j < 8; j++)
                imageMatrix[i][j] = scan[index[i][j]]; // 图像矩阵
        if (T == 0) {
            for (int i = 0; i < 8; i++) {
                for (int j = 0; j < 8; j++)
                    System.out.print(imageMatrix[i][j] + " ");
                System.out.println();
            }
            return;
        }
        for (int i = 0; i < 8; i++)
            for (int j = 0; j < 8; j++)
                imageMatrix[i][j] *= quantifyMatrix[i][j]; // 量化后
        if (T == 1) {
            for (int i = 0; i < 8; i++) {
                for (int j = 0; j < 8; j++)
                    System.out.print(imageMatrix[i][j] + " ");
                System.out.println();
            }
            return;
        }
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                for (int u = 0; u < 8; u++) {
                    double au = u == 0 ? Math.sqrt(0.5) : 1.0;
                    double theta1 = (Math.PI / 8.0) * (i + 0.5) * u;
                    for (int v = 0; v < 8; v++) {
                        double av = v == 0 ? Math.sqrt(0.5) : 1.0;
                        double theta2 = (Math.PI / 8.0) * (j + 0.5) * v;
                        transMatrix[i][j] += au * av * imageMatrix[u][v] * Math.cos(theta1) * Math.cos(theta2);
                    }
                }
                decodeMatrix[i][j] = (int) Math.round(transMatrix[i][j] / 4.0 + 128);
                if (decodeMatrix[i][j] > 255) decodeMatrix[i][j] = 255;
                if (decodeMatrix[i][j] < 0) decodeMatrix[i][j] = 0;
                System.out.print(decodeMatrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

202212总结

        1、第一题指数运算求和

        2、第二题写出最早开始时间保底70分，最晚开始时间需要构思一下，使用latest[dep[i]]=min(latest[dep[i]],laest[i]-time[dep[i]])挺有创意的，也可以使用递归逐个更新

        3、第三题对于数组填充，使用填充下标矩阵真的很巧妙，利用矩阵下标i+j或者i-j的特性也很有用

        4、仔细看清题目的要求。如第一题是将未来价值转换到当前价值；第二题不能完成计划就只输出一行；第三题结果要四舍五入并在[0,255]范围内

        5、存个疑：使用(int)(res+0.5)不能成功四舍五入吗（求大佬解答一下）

搞笑症患者
关注
  • 29
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CSP-J模拟赛：真题复现
08-02
CSP-J（中国计算机学会青少年软件编程能力认证初级）是一项针对青少年的编程能力评估考试，旨在检验考生的编程基础和逻辑思维能力。本模拟赛名为FCC - PCS-J，旨在与CSP-J保持相似的难度水平。试卷共20页，包含45道...
CSP201909-CSP19次认证题面.pdf
10-25
第17次 CCF CSP 认证真题，考试时间：2019.9.15 13:30~17:30。适合准备参加CCF CSP认证考试的同学准备一下。
CCF CSP认证-202309
m0_62661752的博客
10-22 552
暴力肯定是不行的80%以上的数据大于1e5我们必须得找办法简化操作，突破点是的，我们可以这样想逆时针旋转了10弧度，再逆时针转了10弧度相当于逆时针转了20弧度。同样拉伸也是，所以可以看出来操作是可以堆叠在一起的，只需判断区间内的操作即可。可以看作是一个变向的前缀和。为什么想到了前缀和因为最后题目要求查找的是经过区间操作之后的位置我们就可以往前缀和这边想。
CSP202212-5---＞星际网络（20分代码）
weixin_51954774的博客
03-10 1198
CSP
CSP202212-4---＞聚集方差
weixin_51954774的博客
02-22 2855
CSP
CSP202212-2.训练计划
追风小小少年的博客
03-06 700
【代码】CSP202212-2.训练计划。
CCF-CSP真题《202212-1 现值计算》思路+python，c++，c满分题解
weixin_53919192的博客
02-17 1万+
本文为大家题解了CCF-CSP真题《202212-1 现值计算》，希望对你有帮助~~
CCF-CSP 202212-1 现值计算 c语言（满分）
Song_yang_yu的博客
02-24 1148
CCF-CSP 202212-1 现值计算 c语言（满分）
CCF-CSP认证历年真题解
热门推荐
海岛Blog
01-28 32万+
CSP认证考什么怎么考？ CCF计算机职业资格认证的每一道试题都十分经典，覆盖现实世界中方方面面的问题。这个历年试题解主要使用C/C++语言编写，将逐步增加Python和Java的解题程序。程序中附有注释，力求解题思路清晰简洁，值得珍藏与模仿。 逐题改写过程中，富文本编辑器写的博客将全部用Markdown编辑器改写。改写的第一题，都增加了Python和Java的解题程序。 2021.04第22次： CCF202104-1 灰度直方图（100分）【计数】 CCF202104-2 邻域均值（100分.
CSP202012-5 星际旅行（满分代码）
m0_46223441的博客
10-11 721
家人们，蚌埠住了呀，提交了90次，终于过了。 #include <bits/stdc++.h> using namespace std; #define mod 1000000007 #define ll unsigned long long #define For(i, i0, n) for(ll i=i0;i<n;i++) #define maxM 5000000 #define clr(a) memset(a,0,sizeof a) ll n, m, t, a, b, c, k
CSP202212-2 训练计划 java 满分解法通俗易懂
lzx117547的博客
03-10 379
CSP202212-2 训练计划 java 100分 小白
2019-2021 CSP-J CSP-S 第一轮成绩及分数线汇总.pdf
05-17
CSP-J和CSP-S认证考试科目详解 CSP-J和CSP-S认证考试是中国计算机学会（CCF）举办的计算机等级考试，旨在考察考生的计算机基础知识和编程能力。下面是对CSP-J和CSP-S认证考试科目的详细解释： 一、CSP-J认证考试...
2020 CSP-J1 CSP-S1答案解析及总结(C)-2021.08.23(B)--56页.pdf
08-24
* 备战CSP2020，初赛讲解，NOIP CSP-J CSP-S CSP-J/S * 信奥CSP入门级2019年初赛试题精讲 * 备战CSP2020，初赛讲解，NOIP CSP-J CSP-S CSP-J/S * 2011-2020NOIP/CSP普及组初赛真题解析 * 2019CSP提高初赛 * CSP2019-...
2021 CSP-J1 junior-C++ 初赛　第1轮　真题　.pdf
09-20
CSP-J1 初赛真题解析 本文档是对 2021 CSP-J1 junior-C++ 初赛第 1 轮真题的详细解析，以帮助读者更好地理解题目内容和解题思路。 一、单项选择题 1. 不属于面向对象程序设计语言的是（ ）。 答案：D. C。面向...
算法力扣刷题记录六【203移除链表元素】
danaaaa的博客
06-21 1013
删除链表节点
排序算法系列二：归并排序、快速排序
暗黑世界
06-22 308
一、概念 二、实现 三、时间空间复杂度 四、优缺点
C语言入门系列：从内存原理看函数的值传递和引用传递
epitomizelu的专栏
06-23 348
函数参数用于向函数传递数据，C语言支持两种传递方式：值传递和引用传递。
【算法】二叉树 - 理论基础
最新发布
Nanki_的博客
06-23 1032
int val;
csp202212-2 训练计划
08-23
很抱歉，我无法提供关于"csp202212-2"的特定训练计划。CSP（计算机软件专业资格认证）是一个由中国计算机学会主办的考试，旨在评估个人在计算机软件开发方面的能力。每个考试周期的具体训练计划会根据考试的内容和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值