题目链接

矩阵转置

题目描述

给定一个 n 行 m 列的矩阵 A，计算其转置矩阵 A^T。 转置矩阵是将原矩阵的行与列进行互换得到的新矩阵。

输入描述:

  • 第一行输入两个整数 n 和 m，分别表示矩阵的行数和列数 (1 <= n, m <= 10)。
  • 接下来 n 行，每行输入 m 个整数。

输出描述:

  • 输出 m 行 n 列，为矩阵的转置结果。每个元素之后使用一个空格，每行末尾不需要空格但需要换行。

示例1:

  • 输入: 
    2 3
1 2 3
4 5 6
  • 输出: 
    1 4 
2 5 
3 6

解题思路

矩阵转置是一个基础的线性代数操作，在编程中通常通过二维数组来实现。解题的核心思想是创建一个新的矩阵，其维度与原矩阵的维度正好相反，然后通过交换行列索引来填充它。

  1. 理解转置: 如果原矩阵是 A，转置矩阵是 A^T，那么它们元素之间的关系是 A^T[j][i] = A[i][j]。也就是说，原矩阵的第 i 行、第 j 列的元素，会成为转置矩阵中第 j 行、第 i 列的元素。

  2. 读取输入:

    • 首先读取矩阵的维度 n (行数) 和 m (列数)。
    • 创建一个 n x m 的二维数组 original_matrix。
    • 使用嵌套循环将 n * m 个输入整数填充到 original_matrix 中。

  3. 创建转置矩阵:

    • 转置后的矩阵维度会变为 m x n。因此，我们需要创建一个新的 m x n 的二维数组 transposed_matrix 来存放结果。

  4. 执行转置:

    • 使用两层嵌套循环遍历原矩阵 original_matrix。外层循环 i 从 0 到 n-1，内层循环 j 从 0 到 m-1。
    • 在循环体中，执行核心的转置操作：transposed_matrix[j][i] = original_matrix[i][j]。

  5. 输出结果:

    • 转置操作完成后，transposed_matrix 中就保存了完整的结果。
    • 最后，使用两层嵌套循环遍历转置矩阵 transposed_matrix，并按照题目要求的格式（每个元素后跟一个空格，每行结束后换行）将其打印出来。

算法步骤概览:

  • 读入 n, m。
  • 创建 n x m 的二维数组 original 并填充数据。
  • 创建 m x n 的二维数组 transposed。
  • for i from 0 to n-1:
    • for j from 0 to m-1:
      • transposed[j][i] = original[i][j]
  • for i from 0 to m-1:
    • for j from 0 to n-1:
      • 打印 transposed[i][j] 和一个空格。
    • 打印换行符。

代码

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    
    // 1. 读取原始矩阵
    vector<vector<int>> original(n, vector<int>(m));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> original[i][j];
        }
    }
    
    // 2. 创建转置矩阵并填充
    vector<vector<int>> transposed(m, vector<int>(n));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            transposed[j][i] = original[i][j];
        }
    }
    
    // 3. 打印转置矩阵
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            cout << transposed[i][j] << " ";
        }
        cout << endl;
    }
    
    return 0;
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        
        // 1. 读取原始矩阵
        int[][] original = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                original[i][j] = sc.nextInt();
            }
        }
        
        // 2. 创建转置矩阵并填充
        int[][] transposed = new int[m][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                transposed[j][i] = original[i][j];
            }
        }
        
        // 3. 打印转置矩阵
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(transposed[i][j] + " ");
            }
            System.out.println();
        }
    }
}

n, m = map(int, input().split())

# 1. 读取原始矩阵
original = []
for _ in range(n):
    original.append(list(map(int, input().split())))

# 2. 创建一个 m x n 的空矩阵用于存放转置结果
transposed = [[0] * n for _ in range(m)]

# 3. 填充转置矩阵
for i in range(n):
    for j in range(m):
        transposed[j][i] = original[i][j]

# 4. 打印转置矩阵
for i in range(m):
    # 使用 * 操作符解包列表，print 函数默认用空格分隔
    print(*transposed[i])

算法及复杂度

  • 算法: 矩阵转置。
  • 时间复杂度: 。我们需要遍历整个 N x M 矩阵来读取、填充转置矩阵和打印结果。
  • 空间复杂度: 。我们需要额外的空间来存储原始矩阵和转置矩阵。