1. 从零开始：理解二维数组与矩阵的“坐标世界”
很多刚开始接触编程的朋友，一看到“二维数组”和“矩阵”这两个词，心里可能就有点发怵，觉得这是数学大神才玩得转的东西。其实不然，你可以把它想象成一个非常直观的“棋盘”或者“Excel表格”。我在最初学习的时候，也花了点时间才把行和列的下标关系理顺，一旦开窍了，后面的一切都会变得非常简单。
在C++里，我们通常用int matrix[10][10];这样的形式来声明一个10行10列的整数矩阵。这里最关键的是要建立“坐标”思维。matrix[i][j]这个元素，它的“地址”由两个数字决定：第一个下标i代表它在第几行（从0开始数），第二个下标j代表它在第几列。比如matrix[2][3]，就是指第3行、第4列的那个格子（因为从0开始计数）。这个思维模式是后续所有操作的基础，无论是遍历、求和还是旋转，本质上都是在和这些(i, j)坐标玩游戏。
为什么对角线遍历和矩阵旋转这么重要呢？这可不是为了应付考试。在我做过的很多项目中，比如图像处理的基本操作（旋转一张图片）、游戏开发中的地图数据处理（比如45度角斜视角地图的渲染），甚至是机器学习里数据预处理时的特征矩阵变换，都离不开这些操作。理解并熟练运用它们，能让你在面对这类问题时，不再去网上盲目搜索代码，而是自己心里有谱，能清晰地分析出坐标变化的规律，然后写出高效、准确的代码。接下来，我们就从最简单的对角线求和开始，一步步拆解这里面的门道。
2. 深入核心：对角线遍历的多种姿势与实战
对角线遍历听起来好像就一种，无非是从左上角到右下角。但实际玩起来，你会发现这里面花样不少：主对角线、副对角线、甚至是从任意点出发的斜线。掌握它们的关键，在于发现下标i和j之间那个美妙的数学关系。
2.1 主对角线求和：当行号等于列号
主对角线是最简单的一条，就是从矩阵左上角[0][0]拉到右下角[n-1][n-1]的那条线。这条线上的元素有个共同特点：它们的行索引i和列索引j相等。所以，求主对角线和就是找所有i == j的位置。
int sumPrimary = 0; for (int i = 0; i < n; ++i) { sumPrimary += matrix[i][i]; // 直接利用 i == j 的关系 }这段代码非常直观，一次循环搞定。但这里我想分享一个我早期踩过的坑：边界判断。如果矩阵不是方阵（行数和列数不等），主对角线怎么定义？通常我们会以较短的那条边为准。所以更健壮的写法可能是for (int i = 0; i < min(rows, cols); ++i)。虽然题目常给方阵，但养成考虑边界的习惯很重要。
2.2 副对角线求和：发现 i + j 的恒定秘密
副对角线（也叫反对角线）是从右上角到左下角。它的规律比主对角线稍微绕一点，但同样简洁：这条线上所有元素的行列索引之和是常数，且等于n-1（对于n阶方阵）。也就是说，满足i + j == n - 1。
原始文章里给出的求副对角线和代码，用了两层循环遍历所有元素再判断条件：
for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { if(i + j == n - 1) { cnt += a[i][j]; } } }这种方法当然正确，但效率不是最优的，因为它遍历了所有n*n个元素。我们可以更聪明一点，直接遍历行i，那么列j就等于n - 1 - i，这样只需要n次计算：
int sumSecondary = 0; for (int i = 0; i < n; ++i) { int j = n - 1 - i; // 根据关系直接算出列号 sumSecondary += matrix[i][j]; }两种方法结果一样，但后者的思路更体现了我们对坐标关系的深刻理解，在性能上也更优。在实际编程中，这种从“暴力判断”到“直接计算”的思维转变，是算法能力提升的一个标志。
2.3 任意斜线遍历：从“同行列对角线格子”问题进阶
“同行列对角线格子”这个问题非常好，它把我们带向了更一般的场景：给定矩阵中任意一个点(x, y)，如何找出它所在的所有对角线上的格子？
这需要我们把问题拆解成两条不同的对角线：
- 从左上到右下的对角线（主对角线方向）：这条线上的点，行索引和列索引的差值
i - j是恒定的。对于给定点(r, c)，这个恒定值就是r - c。所以，要找出这条线上所有点，我们可以让i和j同时增加，保持i - j == r - c这个关系。 - 从左下到右上的对角线（副对角线方向）：这条线上的点，行索引和列索引的和
i + j是恒定的。对于给定点(r, c)，这个恒定值就是r + c。要找出这些点，可以让i减少、j增加（或反之），保持i + j == r + c。
理解了这个，我们就能写出更清晰、更通用的代码。下面是一个改进的实现思路，避免了原始代码中复杂的起点调整计算：
int n, r, c; cin >> n >> r >> c; // 注意：题目输入的行列号通常从1开始，我们先转为从0开始的索引 r--; c--; // 1. 输出同一行 for (int j = 0; j < n; ++j) cout << "(" << r+1 << "," << j+1 << ") "; cout << endl; // 2. 输出同一列 for (int i = 0; i < n; ++i) cout << "(" << i+1 << "," << c+1 << ") "; cout << endl; // 3. 输出左上-右下对角线：寻找满足 i - j == r - c 的点 cout << "左上-右下对角线: "; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (i - j == r - c) { cout << "(" << i+1 << "," << j+1 << ") "; } } } cout << endl; // 4. 输出左下-右上对角线：寻找满足 i + j == r + c 的点 cout << "左下-右上对角线: "; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (i + j == r + c) { cout << "(" << i+1 << "," << j+1 << ") "; } } }这个实现虽然仍有双重循环，但判断条件非常直白地反映了我们发现的数学规律，更容易理解和维护。如果你想进一步优化，也可以像之前那样，根据恒定值直接计算出对角线的起点和终点，用单循环完成，这留给大家作为练习。
3. 玩转矩阵：旋转90度、180度与270度的艺术
矩阵旋转是二维数组操作中的经典问题，也是面试中的常客。它考验的是你对坐标空间变换的想象力和推导能力。很多人会死记硬背公式，但一旦理解了背后的“映射”原理，你就能轻松推导出任何角度的旋转。
3.1 右旋90度：坐标变换的推导与实现
我们先来看最经典的顺时针旋转90度（也就是题目里的“右转90度”）。原始文章给出的方法是：按列逆序读取。具体是for(j从n-1到0) { cout << a[j][i] << " "; }。这方法很巧妙，但它是“输出时”进行的变换，没有改变原矩阵。如果我们想得到一个旋转后的新矩阵，或者需要原地旋转（不使用额外空间），就需要理解坐标映射关系。
让我们动手在纸上画一个3x3的矩阵，标上坐标和数字：
旋转前坐标 旋转后坐标 (0,0)=1 -> (0,2)=7? 不对，我们系统推导一下。更系统的方法是：找一个点(i, j)，看看它旋转90度后去了哪里。经过观察和推导，你会发现一个规律：原矩阵中的元素matrix[i][j]，在顺时针旋转90度后，会移动到新矩阵的[j][n-1-i]位置。
为什么？想象一下，旋转后，原来的“行”变成了“列”，原来的“列”变成了“反过来的行”。第i行会变成第n-1-i列（从后往前数），第j列会变成第j行。所以新坐标就是(j, n-1-i)。
因此，创建一个新的n x n矩阵rotated，然后进行赋值：
// 假设原矩阵是 a, 新矩阵是 rotated for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { rotated[j][n - 1 - i] = a[i][j]; } }然后按行输出rotated即可。这种方法清晰地展示了每个元素去了哪里，概念上更容易理解。而原始文章的输出技巧，可以看作是这种映射关系在输出时的一种即时应用。
3.2 原地旋转90度：一种更高级的技巧
有时候，题目会要求“原地旋转”，也就是只能使用O(1)的额外空间（除了原矩阵）。这听起来有点难，但有一个非常经典的四元素循环交换方法。思路是分层处理，从最外层一圈开始，一直到最内层。
对于每一层，我们一次旋转四个处于对称位置上的元素。例如，对于最外层的左上角元素matrix[i][j]，它应该去的位置是matrix[j][n-1-i]，而原来在那个位置的元素又该去matrix[n-1-i][n-1-j]，以此类推，形成一个四元组循环。我们用一个临时变量temp保存第一个值，然后按逆时针方向依次赋值，就能完成原地旋转。
void rotate90ClockwiseInPlace(vector<vector<int>>& matrix) { int n = matrix.size(); for (int i = 0; i < n / 2; ++i) { // 处理层数 for (int j = i; j < n - 1 - i; ++j) { // 处理当前层的一边 int temp = matrix[i][j]; // 四元组旋转 matrix[i][j] = matrix[n-1-j][i]; // 左下角 -> 左上角 matrix[n-1-j][i] = matrix[n-1-i][n-1-j]; // 右下角 -> 左下角 matrix[n-1-i][n-1-j] = matrix[j][n-1-i]; // 右上角 -> 右下角 matrix[j][n-1-i] = temp; // 原左上角 -> 右上角 } } }这段代码需要多画图、多模拟几次才能完全吃透。我建议你一定要在纸上画一个4x4或5x5的矩阵，手动走一遍这个循环过程，这是理解原地算法最好的方式。
3.3 旋转180度与270度：举一反三的练习
掌握了90度旋转，180度和270度就很简单了。
- 旋转180度：可以看作是水平翻转后再垂直翻转，也可以看作是两次90度旋转。坐标映射关系是
(i, j) -> (n-1-i, n-1-j)。也就是行和列都变成了“倒数”位置。 - 旋转270度（或逆时针90度）：这是顺时针90度的反向操作。坐标映射关系是
(i, j) -> (n-1-j, i)。你可以通过推导，或者理解为顺时针旋转3次90度来得到。
我们可以写一个通用的旋转函数，通过参数控制旋转角度：
void rotateMatrix(vector<vector<int>>& mat, int degrees) { int n = mat.size(); vector<vector<int>> result(n, vector<int>(n)); degrees %= 360; // 处理超过360度的情况 for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { int new_i, new_j; if (degrees == 90) { // 顺时针90 new_i = j; new_j = n - 1 - i; } else if (degrees == 180) { new_i = n - 1 - i; new_j = n - 1 - j; } else if (degrees == 270) { // 或逆时针90 new_i = n - 1 - j; new_j = i; } else { // 0度，不旋转 new_i = i; new_j = j; } result[new_i][new_j] = mat[i][j]; } } mat = result; // 将结果赋回原矩阵（非原地版本） }通过这样一个函数，你可以轻松应对不同角度的旋转需求。理解这些变换的核心，永远是抓住“原坐标(i, j)与目标坐标(new_i, new_j)之间的数学关系”。
4. 综合实战：从“斜角矩阵”生成到复杂变换
在掌握了基本的遍历和旋转后，我们来看一些更有趣的综合性问题，比如生成各种规律的“斜角矩阵”。这些问题能很好地锻炼我们的循环控制和下标计算能力。
4.1 生成斜角矩阵（I到IV）：找规律与循环控制
原始文章给出了好几个斜角矩阵生成的例子，比如斜角I（递增）、斜角II（递减）、斜角IV（对称）。我们以斜角IV为例深入分析一下，它的输出是这样的（N=5）：
5 4 3 2 1 4 5 4 3 2 3 4 5 4 3 2 3 4 5 4 1 2 3 4 5观察这个矩阵，你会发现它关于主对角线是近似对称的，每个位置(i, j)的值是|i - j| + 1吗？不对，中间是5。更准确的规律是：每个元素的值等于其到中心（主对角线）的“距离”加1，但以主对角线为对称轴进行镜像。实际上，a[i][j] = abs(i - j) + 1这个公式只对左上角部分成立。更通用的方法是：对于每个位置(i, j)，其值等于n - max(i, j)？我们来验证一下(0,0)是5，n-max(0,0)=5，对；(1,0)是4，n-max(1,0)=4，对；(2,2)是5，n-max(2,2)=3，不对。
看来直接找通项公式有点复杂。原始文章的代码提供了一种构造性的思路：它先按行处理，从每行的最右边（j=n-1）开始向左填充，用一个变量cnt控制数字的变化。当行索引i大于等于列索引j时（即位于主对角线及其右下方），数字递减；否则（位于主对角线左上方），数字递增。这种“分情况讨论+过程构造”的方法，在解决复杂矩阵填充问题时非常实用，它不追求一个万能公式，而是用逻辑清晰地描述填充过程。
// 斜角IV的一种更易理解的实现思路 int n; cin >> n; vector<vector<int>> mat(n, vector<int>(n)); for (int i = 0; i < n; ++i) { // 从主对角线开始，向左递减，向右递减（但对称） for (int j = 0; j < n; ++j) { // 核心：值 = n - 行、列索引中较大的那个？不对。 // 观察发现：值 = n - |(i - (n-1-j))| ? 太复杂。 // 采用距离中心线（从左上到右下的对角线，但值从n开始）的思路： // 实际上，mat[i][j] = n - | (i - j) | ? 对于(0,0):5-0=5对，(1,0):5-1=4对，(2,2):5-0=5对！ // 验证(0,1):5-1=4，但矩阵中是4，对！(1,2):5-1=4，矩阵中是4，对！(4,4):5-0=5，但矩阵中是1，错！ // 所以这个简单公式只对上半部分或特定区域有效。这正说明了原始文章那种“过程式”填充的通用性。 // 我们按照“到两条对角线距离”的思路来模拟： int distFromMain = abs(i - j); // 到主对角线的距离 int distFromAnti = abs(i + j - (n - 1)); // 到副对角线的距离 // 斜角IV的规律更接近：值 = n - distFromMain? 对(4,4)是5-4=1，正确！ // 验证(0,0):5-0=5正确，(2,2):5-0=5正确，(0,4):5-4=1正确，(4,0):5-4=1正确。 // 原来这么简单！mat[i][j] = n - abs(i - j); mat[i][j] = n - abs(i - j); } } // 输出mat...看，经过一番推导，我们竟然找到了一个非常简洁的通项公式：mat[i][j] = n - abs(i - j)。对于N=5，abs(i-j)的范围是0到4，用5去减正好得到5到1。这比原始文章的代码更简洁明了。这个过程告诉我们，面对看似复杂的矩阵生成题，不妨多观察、多尝试，寻找简洁的数学关系，这往往能带来更优雅的解法。
4.2 矩阵的翻转与行/列交换
除了旋转，矩阵的翻转（镜像）也是常见操作。水平翻转就是每一行逆序，new[i][j] = old[i][cols-1-j]。垂直翻转就是每一列逆序，new[i][j] = old[rows-1-i][j]。这些操作理解起来比旋转简单。
原始文章中还提到了“矩阵交换行”，这是一个非常基础但重要的操作。它的关键在于，交换两行数据时，行索引变化，但列索引遍历方式不变。高效的实现是直接交换两个一维数组（即两行），而不是在输出时做判断。
// 更高效的交换行方法 void swapRows(vector<vector<int>>& mat, int rowA, int rowB) { // 假设rowA和rowB是0-based的索引 if (rowA < 0 || rowB < 0 || rowA >= mat.size() || rowB >= mat.size()) return; // 直接交换两个行向量 swap(mat[rowA], mat[rowB]); }使用std::swap可以一次性交换两行所有元素，既简洁又高效。这个技巧在实现矩阵的行阶梯变换（高斯消元法）等算法时非常有用。
5. 性能优化与常见“坑点”剖析
当我们把基础打牢后，就需要关注代码的效率和健壮性了。在处理二维数组，特别是大型矩阵时，一些细微的选择可能会带来显著的性能差异。
5.1 遍历顺序与缓存命中率
这是一个非常关键但容易被忽视的点。C++中，二维数组在内存中是按行连续存储的。也就是说，matrix[0][0],matrix[0][1],matrix[0][2]... 这些元素在内存中是紧挨着的。当我们访问matrix[i][j]时，计算机不仅会加载这个数据，还会把它附近的一整块数据（一个缓存行）加载到CPU高速缓存中。
因此，按行顺序遍历（外层循环行i，内层循环列j）的效率，远高于按列顺序遍历。
// 高效：按行遍历 for (int i = 0; i < rows; ++i) { for (int j = 0; j < cols; ++j) { sum += matrix[i][j]; // 对缓存友好 } } // 低效：按列遍历 for (int j = 0; j < cols; ++j) { for (int i = 0; i < rows; ++i) { sum += matrix[i][j]; // 跳跃式访问，缓存不命中率高 } }在旋转矩阵的算法中，我们有时不得不进行非顺序访问，但了解这个原理能帮助我们在设计算法时，尽可能让内存访问模式更连续。
5.2 边界条件与索引处理
这是新手最容易出错的地方之一，我也因此调试过不少时间。
- 索引从0开始 vs 从1开始：题目输入输出有时使用1-based索引（第1行第1列），而我们代码中数组通常是0-based。在读取输入或输出结果时，必须进行清晰的转换（
实际索引 = 输入索引 - 1）。一个良好的习惯是，在代码开头就用注释标明索引体系。 - 矩阵非方阵：我们讨论的很多规律（如对角线）默认对方阵有明确定义。如果矩阵不是方阵，你需要明确问题定义。例如，对于一个
m x n的矩阵，主对角线可以定义为min(m, n)个元素，但副对角线的定义就可能模糊不清。在写通用函数时，要增加对行列数是否相等的判断。 - 原地操作的风险：像原地旋转矩阵这样的操作，因为是在原数据上修改，一旦中间步骤出错，原始数据就被破坏了，很难调试。一个稳妥的做法是，先写出使用额外空间的正确版本，验证逻辑无误后，再尝试优化为原地算法。并且在修改时，可以先用一个临时变量保存要被覆盖的值。
5.3 从二维数组到vector<vector<int>>
在学习和做OJ题时，我们常用原生数组int a[100][100]。但在实际C++项目中，更推荐使用vector<vector<int>>。它更安全（自带大小信息、支持动态扩容）、更方便（可以直接赋值、作为函数参数传递）。
#include <vector> using namespace std; int main() { int n; cin >> n; // 声明一个n行n列的矩阵，并初始化为0 vector<vector<int>> matrix(n, vector<int>(n, 0)); // 输入 for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { cin >> matrix[i][j]; } } // 操作起来和数组几乎一样 // 获取行数：matrix.size() // 获取列数：matrix[0].size() (需确保非空) }使用vector时，交换两行变得极其简单：swap(matrix[rowA], matrix[rowB])。在性能要求不是极端苛刻的情况下，vector的便利性和安全性是首选。
6. 实战演练：解决一个综合性问题
让我们把所有技巧用起来，解决一个稍微综合点的问题：给定一个方阵，先计算其两条主对角线上所有不重复元素之和，然后将矩阵顺时针旋转90度，再计算一次旋转后两条对角线上的不重复元素之和，最后输出两个和值。
这个问题融合了对角线遍历、元素去重（考虑主副对角线交点元素不重复计算）、矩阵旋转等多个知识点。
#include <iostream> #include <vector> #include <unordered_set> using namespace std; // 计算矩阵两条对角线上不重复元素之和 int sumOfUniqueDiagonals(const vector<vector<int>>& mat) { int n = mat.size(); unordered_set<int> uniqueElements; // 用于去重 // 主对角线 for (int i = 0; i < n; ++i) { uniqueElements.insert(mat[i][i]); } // 副对角线 for (int i = 0; i < n; ++i) { uniqueElements.insert(mat[i][n - 1 - i]); } // 计算和 int sum = 0; for (int val : uniqueElements) { sum += val; } return sum; } // 顺时针旋转90度（非原地，返回新矩阵） vector<vector<int>> rotate90(const vector<vector<int>>& mat) { int n = mat.size(); vector<vector<int>> rotated(n, vector<int>(n)); for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { rotated[j][n - 1 - i] = mat[i][j]; } } return rotated; } int main() { int n; cout << "输入矩阵大小 n: "; cin >> n; vector<vector<int>> matrix(n, vector<int>(n)); cout << "输入 " << n << "x" << n << " 矩阵:" << endl; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { cin >> matrix[i][j]; } } // 计算原始矩阵对角线不重复和 int sum1 = sumOfUniqueDiagonals(matrix); cout << "旋转前，两条对角线不重复元素之和为: " << sum1 << endl; // 旋转矩阵 vector<vector<int>> rotatedMatrix = rotate90(matrix); // 计算旋转后矩阵对角线不重复和 int sum2 = sumOfUniqueDiagonals(rotatedMatrix); cout << "旋转90度后，两条对角线不重复元素之和为: " << sum2 << endl; // 可选：输出旋转后的矩阵看看 cout << "\n旋转后的矩阵为:" << endl; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { cout << rotatedMatrix[i][j] << " "; } cout << endl; } return 0; }这个例子展示了如何将多个基础操作组合起来解决一个具体问题。使用unordered_set可以方便地对元素进行去重。通过编写清晰的函数（如sumOfUniqueDiagonals和rotate90），主函数的逻辑变得非常易懂。在实际开发中，这种模块化的思想至关重要。
处理二维数组的问题，就像在指挥一个坐标方阵。最开始可能会被下标绕晕，但只要你耐心地在纸上多画几次，把i和j的变化规律摸清，就会发现所有的遍历、旋转、翻转，都不过是坐标(i, j)按照某种规则映射到了新的位置(new_i, new_j)。从简单的对角线求和，到复杂的原地旋转，再到生成各种图案的矩阵，核心思路都是一致的：观察、归纳坐标变换的数学关系，然后用代码精确地描述这种关系。我自己的经验是，每学一种新变换，就一定要亲手在纸上推导一遍坐标映射，并尝试用不同的循环方式去实现它。这个过程积累下来的直觉，比死记硬背十段代码都有用。当你再遇到类似的矩阵问题时，就能很快地抓住要害，写出既正确又高效的代码。
