Leetcode 1. Two Sum

本篇是 Leetcode 刷題第一篇，對於大部分人來說 Two Sum 都是刷題的開端，就像單詞書的 abandon 。至於後續會不會 abandon，拭目以待。

對於第一題最先想到的演算法是用兩層迴圈遍歷陣列，nums[j]==target-nums[i] 。時間複雜度為 \(O(n^2)\)。演算法主要浪費在找到 target-nums[i] 這個數，找這個數的時間複雜度為 \(O(n)\)，即遍歷整個陣列。

我們可以使用雜湊表儲存每個數及其對應的下標，這樣就可以在 \(O(1)\) 時間內找到 target-nums[i]，整個演算法時間複雜度為 \(O(n)\)

C++

C++ 使用 unordered_map 來儲存鍵值對。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> index;
        vector<int> result;

        int nSize = nums.size();
        int residue;
        for(int i = 0; i < nSize; i++) {
            residue = target - nums[i];
            if(index.find(residue) != index.end()) {
                result.push_back(index[residue]);
                result.push_back(i);
                return result;
            }
            index[nums[i]] = i;
        }

        return result;
    }
};
 

Ruby

# @param {Integer[]} nums
# @param {Integer} target
# @return {Integer[]}
def two_sum(nums, target)
    hs = {}
    nums.each_with_index do |num, idx|
        subt = target - num
        if hs.has_key?(subt)
            return [hs[subt], idx]
        end
        hs[num] = idx
    end
end

Python

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()
        for i, num in enumerate(nums):
            if target - num in hashtable:
                return [hashtable[target - num], i]
            hashtable[nums[i]] = i
        return []

Swift

Swift 需要使用 enumerated() 獲取陣列值和下標，可參照 Ruby 的 each_with_index。Swift 和 Ruby 語法相較其他語言有很多不同，刷題時可以領略不同風格的語言。

class Solution {
    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
        var dict = [Int: Int]()

        for (i, num) in nums.enumerated() {
            if let lastIndex = dict[target - num] {
                return [lastIndex, i]
            }
            dict[num] = i
        }
        fatalError("No valid outputs")
    }
}