Leetcode OJ: 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

就是给一个Target，然后找出一个数组中两个和为target的组合，确保只有一个。

第一反应，暴力解法，果断超时了，复杂度O(n^2)。

第二反应，排序后，复杂度果断变成O(nlogn)。然后再结合二分查找，又提升了查找速度，另外用到二分查找一定要记得判断是否与上次的边界相等。看代码吧：

class Solution {
private:
    // 归并时用到的buffer
    vector<int> buffer;
    vector<size_t> index_buffer;
    // 用于找回排序后的原index
    vector<size_t> indexes;

public:
    // 归并，注意index也需要进行对应的调整
    void mergeSort(vector<int>& numbers, size_t begin, size_t end) {
        if (end - begin <= 1)
            return;
        size_t i = begin, j = end, mid = begin + ((end - begin) >> 1);
        mergeSort(numbers, begin, mid);
        mergeSort(numbers, mid, end);
        int k = begin;
        j = mid;
        while (i < mid || j < end) {
            if (j >= end || (i < mid && numbers[i] < numbers[j])) {
                buffer[k] = numbers[i];
                index_buffer[k] = indexes[i];
                k++;
                i++;
            }else {
                buffer[k] = numbers[j];
                index_buffer[k] = indexes[j];
                k++;
                j++;
            }
        }
        for (i = begin; i < end; ++i) {
            numbers[i] = buffer[i];
            indexes[i] = index_buffer[i];
        }
    }
    
    size_t search(vector<int>& numbers, size_t begin, size_t end, int target) {
        size_t mid;
        while (begin < end) {
            mid = begin + ((end - begin) >> 1);
            if (numbers[mid] < target) {
                begin = mid + 1;
            } else if (numbers[mid] > target) {
                end = mid;
            } else
                break;
        }
        if (begin >= end) {
            return end;
        }
        return mid;
    }

    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> ret;
        if (numbers.empty())
            return ret;
        int size = numbers.size();
        // 初始化index与buffer
        buffer.assign(size, 0);
        indexes.assign(size, 0);
        for (int i = 0; i < size; ++i) {
            indexes[i] = i + 1;
        }
        index_buffer.assign(size, 0);
        
        // 归并排序
        mergeSort(numbers, 0, size);
        
        size_t i = 0, j = size - 1;
        while (i < j) {
            int sum = numbers[i] + numbers[j];
            if (sum == target) {
                ret.push_back(min(indexes[i], indexes[j]));
                ret.push_back(max(indexes[i], indexes[j]));
                break;
            } else if (sum > target) {
                size_t tmp = search(numbers, i + 1, j, target - numbers[i]);
                // 查找j与下一个的值是否相等，不相等则左移一位
                while (numbers[tmp] == numbers[j])
                    tmp--;
                j = tmp;
            } else {
                size_t tmp = search(numbers, i + 1, j, target - numbers[j]);
                // 查找i与下一个的值是否相等，不相等则右移一位
                while (numbers[tmp] == numbers[i])
                    tmp++;
                i = tmp;
            }
        }
        return ret;
    }
};