【LeetCode】Two Sum

Two Sum

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

 

Solution:

如果只是简单的：

class Solution:
    # @return a tuple, (index1, index2)
    def twoSum(self, num, target):
        for i in range(len(num)):
            numJ = target-num[i]
            if numJ in num:
                return (i+1, num.index(numJ)+1)
        

肯定是会超时的。这个Python程序应该是O(n^3)的（for, 查找numJ, index(numJ)），一般的O(n^2)（用for将查找值和索引合成一个循环）也会超时。

于是很快可以想到另外一种解法：QuickSort + BinarySearch。这是一般的想法，是可以AC的（O(nlogn)）。

代码如下：

void sort(int a[], int b[], int l, int r)
{
    int i, j, x, t;
    i = l; j = r; x = a[i + ((j - i) >> 1)];
    do
    {
        while (x > a[i]) i++;
        while (x < a[j]) j--;
        if (i <= j)
        {
            t = a[i]; a[i] = a[j]; a[j] = t;
            t = b[i]; b[i] = b[j]; b[j] = t;
            i++; j--;
        }
    } while (i <= j);
    if (i < r) sort(a, b, i, r);
    if (j > l) sort(a, b, l, j);
}

int binSearch(int a[], int e, int lo, int hi)
{
    int mi;
    while (lo < hi)
    {
        mi = (lo + hi) >> 1;
        if (e < a[mi]) hi = mi;
        else lo = mi + 1;
    }
    return --lo;
}

int *twoSum(int numbers[], int n, int target) {
    int *index = (int *)malloc(n * sizeof(int));
    int i, indexLook;
    int *ans = (int *)malloc(2 * sizeof(int));
    for (i = 0; i<n; i++) index[i] = i;
    sort(numbers, index, 0, n-1);
    for (i = 0; i<n; i++)
    {
        indexLook = binSearch(numbers, target - numbers[i], 0, n);
        if (numbers[indexLook] == target - numbers[i])
        {
            if (index[i] < index[indexLook])
            {
                ans[0] = index[i]+1;
                ans[1] = index[indexLook]+1;
            }
            else
            {
                ans[1] = index[i]+1;
                ans[0] = index[indexLook]+1;
            }
            return ans;
        }
    }
}

这里，还有一种也比较常规的解法：HashTable。（O(n)）

可以在边建立哈希表的同时也进行查找（按先后顺序，查找第二个时第一个肯定已经入表）。将num中的值映射到其下标，对于每一个num中的值e，在HashTable中查找target-e对应的下标。如果能找到直接返回结果；如果不能找到则把e和其下标也加入哈希表中。

Java解法如下：

import java.util.HashMap;
import java.util.Map;

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        Map<Integer, Integer> map=new HashMap<>(numbers.length*2);
        for(int i=0;i<numbers.length;i++){
            Integer company=map.get(target-numbers[i]);
            if(company==null)
                map.put(numbers[i], i);
            else
                return new int[]{company+1,i+1};
        }
        return null;
    }
}

另外，其实这道题的本质就是找one pair numbers使得其和等于target。我们可以从整体上来看待这个问题，并且根据找到的pair与target之间的关系调整位置继续找，直到找到符合条件的唯一解。

当num排完序后，我们考虑从第一个数(i=0)和最后一个数(j=len-1)开始，如果它们的和比target大，说明此时和需要调整得更小，那么把j指针向前调；如果当前的和比target小，则把i指针向后调。直到找到这样的pair使得和正好等于target。这样就可以避免对于每一个元素e都要对target-e进行二分查找，效率肯定更高。（因为如果当前i一定是最后结果(i, j)中的一个值，那么比当前j下标大的数一定使得当前和比target大，所以j会不断减小直到到正确解，正确性可以得到证明。）

AC代码如下（Python）：O(nlogn)

class Solution:
    # @return a tuple, (index1, index2)
    def twoSum(self, num, target):
        copyNum = num[:]
        copyNum.sort()
        firstIndex = 0
        lastIndex = len(copyNum) - 1
        while True:
            if copyNum[firstIndex] + copyNum[lastIndex] == target:
                break
            elif copyNum[firstIndex] + copyNum[lastIndex] > target:
                lastIndex -= 1
            else:
                firstIndex += 1
        
        fIndex = num.index(copyNum[firstIndex])+1
        num.reverse()
        lIndex = len(num) - num.index(copyNum[lastIndex])
        
        if fIndex > lIndex:
            fIndex, lIndex = lIndex, fIndex
        return (fIndex, lIndex)
        

（因为index只能找到第一个等于该值得下标，当两个加数相等时，就必需从后往前找，所以要num.reverse()，或者自己写一个function从后往前找。）

参考：

1、https://leetcode.com/discuss/27316/java-solution-space-using-binarysearch-time-space-using-hash

2、https://leetcode.com/discuss/26760/python-solution-with-52ms-cost