第十九次CCF计算机软件能力认证

最新推荐文章于 2024-09-06 10:38:06 发布
最新推荐文章于 2024-09-06 10:38:06 发布
阅读量144 收藏
点赞数
文章标签： 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34696503/article/details/126362399
版权
本文探讨了线性分类器的实现，通过ACwing题目实例展示如何利用双指针解决稀疏向量问题，并深入解析Markdown渲染器和复杂的状态转移方程，涉及算法如转移矩阵和递归。适合理解算法和数据结构在实际问题中的应用。
摘要由CSDN通过智能技术生成

目录

1、线性分类器

ACwing 3287

#include <iostream>
#include <algorithm>
#include <set>
using namespace std;

typedef long long LL;
const int N = 1010;

int n, m;
struct Node {
    int x, y;
    char type;
} node[N];
int p0, p1, p2;
set<char> st_u, st_d;

bool get(int x, int y) {
    return p0 + (LL) x * p1 + (LL) y * p2 > 0;
}

int main() {
    cin >> n >> m;
    for (int i = 0; i < n; i++) cin >> node[i].x >> node[i].y >> node[i].type;
    while (m--) {
        cin >> p0 >> p1 >> p2;
        st_u.clear(), st_d.clear();
        for (int i = 0; i < n; i++) {
            int res = get(node[i].x, node[i].y);
            if (res > 0) st_u.insert(node[i].type);
            else st_d.insert(node[i].type);
        }
        if (st_d.size() > 1 || st_u.size() > 1) puts("No"); else puts("Yes");
    }
    return 0;
}

2、稀疏向量(双指针)

ACwing 3288

#include <iostream>
#include <algorithm>
using namespace std;

#define x first
#define y second

typedef long long LL;
typedef pair<int, int> PII;
const int N = 5e5 + 10;

int n, a, b;
PII A[N], B[N];

int main() {
    scanf("%d%d%d", &n, &a, &b);
    for (int i = 0; i < a; i++) scanf("%d%d", &A[i].x, &A[i].y);
    for (int i = 0; i < b; i++) scanf("%d%d", &B[i].x, &B[i].y);
    sort(A, A + a);
    sort(B, B + b);
    LL res = 0;
    for (int i = 0, j = 0; i < a && j < b;)
        if (A[i].x < B[j].x) i++;
        else if (A[i].x > B[j].x) j++;
        else res += (LL) A[i].y * B[j].y, i++, j++;
    printf("%lld", res);
    return 0;
}

3、Markdown渲染器

ACwing 3289

4、1246

ACwing 3290

首先，由题目可知：

  • 1：2
  • 2：4
  • 4：1，6
  • 6：6，4

也就是说， 2 2 2 可以由 1 1 1 转换过来， 4 4 4 可以由 2 、 6 2、6 2、6 转换过来…

当 S = 1 S= 1 S=1 的时候，可以发现时刻 n n n 的状态是完全取决于时刻 n − 1 n-1 n−1 的状态。也就是有转移方程：

  • f ( n , 1 ) = f ( n − 1 , 4 ) f(n, 1) = f(n-1, 4) f(n,1)=f(n−1,4)
  • f ( n , 2 ) = f ( n − 1 , 1 ) f(n, 2) = f(n- 1, 1) f(n,2)=f(n−1,1)
  • f ( n , 4 ) = f ( n − 1 , 2 ) + f ( n − 1 , 6 ) f(n, 4) = f(n - 1, 2) + f(n-1, 6) f(n,4)=f(n−1,2)+f(n−1,6)
  • f ( n , 6 ) = f ( n − 1 , 4 ) + f ( n − 1 , 6 ) f(n, 6) = f(n-1,4) + f(n-1,6) f(n,6)=f(n−1,4)+f(n−1,6)

当 S = 2 S = 2 S=2 的时候，这两位数可能存在两种构造情况：

  • 由上一个状态的一个数产生，比如 4 4 4 可以产生 16 16 16， 6 6 6 可以产生 64 64 64。
  • 由上一个状态的两个相邻的数产生。

那么就存在如下规律：

  • 1：2
  • 2：4
  • 4：1，6，16
  • 6：6，4，64
  • 16：26 (1产生2，6产生64，取前两位)
  • 26：46
  • 41：62
  • 42：64
  • 44：61
  • 46：66
  • 61：42
  • 62：44
  • 64：41
  • 66：46

可见可以产生的两位数总共仅有 14 14 14 总，且第 n n n 行的两位数完全取决于第 n − 1 n-1 n−1 行两位数的状态。

分析到这里可以考虑使用矩阵快速幂进行状态转移(根据数据，处理出 S = 1 、 S = 2 S= 1、S = 2 S=1、S=2 的情况，已经可以拿到96分！)。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

typedef long long LL;
const int N = 14, MOD = 998244353;

int n;
string S;
int id[100]; // 将下面14个数映射成从0开始的id
vector<int> vers{1, 2, 4, 6, 16, 26, 41, 42, 44, 46, 61, 62, 64, 66};
vector<vector<int>> g{{2}, {4}, {1, 6, 16}, {6, 4, 64}, {26}, {46}, {62}, {64}, {61}, {66}, {42}, {44}, {41}, {46}};
int tr[N][N]; // 转移矩阵

void init() {
    memset(id, -1, sizeof id);
    for (int i = 0; i < N; i++) id[vers[i]] = i;
    for (int i = 0; i < N; i++)
        for (auto x: g[i])
            tr[i][id[x]]++;
}

// 矩阵乘法
void mul(int c[][N], int a[][N], int b[][N]) {
    static int tmp[N][N];
    memset(tmp, 0, sizeof tmp);
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            for (int k = 0; k < N; k++)
                tmp[i][j] = (tmp[i][j] + (LL) a[i][k] * b[k][j]) % MOD;
    memcpy(c, tmp, sizeof tmp);
}

int qmi(int k, int id) {
    if (id == -1) return 0;
    int res[N][N] = {0}, w[N][N];
    memcpy(w, tr, sizeof w);
    res[0][0] = 1;

    while (k) {
        if (k & 1) mul(res, res, w);
        mul(w, w, w);
        k >>= 1;
    }
    return res[0][id];
}

int main() {
    init();
    cin >> n >> S;
    cout << qmi(n, id[stoi(S)]) << endl;
    return 0;
}

考虑 S > 2 S > 2 S>2 的情况，因为有如下关系：

  • 1：2
  • 2：4
  • 4：16
  • 6：64

对于任意一串数据，可以根据第一个数的开头数字确定它是由哪个数转移过来的，比如： 64162641664 64162641664 64162641664
在这里插入图片描述
对于任一个一数，它的构成只可能存在两种情况，比如 164 164 164在这里插入图片描述
对于中间的 6 6 6 而言，它可能和前面的 1 1 1 一起，是由上一个状态的 4 4 4 产生，也可能是和后面的 4 4 4 一起，是由上一个状态的 6 6 6 产生的。

所以对于一串数的首位而言，可能存在三种情况：

  • 首位直接匹配；
  • 首位是 4 4 4，可以在前面添加一个 6 6 6；
  • 首位是 6 6 6，可以在前面添加一个 1 1 1。

而对于末位，可能存在位不足，需要特判。比如单独留下一个 6 6 6，这种情况可以认为它的上一个状态是 6 6 6；如果单独留下一个 1 1 1，那么可以认为它的上一个状态是 4 4 4。

可以暴力枚举它的所有情况，一层层往上迭代就转换为了上面的 S = 1 、 S = 2 S = 1、S = 2 S=1、S=2 的问题。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

typedef long long LL;
const int N = 14, MOD = 998244353;

int n;
string S;
int id[100]; // 将下面14个数映射成从0开始的id
vector<int> vers{1, 2, 4, 6, 16, 26, 41, 42, 44, 46, 61, 62, 64, 66};
vector<vector<int>> g{{2}, {4}, {1, 6, 16}, {6, 4, 64}, {26}, {46}, {62}, {64}, {61}, {66}, {42}, {44}, {41}, {46}};
int tr[N][N]; // 转移矩阵

void init() {
    memset(id, -1, sizeof id);
    for (int i = 0; i < N; i++) id[vers[i]] = i;
    for (int i = 0; i < N; i++)
        for (auto x: g[i])
            tr[i][id[x]]++;
}

void mul(int c[][N], int a[][N], int b[][N]) {
    static int tmp[N][N];
    memset(tmp, 0, sizeof tmp);
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            for (int k = 0; k < N; k++)
                tmp[i][j] = (tmp[i][j] + (LL) a[i][k] * b[k][j]) % MOD;
    memcpy(c, tmp, sizeof tmp);
}

int qmi(int k, int id) {
    if (id == -1) return 0;
    int res[N][N] = {0}, w[N][N];
    memcpy(w, tr, sizeof w);
    res[0][0] = 1;

    while (k) {
        if (k & 1) mul(res, res, w);
        mul(w, w, w);
        k >>= 1;
    }
    return res[0][id];
}

string get(string str) {
    string res;
    for (int i = 0; i < str.size(); i++)
        if (str[i] == '2') res += '1';
        else if (str[i] == '4') res += '2';
        else if (str[i] == '1') {
            if (i + 1 == str.size() || str[i + 1] == '6') res += '4', i++; else return "";
        } else {
            if (i + 1 == str.size() || str[i + 1] == '4') res += '6', i++; else return "";
        }
    return res;
}

int dfs(int k, string &str) {
    if (str.size() <= 2) return qmi(k, id[stoi(str)]);
    int res = 0;
    for (string s: {"", "1", "6"}) {
        auto t = get(s + str);
        if (t.size()) res = (res + dfs(k - 1, t)) % MOD;
    }
    return res;
}

int main() {
    init();
    cin >> n >> S;
    cout << dfs(n, S) << endl;
    return 0;
}
路哞哞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CCF计算机软件能力认证试题练习：202104-3 DHCP服务器
WINGREZ‘S BLOG
05-30 4232
DHCP服务器 来源：CCF 标签： 参考资料： 相似题目： 题目 动态主机配置协议（Dynamic Host Configuration Protocol, DHCP）是一种自动为网络客户端分配 IP 地址的网络协议。当支持该协议的计算机刚刚接入网络时，它可以启动一个 DHCP 客户端程序。后者可以通过一定的网络报文交互，从 DHCP 服务器上获得 IP 地址等网络配置参数，从而能够在用户不干预的情况下，自动完成对计算机的网络设置，方便用户连接网络。DHCP 协议的工作过程如下： 当 DHCP 协议
2020 CCF 非专业级别软件能力认证第一轮(CSP-S) 提高级 C++ 语言试题
IT_Scratch的博客
09-09 928
特别地， 对于绿色的边， 红蓝双方都可以进行删除操作。每一局将从事先约定好的一方开始， 每一方轮流选择属于自己颜色的边，如果轮到某一方时， 属于他的颜色的所有的边都被。学中的一类数据结构， 为改进的二叉查找树。少皆宜的双人博弈游戏。目标结点到树根的距离(即深度)，因此当结点的深度普遍较大时，要注意的是， 合并操作会保留所有的重边， 即在上图操作后，在每小题给出的四个选项中，只有一项是符合题目要求的。为了确保该算法的结果符合预期，输入需要保证所有的。的两个端点合并为一个点后得到的新图(如图所示，
第十九次CCF CSP认证题目——线性分类器 C语言
AIMINdeCSDN的博客
08-10 1960
题目描述 解题思路 1.对于输入的坐标点使用最大数组保存。 2.对于判断A、B类点，首先根据第一个点的类别，设置分类的flag，那么对另一个类别就是对立的flag值，而设置flag的操作时原子操作，需要一次性完成。 3.对于分类的依据，是数学中的点与直线的关系，点在直线上，则带入点的坐标与直线的三个参数计算结果为0；点在直线上方则带入点的坐标与直线的三个参数计算结果大于0；点在直线的下方则带入点的坐标与直线的三个参数计算结果小于0. 源代码 #include<stdio.h>
第19次CCF计算机软件能力认证-第4题-202006-4 1246
m0_47879244的博客
10-31 208
代码取自 躺平的hhy写的文章 ![在这里插入图片描述](https://img-blog.csdnimg.cn/c9fc16bc2c0c428cb8e59c0245e3db94.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAY2bogIHmnqrmiYs=,size_20,color_FFFFFF,t_70,g_se,x_16 #include<iostream> #i
第十九次
weixin_45088679的博客
06-16 302
2、 （1)20000/40=500块 （2）选择条件是“码=值”，采用该表主索引，如果是B+树，层数为L需要存取B+树中从根结点到叶结点L块，加上基本表中该元组所在的一块，总供需要：L+1 3+1=4块 （3）嵌套循环连接算法代价估算： 容M,N分别代表R,S占用的块数 总共需要块数为：M+M*N/(K-1) 连接操作使用的内存缓冲区块数为K，分配K-1给外表，本题中没有给出K 故最终结果为：500+500x40/（K-1） （4）排序-合并连接算法代价估算： 排序好：R和S只读取一遍，20000/40+
第19次CCF计算机软件能力认证（CCF CSP认证）日程安排
Running Snail
06-01 1568
CCF总部决定将于6月28日将举办线下的csp19次认证，全国开设本次认证的一共有十所高校
第18次CCF计算机软件能力认证赛后总结
weixin_44816508的博客
01-15 701
成绩 认证经历 距离比赛结束已经整整一个月了，本来应该赛后及时总结的，但是期末事情太多，于是拖到了现在。 这是我第一次参加CCF认证，赛前也没有好好准备，大概就刷了两三道题，果然又一次认识到了自己的菜。决定假期好好刷题，好好钻研算法，再战第十九次CCF！！ 这次认证前两题都还挺简单，我都是暴力解开的，第三题化学方程式注重的字符串处理，给自己处理晕了，第四题区块链真的长出...
北航ccf计算机软件能证排名前18%,CCF成功举办第十一次CCF CSP认证
weixin_39722921的博客
07-22 1070
第十一次CCF CSP计算机软件能力认证(CSP)于2017年9月17日在全国66所院校举办，这是2017年度CCF举办的第二次认证，来自全国200多个单位的6591人参加了本次认证。通过对本次CSP结果的分析，清华、中山、北航、华中科大等在CSP300排名中名列前茅。本次CSP认证首次在高职高专院校中试点，重庆工程职业技术学院、广东科学技术职业学院、无锡职业技术学院成立了认证点，并组织学生参加了...
第七次CCF计算机软件能力认证题解
Fighting!
08-20 6209
第七次CCF计算机软件能力认证题解今天把上次CCF的题目重新做了一下… CCF链接：cspro.org折点计数问题描述 试题编号： 201604-1 试题名称： 折点计数 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 问题描述 　　给定n个整数表示一个商店连续n天的销售量。如果某天之前销售量在增长，而后一天销售量减少，则称这一天为折点，反过来如果之前销
第二十次CCF计算机软件能力认证
BeNoble_的博客
09-13 1507
A. 题意 求nnn个点中距离关键点最近的三个点。 若距离相同，则取编号小的。 3≤n≤2003\le n\le 2003≤n≤200 题解 分别记录最小值，次小值，第三小值即可。 时间复杂度O(n)O(n)O(n) #include <bits/stdc++.h> #define sqr(x) ((x) * (x)) using namespace std; typedef pair<int, int> Pii; int n; struct Point { int x, y; }
第 19 次 CCF CSP 认证 202006-1 线性分类器（line）
Running Snail
07-04 5233
这里写目录标题【题目描述】【输入格式】【输出格式】【样例 1 输入】【样例 1 输出】【样例 1 解释】【子任务】思路分析：C++代码： 【题目描述】 考虑一个简单的二分类问题——将二维平面上的点分为A 和B 两类。 训练数据包含 n 个点，其中第 i 个点（1≤i≤n）可以表示为一个三元组 (xi,yi,typei)， 即该点的横坐标、纵坐标和类别。 在二维平面上，任意一条直线可以表示为 θ0 + θ1x+ θ2y = 0 的形式，即由 θ0、θ1 和 θ2 三个参数确定该直线，且满足 θ1、θ2 不同时
Python之 if-else
Running Snail
07-01 205
当 if 语句判断表达式的结果为 True 时，就会执行 if 包含的代码块： if age >= 18: print 'adult' 如果我们想判断年龄在18岁以下时，打印出 ‘teenager’，怎么办？ 方法是再写一个 if: if age < 18: print 'teenager' 或者用 not 运算： if not age >= 18: print 'teenager' 细心的同学可以发现，这两种条件判断是“非此即彼”的，要么符合条件1，要么符合
CCF计算机软件能力认证试题练习：201712-3 Crontab
WINGREZ‘S BLOG
09-12 2801
Crontab 来源： 标签： 参考资料： 相似题目： 题目 输入 输出 输入样例 3 201711170032 201711222352 0 7 * * 1,3-5 get_up 30 23 * * Sat,Sun go_to_bed 15 12,18 * * * have_dinn...
实验8 群体类、流类库与输入/输出（4学时）
Running Snail
06-28 2767
一、 实验目的 了解链表类的定义与实现，学习其使用方法； 了解栈类的定义与实现，学习其使用方法； 了解队列类的定义与实现，学习其使用方法； 了解C++标准模板库STL的使用方法。 熟悉流类库中常用的类及其成员函数的用法。 学习标准输入输出及格式控制； 学习对文件的应用方法（二进制文件、文本文件）。 二、 实验任务 编写程序link.h实现教材中例9.6的链表类。在测试程序lab9_1.cpp中定义两个整型链表A和B，分别插入5个元素，然后把B中的元素加入A的尾部。 （题解：实验8.1 链表类的定义与实
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 873
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 634
四、实验结果。
树状数组记录
最新发布
volcan的博客
09-06 605
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 356
力扣刷题--1534. 统计好三元组【简单】
ccf计算机软件能力认证考试难度
09-21
CCF计算机软件能力认证考试是一个评估计算机软件应用能力和技术能力的考试。考试内容涵盖了计算机软件开发、算法设计、数据库管理、网络通信等多个领域。难度方面，考试可以说是比较困难的。 首先，考试题目的设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值