如何提取二维矩阵C+的同一对角线中的单元格索引+； 以上，我尝试只用C++来获取二维矩阵的元素 矩阵有MxN维，可能是N=M，N>=M或Mn>>m； std：：向量结果； 对于（int k=0；kn>>m； std：：向量结果； 对于（int k=0；k

视觉辅助：

我试图让第二个for循环从左上角开始遍历矩阵的彩色单元格，也就是说，在每个循环中，第二个循环遍历的单元格的数量/位置都在不断变化&我开始怀疑，在编译时不知道N&M的情况下，是否可以做到这一点

提前谢谢你的时间

~EDIT1: 对于非正方形矩阵，元素的迭代是这样的（如果行多于列，则同样适用）

~2: 以下是迄今为止的代码：（可测试！）

#包括
#包括
#包括
使用名称空间std；
无效函数（void）；
//使用这些变量可以任意指定尺寸
//请记住，我需要这个来处理相对较大的矩阵
int行=5，列=5；
字符串arr[][10]={{“0”、“0”、“0”、“0”、“0”、“0”、“0”、“0”、“0”、“0”、“0”、“0”}，
{"0",  "1,1",   "1,2", "1,3",  "1,4", "1,5", "1,6",  "1,7", "1,8", "1,9" },
{"0",  "2,1",   "2,2", "2,3",  "2,4", "2,5", "2,6",  "2,7", "2,8", "2,9" },
{"0",  "3,1",   "3,2", "3,3",  "3,4", "3,5", "3,6",  "3,7", "3,8", "3,9" },
{"0",  "4,1",   "4,2", "4,3",  "4,4", "4,5", "4,6",  "4,7", "4,8", "4,9" },
{"0",  "5,1",   "5,2", "5,3",  "5,4", "5,5", "5,6",  "5,7", "5,8", "5,9" },
{"0",  "6,1",   "6,2", "6,3",  "6,4", "6,5", "6,6",  "6,7", "6,8", "6,9" },
{"0",  "7,1",   "7,2", "7,3",  "7,4", "7,5", "7,6",  "7,7", "7,8", "7,9" },
{"0",  "8,1",   "8,2", "8,3",  "8,4", "8,5", "8,6",  "8,7", "8,8", "8,9" },
{"0",  "9,1",   "9,2", "9,3",  "9,4", "9,5", "9,6",  "9,7", "9,8", "9,9" }  };
bool f=false，f2=false；
内部主（空）
{
func（）；
返回0；
}
无效函数（无效）
{
如果（行<列）
{
//还记得那一行吗
f=真；
}
无符号短m_i；//外部for循环（i）计数器的掩码-计算
unsigned short j_end=1；//存储内部循环应执行的最大迭代次数-相应递增
无符号短k=1；//存储内部循环的起始索引-开始递增一次（j_end==col）
cout代码：

#包括
#包括
#包括
int main（）{
int n，m；
标准：cin>>n>>m；
std：：向量结果；
对于（int k=0；k=0）
{
结果。推回（{i，j}）；
i++；
j--；
}
}
对于（int k=1；k=0）
{
结果。推回（{i，j}）；
i++；
j--；
}
}
返回0；
}

说明：
如果你看这张图片，你可以看到对角线是当你移动i+1和j-1时。直到上半部分，我们从第一行开始，并尝试沿着指定的方向前进。当我们到达终点时，我们只进入下一列。基本上，每一次迭代我们只是改变起点。第二部分有点棘手，因为我们已经完成了遍历了一些行，所以我们从1开始（因为我们已经遍历了第一行。然后应用与上半部分相同的方向，我们遍历了矩阵的其余部分。
代码：

#include <vector>
#include <utility>
#include <iostream>

int main() {
    int n, m;
    std::cin >> n >> m;

    std::vector<std::pair<int, int> > result;
    for (int k = 0; k < m; k++) {
        int i = 0, j = k;
        while (i < n && j >= 0)
        {
            result.push_back({ i, j });
            i++;
            j--;
        }

    }

   for (int k = 1; k < n; k++) {
        int i = k, j = m - 1;
        while (i < n && j >= 0)
        {
            result.push_back({ i, j });
            i++;
            j--;
        }
    }

    return 0;
}

for( int manhattan_distance = 0; manhattan_distance < M + N - 1; ++manhattan_distance )
{
    for( int i = 0; i <= manhattan_distance; ++i )
    {
         int j = manhattan_distance - i;
         if( j < N && i < M )
         {
               ...
         }       
    }
}

#包括
#包括
#包括
int main（）{
int n，m；
标准：cin>>n>>m；
std：：向量结果；
对于（int k=0；k=0）
{
结果。推回（{i，j}）；
i++；
j--；
}
}
对于（int k=1；k=0）
{
结果。推回（{i，j}）；
i++；
j--；
}
}
返回0；
}

说明：
如果你看这张图片，你可以看到对角线是当你移动i+1和j-1时。直到上半部分，我们从第一行开始，并尝试沿着指定的方向前进。当我们到达终点时，我们只进入下一列。基本上，每一次迭代我们只是改变起点。第二部分有点棘手，因为我们已经完成了遍历了一些行，所以我们从1开始（因为我们已经遍历了第一行。然后应用与上半部分相同的方向，我们遍历了矩阵的其余部分。
for（int manhattan_distance=0；manhattan_distancefor( int manhattan_distance = 0; manhattan_distance < M + N - 1; ++manhattan_distance )
{
    for( int i = 0; i <= manhattan_distance; ++i )
    {
         int j = manhattan_distance - i;
         if( j < N && i < M )
         {
               ...
         }       
    }
}

{
for（int i=0；i
for（int曼哈顿距离=0；曼哈顿距离对于（int i=0；i你可以这样做：

void foo(int rows,int cols){
    // first go vertically down
    for (int start_row = 0;start_row<rows;start_row++){
        int col = 0;
        int row = start_row;
        while (col < cols && row >= 0){
            std::cout << row << "," << col << " ";
            row--;
            col++;
        } 
        std::cout << std::endl;
    }
    // now horizantally
    for (int start_col = 0;start_col<cols;start_col++){
        int col = start_col;
        int row = rows-1;
        while (col < cols && row >= 0){
            std::cout << row << "," << col << " ";
            row--;
            col++;
        }
        std::cout << std::endl;
    }
}   

void foo（int行，int列）{
//首先垂直向下
对于（int start_row=0；start_row=0）{
std:：cout您可以这样做：

void foo(int rows,int cols){
    // first go vertically down
    for (int start_row = 0;start_row<rows;start_row++){
        int col = 0;
        int row = start_row;
        while (col < cols && row >= 0){
            std::cout << row << "," << col << " ";
            row--;
            col++;
        } 
        std::cout << std::endl;
    }
    // now horizantally
    for (int start_col = 0;start_col<cols;start_col++){
        int col = start_col;
        int row = rows-1;
        while (col < cols && row >= 0){
            std::cout << row << "," << col << " ";
            row--;
            col++;
        }
        std::cout << std::endl;
    }
}   

void foo（int行，int列）{
//首先垂直向下
对于（int start_row=0；start_row=0）{
好吧，我得到了一个答案，所有人都认为它不够精致。
它工作正常，但未进行优化

<>编辑：C……没有看到它是C++的，但是这个想法是相同的< /P>
using System;
Random r = new Random();
int rows = r.Next(10,13); // or any range of rows
int cols = r.Next(10,20); // same applies
int[,] matrix = new int[rows,cols];

// mark upper diagonal
for(var i=0; i<= cols; i++)
    markByCol(i,0,cols-i);


// mark lower diagonal
for(var i=1; i<= rows; i++)
    markByCol(cols+1+i,i,cols-1);

// stringify matrix to view it properly
string line = string.Empty;
for(int i=0; i< rows; i++)
{
    line = string.Empty;
    for(int j=0; j< cols; j++)
    {
        line+= matrix[i,j]+" | ";
    }
    Console.WriteLine(line);
}

// the actual function
    int markByCol(int marker,int row,int col){
    if((row > -1  && row < rows) && (col > -1 && col < cols))
    {
            matrix[row,col] = marker;
        return markByCol(marker,row+1,col-1);
    }
    else
        return 0;   
}

使用系统；
随机r=新随机（）；
int rows=r.Next（10,13）；//或任意范围的行
int cols=r.Next（10,20）；//同样适用
int[，]矩阵=新的int[行，列]；
//标记上对角线
对于（变量i=0；i-1&&col