题目链接

单组_二维数组

题目描述

给定一个 n 行 m 列的二维正整数数组 a，其中 1 <= n, m <= 100，且 1 <= a[i][j] <= 1000。请计算数组中所有元素之和。

输入描述:

  • 第一行输入两个整数 n 和 m，用空格隔开。
  • 接下来 n 行，每行输入 m 个整数。

输出描述:

  • 输出一个整数，表示二维数组所有元素之和。

示例说明:

  • 输入: 
    3 4
1 2 3 4
5 6 7 8
9 10 11 12
  • 输出: 78

解题思路

本题是一个基础的二维数组遍历和求和问题。按照"先输入，再处理"的思路，解法如下：

  1. 读取维度: 首先，从输入中读取二维数组的行数 n 和列数 m。

  2. 创建并填充数组:

    • 声明一个 n 行 m 列的二维数组（或列表）。
    • 使用两层嵌套的循环，按顺序读取 n * m 个整数，并将它们填充到创建好的二维数组中。

  3. 初始化总和: 定义一个变量 total_sum 用于存储所有元素的累加和。为了防止整数溢出，最好选择一个范围足够大的数据类型。

    • 数据范围分析: 数组最大为 100x100，每个元素最大为 1000。总和的最大值可能是 100 * 100 * 1000 = 10,000,000。这个值在标准的 int（32位，约2*10^9）范围内。但为了养成良好的编程习惯，对于累加问题，使用 long long (C++) 或 long (Java) 是一个更安全的选择。Python 的整数类型可以自动处理大数，无需担心。

  4. 遍历与累加:

    • 再次使用两层嵌套的循环来遍历内存中已经填充好的二维数组。
    • 在循环中，将每个数组元素的值累加到 total_sum 变量上。

  5. 输出结果: 所有元素都累加完毕后，输出 total_sum 的值。

这种"先存储后处理"的模式在逻辑上更清晰，但也需要 O(N*M) 的额外空间来存储数组。

算法步骤概览:

  • 读入 n, m。
  • 创建 n x m 的二维数组 arr。
  • for i from 0 to n-1:
    • for j from 0 to m-1:
      • 读入一个整数并存入 arr[i][j]。
  • 初始化 total_sum = 0。
  • for i from 0 to n-1:
    • for j from 0 to m-1:
      • total_sum += arr[i][j]。
  • 输出 total_sum。

代码

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    
    vector<vector<int>> arr(n, vector<int>(m));
    
    // 步骤1: 先将所有数据读入二维数组
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> arr[i][j];
        }
    }
    
    long long total_sum = 0;
    // 步骤2: 再遍历数组进行计算
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            total_sum += arr[i][j];
        }
    }
    
    cout << total_sum << 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();
        
        int[][] arr = new int[n][m];

        // 步骤1: 先将所有数据读入二维数组
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        
        long totalSum = 0;
        // 步骤2: 再遍历数组进行计算
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                totalSum += arr[i][j];
            }
        }
        
        System.out.println(totalSum);
    }
}

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

# 步骤1: 先将所有数据读入二维列表
arr = []
for _ in range(n):
    row = list(map(int, input().split()))
    arr.append(row)

# 步骤2: 再遍历列表进行计算
total_sum = 0
for i in range(n):
    for j in range(m):
        total_sum += arr[i][j]

print(total_sum)

算法及复杂度

  • 算法: 遍历求和。
  • 时间复杂度: ，因为我们需要两次遍历 N*M 的数据（一次读取，一次计算），总体复杂度仍然是 。
  • 空间复杂度: 。因为我们需要一个 N*M 大小的二维数组来存储所有输入数据。