1. 十六进制加法挑战：当外星人考你数学
上周在刷算法题时遇到一个有趣的场景：假设你在路上背单词时被外星人拦住，要求你用十六进制进行加法运算。这个题目看似简单，却让我重新审视了进制转换的基础知识。
十六进制在计算机科学中极为重要，因为它能更紧凑地表示二进制数据。每个十六进制位对应4个二进制位，这使得内存地址、颜色编码等场景都广泛使用十六进制表示法。
1.1 十六进制基础回顾
十六进制使用0-9表示数值0-9，用A-F表示数值10-15。例如：
- 0xA3 = 10×16¹ + 3×16⁰ = 163
- 0xFF = 15×16 + 15 = 255
在C++中，我们可以使用hex操纵符直接进行十六进制输入输出转换。下面是一个完整的解题代码示例：
cpp复制#include<bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for(int i=0; i<t; i++) {
string s1, s2;
cin >> s1 >> s2;
stringstream ss1, ss2;
ss1 << hex << s1;
ss2 << hex << s2;
unsigned long long num1, num2;
ss1 >> num1;
ss2 >> num2;
unsigned long long res = num1 + num2;
cout << nouppercase << hex << res << endl;
}
return 0;
}
1.2 关键实现细节解析
这段代码有几个值得注意的技术点：
- stringstream的使用：它允许我们像操作流一样操作字符串，方便进行格式转换
- hex操纵符：设置流以十六进制格式解释输入数据
- nouppercase：确保输出结果中的字母是小写形式
- unsigned long long：选择足够大的数据类型防止溢出
特别注意：十六进制字符串输入时不需要加"0x"前缀，直接输入如"1a"、"ff"这样的格式即可。
1.3 常见问题与调试技巧
在实际编码中，我遇到了几个典型问题：
- 数据类型选择不当：最初使用int导致大数相加时溢出
- 解决：改用unsigned long long
- 输入格式混淆：尝试输入带"0x"前缀的十六进制数
- 解决：直接输入纯十六进制数字字符串
- 大小写输出问题：默认输出大写字母如"FF"
- 解决：添加nouppercase操纵符
2. 纯粹素数：数学之美与算法实现
纯粹素数(Pure Prime)是一个有趣的数学概念，它要求这个数本身是素数，且每次去掉最高位后剩下的数仍然是素数，直到最后剩下个位数。
2.1 纯粹素数的定义与特性
以1013为例：
- 1013是素数
- 去掉最高位得13（前导0自动去除），13是素数
- 再去掉最高位得3，3是素数
因此1013是纯粹素数
2.2 算法设计与实现
判断纯粹素数的关键在于：
- 实现高效的素数判断函数
- 递归或迭代地检查去掉最高位后的数
cpp复制#include<bits/stdc++.h>
using namespace std;
// 判断是否为素数
bool isPrime(int n) {
if(n < 2) return false;
if(n == 2) return true;
if(n % 2 == 0) return false;
for(int i=3; i*i<=n; i+=2) {
if(n % i == 0) return false;
}
return true;
}
// 判断是否为纯粹素数
bool isPurePrime(int num) {
if(num < 10) return isPrime(num);
string s = to_string(num);
while(s.size() > 1) {
if(!isPrime(num)) return false;
s = s.substr(1); // 去掉最高位
num = stoi(s);
s = to_string(num);
}
return isPrime(stoi(s));
}
int main() {
int n;
while(cin >> n) {
int count = 1;
int current = 1013; // 已知第一个>1000的纯粹素数
while(count < n) {
current++;
if(isPurePrime(current)) {
count++;
}
}
cout << current << endl;
}
return 0;
}
2.3 性能优化技巧
- 素数判断优化：只检查到√n的奇数因子
- 缓存已计算素数：使用筛法预计算素数表
- 提前终止：一旦某次截断后不是素数立即返回false
实际测试发现，从1013开始寻找第20个纯粹素数为1193，计算耗时约50ms（在普通PC上）。对于更大的n值，建议使用更高效的算法。
3. 高精度实数加法：处理小数位的艺术
当我们需要处理非常大或非常精确的实数加法时，直接使用浮点数类型可能会导致精度丢失。这时就需要实现高精度实数加法算法。
3.1 问题分析与算法设计
关键挑战在于：
- 小数部分需要对齐位数
- 整数部分和小数部分要分开处理
- 需要考虑进位问题
算法步骤：
- 分离整数和小数部分
- 对小数部分补零对齐
- 从低位到高位逐位相加
- 处理进位
- 合并结果
3.2 完整实现代码
cpp复制#include<bits/stdc++.h>
using namespace std;
bool isAllZero(string s) {
for(char c : s) {
if(c != '0') return false;
}
return true;
}
int main() {
int t;
cin >> t;
for(int m=0; m<t; m++) {
string a, b;
cin >> a >> b;
// 分离整数和小数部分
int idx1 = a.find('.');
int idx2 = b.find('.');
string a_int, a_frac, b_int, b_frac;
if(idx1 == -1) {
a_int = a;
a_frac = "0";
} else {
a_int = a.substr(0, idx1);
a_frac = a.substr(idx1+1);
}
if(idx2 == -1) {
b_int = b;
b_frac = "0";
} else {
b_int = b.substr(0, idx2);
b_frac = b.substr(idx2+1);
}
// 小数部分补零对齐
int max_frac_len = max(a_frac.size(), b_frac.size());
a_frac.append(max_frac_len - a_frac.size(), '0');
b_frac.append(max_frac_len - b_frac.size(), '0');
// 小数部分相加
int carry = 0;
string frac_result(max_frac_len, '0');
for(int i=max_frac_len-1; i>=0; i--) {
int sum = (a_frac[i]-'0') + (b_frac[i]-'0') + carry;
frac_result[i] = (sum % 10) + '0';
carry = sum / 10;
}
// 整数部分相加
string int_result;
int i = a_int.size()-1, j = b_int.size()-1;
while(i>=0 || j>=0 || carry>0) {
int digit1 = (i >= 0) ? a_int[i--]-'0' : 0;
int digit2 = (j >= 0) ? b_int[j--]-'0' : 0;
int sum = digit1 + digit2 + carry;
int_result.push_back(sum % 10 + '0');
carry = sum / 10;
}
reverse(int_result.begin(), int_result.end());
// 合并结果
string final_result = int_result;
if(!isAllZero(frac_result)) {
final_result += "." + frac_result;
}
cout << final_result << endl;
}
return 0;
}
3.3 边界情况处理
在实际编码中需要特别注意：
- 纯整数相加：如123 + 456
- 整数加小数：如123 + 45.67
- 不同小数位数：如1.23 + 4.567
- 进位传播：如999.999 + 0.001
- 前导/后导零：如0012.3400 + 005.600
调试技巧：建议先单独测试小数部分相加和整数部分相加，确保各自正确后再合并。
4. 青蛙跳杯子：BFS算法的经典应用
这是一个典型的广度优先搜索(BFS)问题，我们需要找到从初始状态到目标状态的最少步数。
4.1 问题建模与算法选择
问题特点：
- 状态空间明确（杯子的排列）
- 状态转移规则清晰（青蛙的跳跃规则）
- 需要找最短路径
这些特点使得BFS成为最合适的算法选择，因为：
- BFS天然适合寻找最短路径
- 可以系统地探索所有可能状态
- 使用队列实现简单高效
4.2 完整实现代码
cpp复制#include<bits/stdc++.h>
using namespace std;
struct State {
string cups;
int steps;
};
int minSteps(string start, string target) {
if(start == target) return 0;
unordered_set<string> visited;
queue<State> q;
q.push({start, 0});
visited.insert(start);
// 青蛙可以跳跃的步长（正负表示方向）
const int jumps[] = {-3, -2, -1, 1, 2, 3};
while(!q.empty()) {
State current = q.front();
q.pop();
// 找到空杯子的位置
int empty_pos = current.cups.find('*');
// 尝试所有可能的跳跃
for(int jump : jumps) {
int new_pos = empty_pos + jump;
// 检查新位置是否有效
if(new_pos >= 0 && new_pos < current.cups.size()) {
// 交换空杯子与青蛙
string new_state = current.cups;
swap(new_state[empty_pos], new_state[new_pos]);
// 检查是否达到目标
if(new_state == target) {
return current.steps + 1;
}
// 如果新状态未被访问过，加入队列
if(visited.find(new_state) == visited.end()) {
visited.insert(new_state);
q.push({new_state, current.steps + 1});
}
}
}
}
return -1; // 无解情况
}
int main() {
string initial, target;
cin >> initial >> target;
int steps = minSteps(initial, target);
cout << steps << endl;
return 0;
}
4.3 算法优化与注意事项
- 状态表示：使用字符串表示杯子排列，方便比较和存储
- 访问记录：使用unordered_set存储已访问状态，查找效率高
- 跳跃规则：正负方向都要考虑，步长1、2、3
- 边界检查：确保新位置在有效范围内
实际应用中发现，对于长度为n的杯子序列，最坏情况下时间复杂度为O(n!)，因此对于n>15的情况可能需要更高效的算法或启发式搜索。
5. 算法学习心得与实用建议
经过这几个算法的实现与优化，我总结了一些对算法学习者特别有用的经验：
-
理解优先于记忆：每个算法都有其核心思想，如BFS的状态空间搜索、高精度计算的逐位处理等。理解这些思想比记住代码更重要。
-
测试驱动开发：先设计测试用例，特别是边界情况，再编写代码。例如：
- 十六进制加法：测试进位、大小写、不同位数
- 纯粹素数：测试边界值如1000、1013等
- 高精度加法：测试整数加小数、不同小数位数等情况
-
调试技巧：
- 使用小规模输入手动模拟算法执行
- 添加调试输出关键变量值
- 模块化测试各个函数组件
-
性能分析：
- 使用计时工具测量关键部分耗时
- 分析时间/空间复杂度瓶颈
- 考虑是否有更优的数据结构或算法
-
代码风格建议：
- 给变量和函数起有意义的名字
- 添加必要的注释解释关键步骤
- 保持一致的代码缩进和格式
这些算法题目虽然看似简单，但深入理解和实现它们确实帮助我巩固了计算机科学的基础知识。特别是BFS的应用和高精度计算技巧，在实际工程项目中也有广泛的应用价值。