1. Two Sum

最新推荐文章于 2019-06-02 15:51:25 发布

原创最新推荐文章于 2019-06-02 15:51:25 发布 · 434 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

220 篇文章

订阅专栏

Given an array of integers, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9

Output: index1=1, index2=2

注意：元素可能有重复

最简单的做法就是一个两重循环，时间复杂度是O(n^2),下面提供两种更高效的解法

算法1：

将数组的数组映射到哈希表，key是元素的值，value是该值在数组中的索引。考虑到数组中元素有重复，我们使用STL中的unordered_multimap, 它可以允许重复的key存在。映射以后，对于数组中的某个元素num，我们只要在哈希表中查找num2 = target-num。需要注意的是在哈希表中找到了num2，并不一定代表找到了题目要求的两个数，比如对于数组2 7 11 15，target = 4，当num = 2时，num2 = target-num = 2，此时num2可以在哈希表中找到，但是num和num2指向的是同一个元素。因此当num2 = num时，在哈希表找到num2的同时，还需要保证哈希表中num2的个数>=2。

该算法时间复杂度为O（n）

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        int n = numbers.size();
        vector<int> res;
        unordered_multimap<int, int> umap;
        for(int i = 0; i < n; i++)
            umap.insert(make_pair(numbers[i], i));
        for(int i = 0; i < n; i++)
        {
            auto range = umap.equal_range(target - numbers[i]);
            if(range.first != umap.end())//found
            {
                if(numbers[i] != target - numbers[i])
                {
                    auto range2 = umap.equal_range(numbers[i]);
                    res.push_back(min(range.first->second, range2.first->second) + 1);
                    res.push_back(max(range.first->second, range2.first->second) + 1);
                }
                else
                {
                    auto ite = ++(range.first);
                    if(ite != range.second)
                    {
                        auto range2 = umap.equal_range(numbers[i]);
                        res.push_back(min(ite->second, range2.first->second) + 1);
                        res.push_back(max(ite->second, range2.first->second) + 1);
                    }
                }
            }
        }
        return res;
    }
};

算法2：

首先对数组按小到大排序，然后设定两个指针head、tail分别指向排序好的数组的首尾：

如果两个指针对应的元素和等于target，那么找到了
如果两个指针对应的元素和小于target，那么需要增加和的大小，则把head指针向后移动
如果两个指针对应的元素和大于target，那么需要减少和的大小，则把tail指针向前移动
head赶上tail指针时，结束

由于本题中需要返回最后找到的数对的索引，因此，排序是我们不移动原来数组的元素，只是把元素的的索引放到一个新的数组，对这个新的索引数组排序

class Solution {
private:
    static vector<int> *numbersCopy;
    static bool cmp(int idx1, int idx2)
    {
        return (*numbersCopy)[idx1] < (*numbersCopy)[idx2];
    }
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        numbersCopy = &numbers;
        int n = numbers.size();
        vector<int> res;
        vector<int> idx(n);
        for(int i = 0; i < n; i++)
            idx[i] = i;
        sort(idx.begin(), idx.end(), Solution::cmp);
        
        int head = 0, tail = n-1;
        while(head < tail)
        {
            if(numbers[idx[head]] + numbers[idx[tail]] < target)
                head++;
            else if(numbers[idx[head]] + numbers[idx[tail]] > target)
                tail--;
            else //found
            {
                res.push_back(min(idx[head], idx[tail]) + 1);
                res.push_back(max(idx[head], idx[tail]) + 1);
                break;
            }
        }
        
        return res;
    }
};
vector<int> * Solution::numbersCopy = NULL;

上面是Tenos的解法，下面是喜刷刷的解法。

思路1：hash table

对于数组中每个数来A[i]来说，需要在数组的其他元素中寻找target - A[i]。所以问题转化为数组查找元素问题，当给定一个值时，需要能快速判断是否存在于数组中，如果存在，index是多少。

可以将所有元素插入一个hash table <key = A[i], val = i>，然后重新遍历每个元素，计算target - A[i]，然后在hash table中查找。这里仍需解决2个问题：

(1) 重复元素的问题：比如{2 2 3}, target = 4。解决方法为hash table的val变为一个vector<int>来记录所有j：A[j] = A[i]。

(2) index 1 < index 2：假设A[i] + A[j] = target并且i<j。那么在遍历查找时从左向右，一定在扫描i的时候就找到个solution。返回按照这个顺序即可。

时间和额外空间复杂度均为O(n)

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> res;
        int first = -1, second = -1;
        unordered_map<int, vector<int> > ht;
        for(int i=0; i<numbers.size(); i++) 
            ht[numbers[i]].push_back(i);
        
        for(int i=0; i<numbers.size(); i++) {
            int val = target - numbers[i];
            if(ht.count(val)) {
                if(numbers[i]!=val) {
                    first = i+1;
                    second = ht[val][0]+1;
                    break;
                }
                else if(ht[val].size()>1) {
                    first = ht[val][0]+1;
                    second = ht[val][1]+1;
                    break;
                }
            }
        }
        
        res.push_back(first);
        res.push_back(second);
        return res;
    }
};

思路2：two pointers

将array排序，双指针left/right分别指向头尾。然后两个指针分别向中间移动寻找目标。
(1) A[left] + A[right] = target：直接返回(left+1, right+1)。
(2) A[left] + A[right] > target：说明A[right]不可能是解，right--
(3) A[left] + A[right] < target：说明A[left]不可能是解，left++

中止条件：left >= right

但排序会打乱原来数组index的顺序。我们可以建立一个class/struct/pair来存储val/index，并overload operator < 来以val值排序。这样我们可以track排序后每个数的原有index。

重复元素这里无须特殊处理。index 1和index 2分别取找到的两个index的min/max即可。时间复杂度由于排序的关系为O(n log n)，额外空间复杂度O(n)。

class Solution {
    class elem {
    public:    
        int val;
        int index;
        elem(int v, int i):val(v),index(i) {}
        bool operator<(const elem &e) const {
            return val<e.val;
        }
    };
    
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> res(2,-1);
        vector<elem> arr;
        for(int i=0; i<numbers.size(); i++) 
            arr.push_back(elem(numbers[i],i));

        sort(arr.begin(),arr.end());
        int left = 0, right = arr.size()-1;
        while(left<right) {
            if(arr[left].val+arr[right].val==target) {
                res[0] = min(arr[left].index,arr[right].index)+1;
                res[1] = max(arr[left].index,arr[right].index)+1;
                break;
            }
            else if(arr[left].val+arr[right].val<target) 
                left++;
            else
                right--;
        }
        return res;
    }
};

下面是我的解法：

1.hashtable

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> num_pos;
        vector<int> res;
        int n = (int)nums.size();
        for (int i=0; i<n; i++) {
            int preNum = target-nums[i];
            if (num_pos.count(preNum)) {
                res.push_back(num_pos[preNum]);
                res.push_back(i+1);
                return res;
            } else {
                num_pos[nums[i]] = i+1;
            }
        }
    }
};

2.two pointers

typedef struct{
    int num;
    int pos;
}num_pos;
int cmp( const void *a ,const void *b){
    return (*(num_pos *)a).num > (*(num_pos *)b).num ? 1 : -1;
}
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int len = (int)nums.size(), i, sum;
        vector<int> result;
        num_pos mapping[len];
        for (i=0; i<len; i++) {
            mapping[i].num = nums[i];
            mapping[i].pos = i+1;
        }
        qsort(mapping, len, sizeof(mapping[0]), cmp);
        int p = 0, q = len-1;
        while (p < q) {
            sum = mapping[p].num + mapping[q].num;
            if (sum > target) {
                q--;
            } else if (sum < target) {
                p++;
            } else {
                if (mapping[p].pos < mapping[q].pos) {
                    result.push_back(mapping[p].pos);
                    result.push_back(mapping[q].pos);
                } else {
                    result.push_back(mapping[q].pos);
                    result.push_back(mapping[p].pos);

                }
                break;
            }
        }
        return result;
        
    }
};