给定矩阵左上角的第K个对角线

给定N * N维的平方矩阵M [] [] ，任务是找到矩阵的^第K^个对角线，从左上角到右下角，并打印其内容。
例子：

Input: N = 3, K = 2, M[ ][ ] = {{4, 7, 8}, {9, 2, 3}, {0, 4, 1} 
Output: 9 7 
Explanation: 
5 possible diagonals starting from the top left to the bottom right for the given matrix are: 
1 -> {4} 
2 -> {9, 7} 
3 -> {0, 2, 8} 
4 -> {4, 3} 
5 -> {1} 
Since K = 2, the required diagonal is (9, 7).
Input: N = 2, K = 2, M[ ][ ] = {1, 5}, {9, 4}} 
Output: 1 
Explanation: 
3 possible diagonals starting from the bottom left to the top right for the given matrix are: 
1 -> {1} 
2 -> {9, 5} 
3 -> {4} 
Since K = 2, the required diagonal is (9, 5). 
 

天真的方法：
解决此问题的最简单方法是生成从给定矩阵的左上角到右下角开始的所有对角线。生成第K^个对角线后，打印其内容。
时间复杂度： O(N ² )
辅助空间： O(N)
高效方法：
可以通过避免遍历矩阵来优化上述方法。相反，找到第K^个对角线的边界，即左下角和右上角索引。一旦获得这些索引，只需遍历对角线的索引即可打印所需的对角线。
需要以下观察来找到对角线的位置：

If ((K – 1) < N): The diagonal is an upper diagonal 
Bottom-left boundary = M[K – 1][0] 
Top-right boundary = M[0][K – 1]
If (K ? N): The diagonal is a lower diagonal. 
Bottom-left boundary = M[N-1][K-N] 
Top-right boundary = M[K-N][N-1] 
 

请按照以下步骤解决问题：

• 如果(K – 1) < N ，则将起始行startRow设置为K – 1 ，将列startCol设置为0 。
• 否则，将startRow设置为N – 1并将startCol设置为K – N。
• 最后，从M [startRow] [startCol]开始打印对角线的元素。

下面是上述方法的实现：

C++

// C++ implementation of
// the above approach
#include 
using namespace std;
 
// Function returns required diagonal
void printDiagonal(int K, int N,
                vector >& M)
{
    int startrow, startcol;
 
    // Initialize values to
    // print upper diagonals
    if (K - 1 < N) {
        startrow = K - 1;
        startcol = 0;
    }
 
    // Initialize values to
    // print lower diagonals
    else {
        startrow = N - 1;
        startcol = K - N;
    }
 
    // Traverse the diagonal
    for (; startrow >= 0 && startcol < N;
        startrow--, startcol++) {
 
        // Print its contents
        cout << M[startrow][startcol]
            << " ";
    }
}
 
// Driver Code
int main()
{
    int N = 3, K = 4;
    vector > M = { { 4, 7, 8 },
                            { 9, 2, 3 },
                            { 0, 4, 1 } };
 
    printDiagonal(K, N, M);
    return 0;
}

Java

// Java implementation of
// the above approach
import java.util.*;
 
class GFG{
 
// Function returns required diagonal
static void printDiagonal(int K, int N,
                          int [][]M)
{
    int startrow, startcol;
 
    // Initialize values to
    // print upper diagonals
    if (K - 1 < N)
    {
        startrow = K - 1;
        startcol = 0;
    }
 
    // Initialize values to
    // print lower diagonals
    else
    {
        startrow = N - 1;
        startcol = K - N;
    }
 
    // Traverse the diagonal
    for(; startrow >= 0 && startcol < N;
          startrow--, startcol++)
    {
         
        // Print its contents
        System.out.print(M[startrow][startcol] + " ");
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 3, K = 4;
    int[][] M = { { 4, 7, 8 },
                  { 9, 2, 3 },
                  { 0, 4, 1 } };
 
    printDiagonal(K, N, M);
}
}
 
// This code is contributed by PrinciRaj1992

Python3

# Python3 implementation of the
# above approach
def printDiagonal(K, N, M):
     
    startrow, startcol = 0, 0
 
    # Initialize values to prupper
    # diagonals
    if K - 1 < N:
        startrow = K - 1
        startcol = 0
    else:
        startrow = N - 1
        startcol = K - N
 
    # Traverse the diagonals
    while startrow >= 0 and startcol < N:
         
        # Print its contents
        print(M[startrow][startcol], end = " ")
        startrow -= 1
        startcol += 1
 
# Driver code
if __name__ == '__main__':
     
    N, K = 3, 4
    M = [ [ 4, 7, 8 ],
          [ 9, 2, 3 ],
          [ 0, 4, 1 ] ]
           
    printDiagonal(K, N, M)
 
# This code is contributed by mohit kumar 29

C#

// C# implementation of
// the above approach
using System;
class GFG{
 
// Function returns required diagonal
static void printDiagonal(int K, int N,
                          int [,]M)
{
    int startrow, startcol;
 
    // Initialize values to
    // print upper diagonals
    if (K - 1 < N)
    {
        startrow = K - 1;
        startcol = 0;
    }
 
    // Initialize values to
    // print lower diagonals
    else
    {
        startrow = N - 1;
        startcol = K - N;
    }
 
    // Traverse the diagonal
    for(; startrow >= 0 && startcol < N;
          startrow--, startcol++)
    {
         
        // Print its contents
        Console.Write(M[startrow,startcol] + " ");
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    int N = 3, K = 4;
    int[,] M = { { 4, 7, 8 },
                 { 9, 2, 3 },
                 { 0, 4, 1 } };
 
    printDiagonal(K, N, M);
}
}
 
// This code is contributed by PrinciRaj1992

输出：

4 3 

时间复杂度： O(N)
辅助空间： O(1)