LeetCode Problem 1: Two Sum

Problem

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].

Solution

Approach 1: Brute Force

The brute force approach is simple. Loop through each element x and find if there is another value that equals to target - x.

Code: C++

class Solution
{
public:
    vector<int> twoSum(vector<int>& nums, int target)
    {
        for(int i=0; i < nums.size(); i++)
        {
            for(int j=i+1; j < nums.size(); j++)
            {
                if(nums[j] == target - nums[i])
                {
                    return {i, j};
                }   
            }
        }
        return {-1, -1};
    }
};

Complexity Analysis

• Time complexity: $O(n^2)$. For each element, we try to find its complement by looping through the rest of the array which takes $O(n)$ time. Therefore, the time complexity is $O(n^2)$.

• Space complexity: $O(1)$.

Approach 2: Two-pass Hash Table

To improve our run time complexity, we need a more efficient way to check if the complement exists in the array. If the complement exists, we need to look up its index. What is the best way to maintain a mapping of each element in the array to its index? A hash table.

We reduce the lookup time from $O(n)$ to $O(1)$ by trading space for speed. A hash table is built exactly for this purpose, it supports fast lookup in near constant time. I say “near” because if a collision occurred, a lookup could degenerate to $O(n)$ time. But the lookup in the hash table should be amortized $O(1)$ time as long as the hash function was chosen carefully.

A simple implementation uses two iterations. In the first iteration, we add each element’s value and its index to the table. Then, in the second iteration we check if each element’s complement $(target-nums[i])$ exists in the table.

Code: C++

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target)
    {
        unordered_map<int, int> hashmap;
        for (int i = 0; i < nums.size(); i++)
        {
            hashmap[nums[i]] = i;
        }
        for (int i = 0; i < nums.size(); i++)
        {
            int complement = target - nums[i];
            if (hashmap.count(complement) != 0 && hashmap[complement] != i)
            {
                return {i, hashmap[complement]};
            }
        }
        return {-1, -1};
    }
};

Complexity Analysis

• Time complexity: $O(n)$. We traverse the list containing n elements exactly twice. Since the hash table reduces the lookup time to $O(1)$, the time complexity is $O(n)$.

• Space complexity: $O(n)$. The extra space required depends on the number of items stored in the hash table, which stores exactly $n$ elements.

Approach 3: One-pass Hash Table

It turns out we can do it in one-pass. While we iterate and insert elements into the table, we also look back to check if current element’s complement already exists in the table. If exists, we have found a solution and return the solution immediately.

Code: C++

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target)
    {
        unordered_map<int, int> map;
        for (auto it = nums.begin(); it != nums.end(); ++it)
        {
            int key = target - *it;
            auto keyit = map.find(key);
            if (keyit != map.end())
            {
                return {keyit -> second, it - nums.begin()};
            }
            map.insert(make_pair(*it, it - nums.begin()));
        }
        return {-1, -1};
    }
};

Complexity Analysis

• Time complexity: $O(n)$. We traverse the list containing $n$ elements only once. Each lookup in the table costs only $O(1)$ time.

• Space complexity: $O(n)$. The extra space required depends on the number of items stored in the hash table, which stores at most $n$ elements.