[LeetCode] 1. Two Sum(两数之和)

Two Sum

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

题目要点

• 返回数字所在下标
• 每种输入仅有一种答案
• 同一下标不可以使用两次

解决方案

方法一：暴力法

暴力法很简单。遍历每一个元素 x，并查找是否存在一个值与 target - x 相等的目标元素。

vector<int> twoSum(vector<int> &nums, int target)
{
    vector<int> result_vec;
    for (int i = 0; i < nums.size(); ++i)
    {
        int num1 = target - nums[i];

        for (int j = i + 1; j < nums.size(); ++j)
        {
            if (num1 == nums[j])
            {
                result_vec.push_back(i);
                result_vec.push_back(j);
                return result_vec;
            }
        }
    }

    return result_vec;
}

复杂度分析：

• 时间复杂度：O(n²)， 对于每一个元素，咱们试图经过遍历数组的其他部分来寻找它所对应的目标元素，这将耗费 O(n) 的时间。所以时间复杂度为 O(n²)。
• 空间复杂度：O(1)。

---

方法二：两遍哈希表

为了对运行时间复杂度进行优化，咱们须要一种更有效的方法来检查数组中是否存在目标元素。若是存在，咱们须要找出它的索引。保持数组中的每一个元素与其索引相互对应的最好方法是什么？哈希表。

经过以空间换取速度的方式，咱们能够将查找时间从 O(n) 下降到 O(1)。哈希表正是为此目的而构建的，它支持以 近似 恒定的时间进行快速查找。我用“近似”来描述，是由于一旦出现冲突，查找用时可能退化到 O(n)。但只要你仔细地挑选哈希函数，在哈希表中进行查找的用时应当被摊销为 O(1)。

一个简单的实现使用了两次迭代。在第一次迭代中，咱们将每一个元素的值和它的索引添加到表中。而后，在第二次迭代中，咱们将检查每一个元素所对应的目标元素 （target−nums[i]） 是否存在于表中。注意，该目标元素不能是 nums[i] 自己！

vector<int> twoSum(vector<int> &nums, int target)
{
    vector<int> result_vec;
    map<int, int> num_map;
    for (int i = 0; i < nums.size(); ++i)
    {
        num_map[nums[i]] = i;
    }

    for (int i = 0; i < nums.size(); ++i)
    {
        int target_num = target - nums[i];
        if (num_map.find(target_num) != num_map.end() && num_map[target_num] != i)
        {
            result_vec.push_back(num_map[target_num]);
            result_vec.push_back(i);
            return result_vec;
        }
    }

    return result_vec;
}

复杂度分析：

• 时间复杂度：O(n)，咱们把包含有 n 个元素的列表遍历两次。因为哈希表将查找时间缩短到 O(1)，因此时间复杂度为 O(n)。
• 空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n 个元素。

---

方案三：一遍哈希表

事实证实，咱们能够一次完成。在进行迭代并将元素插入到表中的同时，咱们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。若是它存在，那咱们已经找到了对应解，并当即将其返回。

vector<int> twoSum(vector<int> &nums, int target)
{
    vector<int> result_vec;
    map<int, int> num_map;
    for (int i = 0; i < nums.size(); ++i)
    {
        int target_num = target - nums[i];
        if (num_map.find(target_num) != num_map.end())
        {
            result_vec.push_back(num_map[target_num]);
            result_vec.push_back(i);
            return result_vec;
        }

        num_map[nums[i]] = i;
    }

    return result_vec;
}

复杂度分析：

• 时间复杂度：O(n)，咱们只遍历了包含有 n 个元素的列表一次。在表中进行的每次查找只花费 O(1) 的时间。
• 空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表最多须要存储 n 个元素。