CCF-CSP第38次认证第三题——消息解码（满分题解）

已于 2025-08-30 02:24:39 修改
阅读量780 收藏 6
点赞数 21
CC 4.0 BY-SA版权
分类专栏： CCF-CSP 文章标签： 算法 CCF CSP c++ 消息解码 第三题 38
于 2025-08-29 23:30:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2501_92845263/article/details/150998468

官网链接TUOJ

题解

快写吐了，一堆小细节。

除2和乘2可以直接使用位运算。

总流程

输入：n

  1. 复杂消息：
    1. 代号：先转化成数字，再根据数字表示转化为原字符。
    2. 12位散列值：转化为数字，根据哈希判断是否存在对应字符串。
    3. 收发标志：决定发送方和接收方。
    4. 将代号转化为12位和25位散列值（先计算字符的数字表示，再计算其散列值），存入哈希表（这一步要最后做）。
  2. 简单消息
    1. 接收方代号：
      1. 大于2的25次方，先减去2的25次方，再根据短数字表示计算原字符串（短字符很坑，需要特殊考虑“00AXX”的情况，因为第一位为0表示空格，第二位为0表示“0”，后几位同理）
      2. 小于2的25次方，转化为数字，根据哈希判断是否存在对应字符串。
      3. 将代号转化为12位和25位散列值，存入哈希表（这一步要先做）。
    2. 发送方代号：同上。
    3. 位置编号：转化为数字，注意为0的时候不需要输出。

相关函数

qmi：快速幂，计算a的b次方，直接循环计算应该也可以。

change：将01字符串转化为整数。

sh：short短数字表示，将数字转化为字符串。

ha：计算散列值。

sanlie：根据散列值进行查询。

num：计算出字符的数字表示。

solve0：简单消息处理主函数。

solve11：复杂消息代号处理主函数。

solve12：复杂消息12位散列值处理主函数。

代码

有注释版本（ai注释）

#include<bits/stdc++.h>
using namespace std;

typedef unsigned long long ll;

int n;                     // 数据组数
ll c25 = 33554432;         // 2^25，用来判断 28 位 01 串是否 >= 2^25
string dat;                // 每次读入的一整行字符串
unordered_map<ll,string> mp12, mp25;   // 哈希表：key 为 12/25 位哈希值，value 为压缩后的串

/* 快速幂：base^m，用来算 38^k */
ll qmi(ll base,ll m){
    ll res = 1;
    for(; m; m /= 2, base *= base)
        if(m & 1) res *= base;
    return res;
}

/* 把 01 串转成十进制整数 */
ll change(string s){
    ll res = 0, base = 1;
    for(int i = s.size() - 1; i >= 0; i--){
        if(s[i] == '1') res += base;
        base *= 2;
    }
    return res;
}

/* 把整数 hash 映射成 3~5 位的“短码”：先字母后数字再混合 */
string sh(ll hash){
    string res;
    ll op;
    /* 3 个大写字母 */
    for(int i = 0; i < 3; i++){
        op = hash % 26;
        res += (char)(op + 'A');
        hash /= 26;
    }
    /* 1 位数字 */
    if(hash > 0){
        op = hash % 10;
        res += (char)(op + '0');
        hash /= 10;
    }else res += '0';
    /* 1 位 0-9/A-Z */
    if(hash > 0){
        op = hash % 36;
        if(op <= 9) res += (char)(op + '0');
        else        res += (char)(op + 'A' - 10);
        hash /= 36;
    }else res += '0';
    /* 可能再补 1 位 */
    if(hash > 0){
        op = hash;
        if(op != 0){
            if(op <= 10) res += (char)(op + '0' - 1);
            else         res += (char)(op - 11 + 'A');
        }
    }
    reverse(res.begin(), res.end());
    return res;
}

/* 把一个整数 hash 再映射到 0~(2^base-1) 的更小哈希值（高位截取）*/
ll ha(ll op, ll base){
    return op * 47055833459ULL >> (64 - base);
}

/* 根据哈希值去表里查，找不到返回 "###" */
string sanlie(ll hash, ll base){
    if(base == 25){
        if(mp25.count(hash)) return "#" + mp25[hash];
        else return "###";
    }else{
        if(mp12.count(hash)) return "#" + mp12[hash];
        else return "###";
    }
}

/* 把 10 位 38 进制串（含数字、字母、_）再转回整数 */
ll num(string s){
    ll res = 0, base = qmi(38, 10);
    for(int i = 0; i < s.size(); i++){
        if(isdigit(s[i]))         res += base * (s[i] - '0' + 1);
        else if(s[i] == '_')      res += base * 37;
        else                      res += base * (s[i] - 'A' + 11);
        base /= 38;
    }
    return res;
}

/* 28 位 01 串 -> 压缩串 */
string solve0(string s){
    ll hash = change(s);
    if(hash >= c25){                       // >= 2^25 走 11 位
        hash -= c25;
        string s1 = sh(hash);              // 先映射成 3~5 位短码
        hash = num(s1);                    // 再转成 38 进制整数
        mp12[ha(hash, 12)] = s1;           // 填两张哈希表
        mp25[ha(hash, 25)] = s1;
        return s1;
    }else{
        return sanlie(hash, 25);           // 直接查 25 位哈希
    }
}

/* 58 位 01 串 -> 11 位 38 进制串（带 _） */
string solve11(string s){
    ll x = change(s), op;
    string res;
    for(int i = 0; i < 11; i++){
        op = x % 38;
        if(op != 0){
            if(op <= 10) res += (char)(op + '0' - 1);
            else if(op <= 36) res += (char)(op + 'A' - 11);
            else res += '_';
        }
        x /= 38;
    }
    reverse(res.begin(), res.end());
    ll hash = num(res);        // 再算一次 38 进制整数
    mp12[ha(hash, 12)] = res;  // 填两张哈希表
    mp25[ha(hash, 25)] = res;
    return res;
}

/* 12 位 01 串 -> 查表返回 */
string solve12(string s){
    ll hash = change(s);
    if(mp12.count(hash)) return '#' + mp12[hash];
    else return "###";
}

int main(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> dat;
        string s1, s2, s;
        if(dat[0] == '0'){                        // 类型 0
            s1 = solve0(dat.substr(1, 28));       // 前 28 位
            s2 = solve0(dat.substr(29, 28));      // 中 28 位
            ll pos = change(dat.substr(57, 15));  // 后 15 位
            if(pos != 0) cout << s1 << ' ' << s2 << ' ' << pos << endl;
            else         cout << s1 << ' ' << s2 << endl;
        }else{                                    // 类型 1
            s2 = solve12(dat.substr(59, 12));     // 后 12 位
            s1 = solve11(dat.substr(1, 58));      // 前 58 位
            if(dat[71] == '0') swap(s1, s2);      // 最后一位决定顺序
            cout << s1 << ' ' << s2 << endl;
        }
    }
}

无注释版本

#include<bits/stdc++.h>

using namespace std;

typedef unsigned long long ll;

int n;
ll c25=33554432;
string dat;
unordered_map<ll,string>mp12,mp25;

ll qmi(ll base,ll m){
    ll res=1;
    for(;m;m/=2,base*=base)
        if(m&1)res*=base;
    return res;
}

ll change(string s){
    ll res=0,base=1;
    for(int i=s.size()-1;i>=0;i--){
        if(s[i]=='1')res+=base;
        base*=2;
    }
    return res;
}

string sh(ll hash){
    string res;
    ll op;
    for(int i=0;i<3;i++){
        op=hash%26;
        res+=(char)(op+'A');
        hash/=26;
    }
    if(hash>0){
        op=hash%10;
        res+=(char)(op+'0');
        hash/=10;
    }else res+='0';
    if(hash>0){
        op=hash%36;
        if(op<=9)res+=(char)(op+'0');
        else res+=(char)(op+'A'-10);
        hash/=36;
    }else res+='0';
    if(hash>0){
        op=hash;
        if(op!=0)
            if(op<=10)res+=(char)(op+'0'-1);
            else res+=(char)(op-11+'A');
    }
    reverse(res.begin(),res.end());
    return res;
}

ll ha(ll op,ll base){
    return op*47055833459>>(64-base);
}

string sanlie(ll hash,ll base){
    if(base==25){
        if(mp25.count(hash))return "#"+mp25[hash];
        else return "###";
    }else{
        if(mp12.count(hash))return "#"+mp12[hash];
        else return "###";
    }
}

ll num(string s){
    ll res=0,base=qmi(38,10);
    int cnt=0;
    for(int i=0;i<s.size();i++){
        if(isdigit(s[i]))res+=base*(s[i]-'0'+1);
        else if(s[i]=='_')res+=base*37;
        else res+=base*(s[i]-'A'+11);
        base/=38;
    }
    return res;
}

string solve0(string s){
    ll hash=change(s);
    if(hash>=c25){
        hash-=c25;
        string s1=sh(hash);
        hash=num(s1);
        mp12[ha(hash,12)]=s1;
        mp25[ha(hash,25)]=s1;
        return s1;
    }else{
        return sanlie(hash,25);
    }
}

string solve11(string s){
    ll x=change(s),op;
    string res;
    for(int i=0;i<11;i++){
        op=x%38;
        if(op!=0){
            if(op<=10)res+=(char)(op+'0'-1);
            else if(op<=36)res+=(char)(op+'A'-11);
            else res+='_';
        }
        x/=38;
    }
    reverse(res.begin(),res.end());
    ll hash=num(res);
    mp12[ha(hash,12)]=res;
    mp25[ha(hash,25)]=res;
    return res;
}

string solve12(string s){
    ll hash=change(s);
    if(mp12.count(hash))return '#'+mp12[hash];
    else return "###";
}

int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>dat;
        string s1,s2,s;
        if(dat[0]=='0'){
            s1=solve0(dat.substr(1,28));
            s2=solve0(dat.substr(29,28));
            ll pos=change(dat.substr(57,15));
            if(pos!=0)cout<<s1<<' '<<s2<<' '<<pos<<endl;
            else cout<<s1<<' '<<s2<<endl;
        }else{
            s2=solve12(dat.substr(59,12));
            s1=solve11(dat.substr(1,58));
            if(dat[71]=='0')swap(s1,s2);
            cout<<s1<<' '<<s2<<endl;
        }
    }
}

                

 

第34次CCF-CSP认证考试 第二题 矩阵重塑（其二）满分题解
qq_75242106的博客
09-13 3046
第二题的难度较大，我们还是延续之前的作风，要使用简单，易理解的语句和知识解决。由于题目难度较大，所以解释部分会比较多。下面开始问题分析。
第32次CCF-CSP认证考试 第二题 因子化简 满分题解
qq_75242106的博客
09-21 932
用基础知识解决第32次CCF-CSP认证考试 第二题 因子化简
CCF-CSP真题202212-3JPEG解码(Java满分题解)
m0_74172965的博客
11-12 354
本题来自2022年12月CCF-CSP真题中第三题《JPEG解码》。
CCF-CSP真题《202212-3 JPEG 解码》思路+python，c++满分题解
weixin_53919192的博客
03-14 7270
本文为大家提供了《202212-3 JPEG 解码》的解题代码，希望对你有帮助~~
ccf-csp历年满分题解 + 考点汇总 + 经验总结 + 常用代码模板（已完成63题，持续更新中...）
一只可爱的小猴子的博客
03-07 6741
3. 当题目中没有过多的说明某个操作或数据可能出现的情况，但确实可能会出现递归处理等情况，可以先不考虑递归的情况，后续实在没有其他错误的时候，再来修改这个操作的处理情况（比如说，这道题目中，cancel这个记录有没有可能操作的是一条cancel记录，出现递归的情况，但是。1. 有的时候不要把题目想的太难了，我记得很久之前做这道题目的时候写的很复杂，其实想清楚整个过程或者想一个简单点的思路，好像并没有那么难啊，也不知道当时是怎么想的，总之，2. memcpy(dist, src, sizeof(src));
202212-3 CCF JPEG 解码 满分题解（超详细注释代码） + 两种解题思路（z字形模拟 / 打表法）
一只可爱的小猴子的博客
03-16 1379
解题思路用图表示，清晰易懂。
第28次csp认证T3 JPEG 解码解析
Sunnyztg的博客
03-13 997
第28次csp认证T3 JPEG 解码解析
CCF-CSP 试题考前练习（Python实时更新~）注释超详细
qq_53809201的博客
02-16 1710
CCF CSP 考前练习，实时更新
CCF CSP题解：解压缩（202305-3）
曹无悔的博客
09-03 715
CCF CSP考试题《解压缩》的满分题解。
【202303-2】CSP 第三题JPEG解码python满分代码
m0_51532123的博客
05-24 100
题解
CCF-CSP认证考试历年真题
03-31
ccfcsp历年考试真题解答 不含答案
第34次CCF-CSP认证考试 第一题 矩阵重塑（其一） 满分题解
qq_75242106的博客
09-11 2307
第34次CCF-CSP认证考试 第一题 矩阵重塑（其一） 满分题解
第33次CCF-CSP认证考试 第一题 词频统计 满分题解
qq_75242106的博客
09-08 1530
本人小白一枚，抱着学习的态度想到网上找一些csp的参考答案，但由于实力有限，大佬的代码大都看不太懂，于是萌生了想用一些简单，基础的语句完成csp前两题的想法并公开，以便与像我这样实力不强的同学交流学习，如有更好的建议，还请斧正，感谢！
常见排序算法及Java实现
xike1024的博客
08-27 1027
常见排序算法及Java代码实现
数据结构（一）：算法的时间复杂度和空间复杂度
Larry的博客
08-26 505
本文围绕算法效率展开，先指出衡量算法好坏需从时间和空间复杂度入手，早期关注空间复杂度，如今更侧重时间复杂度。时间复杂度用大 O 渐进表示法，通过去除无关项简化执行次数描述，还提及最坏、平均、最好情况，通常关注最坏情况，并举例计算 8 类常见算法的时间复杂度。空间复杂度聚焦临时额外空间，也用大 O 表示法，分析 3 个实例。此外，对比常见复杂度阶，进阶介绍均摊复杂度、递归复杂度与深度的关联，以及工程中复杂度的实际权衡，为算法设计与优化提供参考。
SM4加密算法
简单点的博客
08-27 327
SM4加密算法
北斗导航 | RAIM算法改进方案及性能对比分析报告
最新发布
尘世冰封的专栏
08-30 341
多假设分组算法通过构建卫星子集组合实现故障检测与隔离，核心原理是将可见卫星划分为多个假设子集，对每个子集进行定位解算并比较结果一致性。
二分查找算法题（持续更新）
2301_79482961的博客
08-27 281
/求左端点while(left < right){ //细节一//细节2}else{}else{//求右端点//细节三left = mid;}else{
基于NXP iMXRT600音频算法开发方法
2401_89373706的博客
08-27 473
iMXRT600音频算法开发指南摘要： 环境搭建：准备iMXRT600开发板及音频I/O接口，安装MCUXpresso IDE和SDK工具包。 音频基础：掌握采样率、位数及PCM编码格式，合理配置参数。 数据采集与输出：通过I2S接口实现音频输入（麦克风）和输出（扬声器）功能。 算法开发：从基础音量调节到复杂算法（如降噪），可借助Speex等开源库优化移植。 调试优化：利用IDE调试工具验证功能，优化算法效率以降低CPU负载。 测试验证：通过Audacity等工具测试兼容性与稳定性，覆盖不同采样参数和设备。
CCF-CSP第35次认证第三题
04-03
### CCF-CSP 第35次认证第三题的题目分析与解法 关于CCF-CSP第35次认证中的第三题，目前公开的具体题目描述尚未广泛传播于网络资源中[^1]。然而，基于以往CSP认证的特点以及考生反馈的信息，可以推测该类题目通常考察的是编程基础能力和逻辑思维能力[^2]。 #### 可能涉及的知识点 此类题目往往围绕以下几个方面展开： - **数据结构**：如数组、链表、栈、队列等基本操作。 - **算法设计**：包括但不限于贪心算法、动态规划、二分查找等常见方法。 - **字符串处理**：对于输入输出格式的要求较高，需注意边界条件和特殊情况下的行为。 下面给出一个假设性的例子来说明如何解答类似的竞赛问题： 假定本题是一个简单的区间覆盖或者路径优化问题，则解决方案如下所示: ```cpp #include <bits/stdc++.++.h> using namespace std; int main(){ int n; cin >> n; // 输入n表示有多少个区域或节点 vector<pair<int, int>> intervals(n); for(auto &p : intervals){ cin >> p.first >> p.second; // 每组两个数代表起点终点坐标 } sort(intervals.begin(), intervals.end()); long long res = 0; int last_end = INT_MIN; for(const auto &[start,end]:intervals){ if(start>last_end){ res += end-start; last_end=end; } else{ if(end>=last_end){ res+=end-last_end; last_end=end; } } } cout<<res<<endl;// 输出最终结果即总长度或其他目标函数值 } ``` 上述代码片段展示了当面对连续区间的合并计算时的一种通用策略——通过排序并遍历所有给定区间实现最优求解过程[^3]。 #### 注意事项 在参加正式比赛前务必熟悉评测环境配置参数限制情况(时间复杂度O()要求)，同时也要关注细节部分比如是否有负权边存在等问题影响到具体实现方式的选择上。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值