【C++】B2091 向量点积计算

💯前言

• 在线性代中，点积是一种基础而重要的向量操作，应用广泛，从学科计算到传统运算阶段都十分常见。本文对一道向量点积的题目进行全面分析，并对三种不同实现方案进行比较和解析，帮助读者更好地理解和掌握向量点积的计算。
  以下文章包括：题目说明与分析；两种不同解法代码（老师给出的方案和自己的解法）；以及各方案的优缺点比较和进一步优化建议。
  C++ 参考手册
  

💯题目描述

B2091 向量点积计算

在线性代数中，计算点积是一种基础的操作。给出两个向量，向量 $a$ 和向量 $b$，它们的点积计算公式如下：

$$a\cdot b=a_1{b}_1+a_2{b}_2+\cdots +a_n{b}_n$$

题目说明

• 输入格式：

  • 第一行，一个整数 $n$，表示向量的维数（元素个数）；
  • 第二行，含有 $n$ 个整数，表示向量 $a$ 的元素值；
  • 第三行，含有 $n$ 个整数，表示向量 $b$ 的元素值；

• 输出格式：

  • 输出一个整数，即两个向量点积的结果。

输入输出示例

输入：

3
1 2 3
4 5 6

输出：

36

分析

根据示例，点积计算流程如下：

1. 向量计算公式应用：
   $$\text{点积}=1\cdot 4+2\cdot 5+3\cdot 6=4+10+18=36$$
2. 最终输出结果为 36。

以上是题目的核心内容和基础分析，接下来将分别分析两种解法，并进行比较和进一步优化。

我的做法

#include <iostream>
using namespace std;

int main()
{
	int n = 0;
	cin >> n;
	int arr1[n];
	int arr2[n];
	for(int i = 0; i < n; i++)
	{
		cin >> arr1[i];
	}
	for(int i = 0; i < n; i++)
	{
		cin >> arr2[i];
	}
	int result = 0;
	for(int i = 0; i < n; i++)
	{
		result += arr1[i] * arr2[i]; 
	}
	cout << result;
	
	return 0;	
} 

💯解法一：完整输入存储后计算点积的方案

代码展示

#include <iostream>
using namespace std;

const int N = 1010;
int arr1[N];
int arr2[N];

int main()
{
    int n = 0;
    cin >> n;

    for (int i = 0; i < n; i++) {
        cin >> arr1[i];
    }

    for (int i = 0; i < n; i++) {
        cin >> arr2[i];
    }

    int ret = 0;
    for (int i = 0; i < n; i++) {
        ret += arr1[i] * arr2[i];
    }

    cout << ret << endl;
    return 0;
}

分析与解释

基础思路

1. 首先读取向量的维度 $n$；
2. 利用两个整型数组，分别存储向量 $a$ 和 $b$ 的值；
3. 将两个向量逐元素相乘，并累加存储在结果变量 ret 中；
4. 最后输出计算结果。

代码分解

1. 全局定义数组和存储设置

const int N = 1010;
int arr1[N];
int arr2[N];

• 全局整型数组的大小设置为 1010，能足以处理题目中需要的最大数据规模（$n\le 1000$）。
• 实现了完整输入存储，方便后续计算点积。

2. 向量值输入

for (int i = 0; i < n; i++) {
    cin >> arr1[i];
}

for (int i = 0; i < n; i++) {
    cin >> arr2[i];
}

• 通过两个 for 循环，分别读取向量 $a$ 和 $b$ 的值并存入数组。
• 这种做法结构清晰，是常见的输入处理方式。

3. 点积计算和输出

int ret = 0;
for (int i = 0; i < n; i++) {
    ret += arr1[i] * arr2[i];
}
cout << ret << endl;

• 通过一个循环，将两个数组对应元素相乘，并累加存入变量 ret。
• 最后将结果输出。

涉及的概念

• 数组：数组用于存储相同类型的值，通过连续内存地址存放。
• 循环处理：使用 for 循环可以依次访问数组中的元素。
• 空间复杂度：由于定义了两个数组，因此空间复杂度为 $O(n)$。

优点与不足

• 优点：

  • 解法完整地使用了数组存储，代码清晰，结构简单易懂；
  • 标准化程度高，适用于大部分相似题目。

• 不足：

  • 空间复杂度较高，需要额外的数组来存储输入；
  • 若仅需要计算点积，而无需保留输入数据，存储数组显得多余。

💯解法二：优化存储的即时计算方案

代码展示

#include <iostream>
using namespace std;

const int N = 1010;
int arr1[N];

int main()
{
    int n = 0;
    cin >> n;

    for (int i = 0; i < n; i++) {
        cin >> arr1[i];
    }

    int ret = 0;
    for (int i = 0; i < n; i++) {
        int b;
        cin >> b;
        ret += arr1[i] * b;
    }

    cout << ret << endl;
    return 0;
}

分析与解释

基础思路

1. 首先读取向量的维度 $n$；
2. 仅用一个数组存储向量 $a$ 的值；
3. 在读取向量 $b$ 的值时，即时计算点积并累加；
4. 最后输出计算结果。

代码分解

1. 定义一个数组

const int N = 1010;
int arr1[N];

• 仅定义一个数组，用于存储向量 $a$ 的值。

2. 向量值输入与即时计算

for (int i = 0; i < n; i++) {
    cin >> arr1[i];
}

int ret = 0;
for (int i = 0; i < n; i++) {
    int b;
    cin >> b;
    ret += arr1[i] * b;
}

• 第一个 for 循环读取向量 $a$ 的值；
• 第二个 for 循环在读取向量 $b$ 的值时，直接计算点积并累加。

3. 输出结果

cout << ret << endl;

• 最后将结果输出。

涉及的概念

• 即时计算：无需额外存储向量 $b$ 的值，直接在输入时进行运算。
• 空间复杂度：只需要存储一个数组，空间复杂度降为 $O(n)$。

优点与不足

• 优点：

  • 存储优化，节省了一个数组的空间；
  • 计算即时完成，无需额外遍历数组，提升效率。

• 不足：

  • 如果需要保存输入数据（如后续操作），此方法不适用。

💯两种方案的比较

💯总结与优化建议

通过对两种方案的分析可以看出：

1. 解法一 适用于需要完整保存输入数据的场景，代码逻辑清晰，易于理解和扩展；
2. 解法二 适用于仅需计算点积的场景，存储优化，计算高效。

进一步优化

如果对代码的可读性和现代化有更高的要求，可以使用 C++ 的标准库容器（如 std::vector）和算法函数（如 std::inner_product）来简化代码，实现更加简洁的向量点积计算：

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;

int main()
{
    int n;
    cin >> n;
    vector<int> a(n), b(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    for (int i = 0; i < n; i++) cin >> b[i];

    int result = inner_product(a.begin(), a.end(), b.begin(), 0);
    cout << result << endl;
    return 0;
}

• 使用 std::vector 动态分配内存，避免了固定大小数组的限制；
• 使用 std::inner_product 函数直接计算点积，代码更加简洁。

通过上述分析与代码优化，相信读者能够更清晰地理解向量点积计算的实现方式，并在实际编程中选择合适的方法来解决类似问题。