Codeforces红名选手jiangly的5个代码习惯，让你的算法竞赛代码更专业

Codeforces红名选手jiangly的5个代码习惯，让你的算法竞赛代码更专业

在算法竞赛的世界里，代码不仅是解决问题的工具，更是选手思维方式的直接体现。作为Codeforces历史上首位突破4000分大关的传奇选手，jiangly的代码风格一直被全球竞赛选手奉为圭臬。本文将深入剖析他代码中五个最具代表性的习惯，这些习惯看似简单，却能显著提升代码的可读性、调试效率和运行性能。

1. 类型命名的语义化革命：告别模糊的ll

传统竞赛代码中常见这样的类型定义：

typedef long long ll;

而jiangly的代码中，你会看到：

using i64 = long long; using u64 = unsigned long long; using u32 = unsigned;

这种命名方式的优势在于：

• 类型信息一目了然：i64明确表示64位有符号整数，u32表示32位无符号整数
• 避免隐式类型转换错误：不同位宽的整数混用时编译器会给出警告
• 便于平台迁移：当需要调整整数大小时只需修改一处定义

实际比赛中，清晰的类型命名能帮助你在紧张的调试中快速定位溢出错误。例如处理大数乘法时：

i64 a = 1e18, b = 1e18; i64 c = a * b; // 明显会有溢出风险

2. 空格规范：代码呼吸的艺术

对比两种代码风格：

for(int i=0;i<n;i++){...} // 紧凑但易读性差

for (int i = 0; i < n; i++) { ... } // jiangly风格

jiangly的空格规范包括：

• 运算符两侧保留空格：a = b + c而非a=b+c
• 控制语句与括号间留空：if (condition)而非if(condition)
• 逗号后留空：func(a, b, c)而非func(a,b,c)
• 代码块间空行分隔逻辑单元

这种风格虽然略微增加代码长度，但在以下场景优势明显：

• 快速视觉定位：在200+行的代码中能迅速找到关键逻辑段
• 减少拼写错误：a==b与a = b的差异更易辨认
• 团队协作友好：统一的格式降低合并冲突概率

3. STL的极致运用：从vector到array

观察jiangly的典型代码片段：

std::vector<std::array<int, 2>> edges; std::sort(edges.begin(), edges.end());

他偏好STL容器的原因在于：

1. 内存安全性：自动管理生命周期，避免内存泄漏
2. 算法兼容性：可直接用于std::sort、std::lower_bound等
3. 调试便利性：GDB等调试器能友好显示STL容器内容

特别值得注意的是他对std::array的使用：

std::array<int, 3> point{1, 2, 3}; // 替代原始数组

与原始数组相比的优势：

4. 输入输出优化：速度与安全的平衡

jiangly的典型main函数结构：

int main() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); // 解决函数调用 }

这两行代码的作用：

1. sync_with_stdio(false)：禁用C与C++流同步，提升输入速度
2. cin.tie(nullptr)：解绑cin与cout，进一步加速

性能对比测试：

注意：使用此优化后不可混用C风格(printf)与C++风格(cout)IO

5. 函数式编程思维：避免全局状态污染

对比两种代码组织方式：

// 传统方式 int a[N], ans; void solve() { // 直接修改全局变量 }

// jiangly风格 int solve(const std::vector<int>& input) { int res = 0; // 纯函数计算 return res; }

函数式风格的优势：

• 可测试性强：每个函数都是独立的测试单元
• 避免竞态条件：多线程环境下更安全
• 代码复用率高：函数不依赖外部状态
• 调试更简单：输入输出关系明确

典型应用场景——DFS实现：

void dfs(int u, const std::vector<std::vector<int>>& adj, std::vector<bool>& visited, std::vector<int>& result) { visited[u] = true; result.push_back(u); for (int v : adj[u]) { if (!visited[v]) { dfs(v, adj, visited, result); } } }

实战演练：jiangly风格代码重构

让我们用一个具体问题展示这些习惯的综合应用。考虑Codeforces典型问题：给定数组，求所有子数组最大值的和。

传统写法：

#include<bits/stdc++.h> #define ll long long using namespace std; const int N=1e5+5; int a[N],L[N],R[N],n; ll ans; int main(){ cin>>n; for(int i=1;i<=n;i++)cin>>a[i]; stack<int>s; for(int i=1;i<=n;i++){ while(!s.empty()&&a[s.top()]<a[i])s.pop(); L[i]=s.empty()?0:s.top(); s.push(i); } //...类似处理R数组 for(int i=1;i<=n;i++) ans+=1LL*a[i]*(i-L[i])*(R[i]-i); cout<<ans; return 0; }

jiangly风格重构：

#include <bits/stdc++.h> using i64 = long long; std::vector<int> compute_boundaries(const std::vector<int>& nums, bool left) { std::vector<int> res(nums.size()); std::stack<int> stk; const int n = nums.size(); const auto& cmp = left ? std::less<>() : std::less_equal<>(); for (int i = 0; i < n; ++i) { while (!stk.empty() && cmp(nums[stk.top()], nums[i])) { stk.pop(); } res[i] = stk.empty() ? -1 : stk.top(); stk.push(i); } return res; } i64 solve(const std::vector<int>& nums) { const auto left = compute_boundaries(nums, true); const auto right = compute_boundaries(nums, false); i64 res = 0; for (int i = 0; i < nums.size(); ++i) { i64 l = i - left[i]; i64 r = right[i] - i; res += nums[i] * l * r; } return res; } int main() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); int n; std::cin >> n; std::vector<int> nums(n); for (int i = 0; i < n; ++i) { std::cin >> nums[i]; } std::cout << solve(nums) << "\n"; return 0; }

重构后的改进点：

1. 使用std::vector替代原始数组
2. 提取通用逻辑到compute_boundaries函数
3. 使用函数对象std::less<>实现方向控制
4. 严格的类型区分i64与int
5. 清晰的空格和缩进规范

这些习惯的养成需要刻意练习，但一旦掌握，你的代码将拥有竞赛高手特有的"干净利落"特质。记住，优秀的竞赛代码不仅是给机器执行的指令，更是给其他程序员（包括未来的自己）阅读的故事。