[ leetcode c++ ] [ 1 ] 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 [1, 2].

思路:

大致有三种方法:

1. hash: 从左向右扫描一遍，然后将数及坐标存到map中。然后再扫描一遍即可。时间复杂度 \( O(n) \)
2. 双指针扫描: 将数组排序，然后双指针从前后往中间扫描。时间复杂度 \( O(n log(n)) \). 因为要求返回原数组的下标，所以在排序的时候还得有额外的数组来存储下标信息。
3. 暴力搜索: 时间复杂度 \( O(n^2) \)

Code 1

#include <vector>
#include <unordered_map>
#include <iostream>
#include <algorithm>
 
using std::vector;
using std::unordered_map;
using std::cout;
using std::endl;
 
// this method we first build the hashmap, then find the result
vector<int> two_sum_clumsy(const vector<int> &nums, const int target) {
    unordered_map<int, int> m;
    vector<int> result(2, 0);
    for (int i = 0; i < nums.size(); ++i) {
        m[nums[i]] = i;
    }
    for (int j = 0; j < nums.size(); ++j) {
        if (m.find(target - nums[j]) != m.end() && m[target - nums[j]] != j) {
            result[0] = j + 1;          // do not forget +1 to j
            result[1] = m[target - nums[j]] + 1;
            return result;
        }
    }
    cout << "Not exist!" << endl;
    return result;
}　

Code 2

// this method is also based on the hashmap, but we build the hashmap and find the result simutaneously
// this method is a bit tricky. First, we traverse the array one by one, then we just put the `target-num[i]`(not `num[i]`) into the map. 
// So, when we checking the next num[i], if we found it is exisited in the map, it means we found the second one.
vector<int> two_sum(const vector<int> &nums, const int target) {
    unordered_map<int, int> m;
    vector<int> result;
     
    for (int i = 0; i < nums.size(); ++i) {
        // not found the second one
        if (m.find(nums[i]) == m.end()) {
            // store the first one poisition into the second one's key
            m[target - nums[i]] = i;
        }
        else {
            // found the second one
            result.push_back(m[nums[i]] + 1);
            result.push_back(i + 1);
            break;
        }
    }
    return result;
}

Code 3

// this method first sort then find, complexity O(log n)
struct Node
{
    int val;
    int index;
    Node(int pVal, int pIndex) : val(pVal), index(pIndex) {}
};
 
bool compare(const Node &left, const Node &right) {
    return left.val < right.val;
}
 
vector<int> two_sum_sorted(const vector<int> &nums, int target) {
    vector<Node> elements;
    for (int i = 0; i < nums.size(); ++i) {
        elements.push_back(Node(nums[i], i));
    }
    // pay attention to the usage to the following sort function in <algorithm>
    std::sort(elements.begin(), elements.end(), compare);
    int s = 0, t = elements.size() - 1;
    vector<int> result;
    while (s < t) {
        int temp_sum = elements[s].val + elements[t].val;
        if (temp_sum == target) {
            result.push_back(elements[s].index + 1);
            result.push_back(elements[t].index + 1);
            std::sort(result.begin(), result.end());
            return result;
        }
        else if (temp_sum > target) {
            --t;
        }
        else {
            ++s;
        }
    }
    return result;
}

Code 4

// this method is the most tedious (这个方法是最麻烦的)
vector<int> two_sum_tedious(const vector<int> &nums, const int target) {
    vector<int> result;
    for (int i = 0; i < nums.size(); ++i) {
        for (int j = i + 1; j < nums.size(); ++j) {
            if (nums[i] + nums[j] == target) {
                result.push_back(i + 1);
                result.push_back(j + 1);
                return result;
            }
        }
    }
    return result;
}