1. Two Sum + 15. 3 Sum + 16. 3 Sum Closest + 18. 4Sum + 167. Two Sum II

▶ 问题：给定一个数组 nums 及一个目标值 target，求数组中是否存在 n 项的和恰好等于目标值

▶ 第 1题，n = 2，要求返回解

● 代码，160 ms，穷举法，时间复杂度 O(n²)，空间复杂度 O(1)

class Solution
{
public:
    vector<int> twoSum(vector<int> nums, int target)
    {
        int i, j;
        for (i = 0; i < nums.size()-1; i++)
        {
            for (j = i + 1; j < nums.size(); j++)
            {
                if (nums[i] + nums[j] == target)
                    return vector<int> {i, j};
            }
        }
        return vector<int>{};
    }
};

● 代码，9 ms，排序后夹逼，需要构造一个结构来保存下标，连着下标一起排序。时间复杂度 O(n log n)，空间复杂度 O(1)

class Solution
{
public:
    struct Node
    {
        int val;
        int index;
        Node(int pval, int pindex) : val(pval), index(pindex) {}
        bool operator < (const Node& b) const {return val < b.val;}
    };

    vector<int> twoSum(vector<int>& nums, int target)
    {
        int i, j, temp;
        vector<Node> nums2;
        for (i = 0; i < nums.size(); i++)
            nums2.push_back(Node(nums[i], i)); 
        sort(nums2.begin(), nums2.end());
        for (i = 0, j = nums2.size() - 1; i < j; (temp > target) ? j-- : i++ )
        {
            if ((temp = nums2[i].val + nums2[j].val) == target)
                return vector<int>{nums2[i].index, nums2[j].index}; 
        }
        return vector<int>{};
    }
};

● 代码，10 ms，使用散列表，遍历数组时将项放入散列表，同时检查当前项和散列表中已经有的项是否构成问题的解，利用散列表查找时间为常数的特点加快检查速度，最快的解法算法与之相同。时间复杂度 O(n)，空间复杂度 O(n)

class Solution
{
public:
    vector<int> twoSum(vector<int> nums, int target)
    {
        int i;
        unordered_map<int, int> map;
        for (i = 0; i < nums.size(); i++)
        {
            if (map.find(target - nums[i])!=map.end())
                return vector<int>{map[target - nums[i]], i };
            map[nums[i]] = i;
        }
        return vector<int>{};
    }
};

▶ 第 15 题，n = 3，target = 0

● 大佬的代码，110 ms，排序后夹逼，先指定第一个（最小的）元素，剩下的两个元素使用前面二元和的方法进行夹逼，并跳掉一些多余分支，最快的解法算法与之相同，时间复杂度 O(n²)，空间复杂度 O(1)

class Solution
{
public:
    vector<vector<int> > threeSum(vector<int> &num)
    {
        int i, left, right;
        vector<vector<int>> output;

        sort(num.begin(), num.end());
        for (i = 0; i < num.size();)
        {
            if (num[i] > 0) // 第一个元素已经大于零，则三个元素的和不可能等于零，剩下的界都不用检查了
                break;
            for (left = i + 1, right = num.size() - 1; left < right;)   // 搜索二元和,可能有多解，必须全部搜索完
            {
                if (num[left] + num[right] + num[i] < 0)
                    left++;
                else if (num[left] + num[right] + num[i] > 0)
                    right--;
                else
                {
                    output.push_back(vector<int>{num[i], num[left], num[right]});
                    for (left++; left < right && num[left] == num[left - 1]; left++);       // 跳过第二个数重复的情况
                    for (right--; left < right && num[right] == num[right + 1]; right--);   // 跳过第三个数重复分情况
                }
            }
            for (i++; i < num.size() && num[i] == num[i - 1]; i++); // 跳过第一个数重复分情况，即调整下一次检查的起点
        }
        return output;
    }
};

▶ 第 16 题，n = 3，求最近似解，第 259 题要收费 Orz

● 代码，6 ms，排序后夹逼，使用 output 来记录当前最优解的信息。最快的解法算法与之相同，时间复杂度 O(n²)，空间复杂度 O(1)

class Solution
{
public:
    inline int diff(int a, int b) { return (a > b) ? (a - b) : (b - a); }

    int threeSumClosest(vector<int> &num, int target)
    {
        int i, target2, left, right, sum2, output;

        std::sort(num.begin(), num.end());
        for (i = 0, output = INT_MAX>>1; i < num.size();)
        {            
            for (target2 = target - num[i], left = i + 1, right = num.size() - 1; left < right;)
            {
                sum2 = num[left] + num[right];
                if (sum2 < target2)
                    left++;
                else if (sum2 > target2)
                    right--;
                else
                    return target;
                if (diff(sum2, target2) < diff(target,output))
                    output = sum2 + num[i];                
            }
            for (i++; i < num.size() && num[i] == num[i - 1]; i++);
        }
        return output;
    }
};

▶ 第18 题，n = 4

● 代码，12 ms，排序后夹逼，先指定两个较小的元素，剩下的两个元素使用前面二元和的方法进行夹逼，并跳掉一些多余分支，最快的解法算法与之相同，时间复杂度 O(n³)，空间复杂度 O(1)

class Solution4
{
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target)
    {
        int n, i, j, left, right, sum;
        vector<vector<int>> output;
        n = nums.size();
        sort(nums.begin(), nums.end());
        for (i = 0; i < n - 3; i++) // 指定第一个元素
        {
            if (i > 0 && nums[i] == nums[i - 1] || nums[i] + nums[n - 3] + nums[n - 2] + nums[n - 1] < target)
                continue;                                       // 跳过第一个元素重复或过小的情况
            if (nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target)
                break;                                          // 第一个元素过大，结束搜索
            for (j = i + 1; j < n - 2; j++)                     // 指定第二个元素
            {
                if (j > i + 1 && nums[j] == nums[j - 1] || nums[i] + nums[j] + nums[n - 2] + nums[n - 1] < target)
                    continue;                                   // 跳过第二个元素重复过小的情况
                if (nums[i] + nums[j] + nums[j + 1] + nums[j + 2]>target)
                    break;                                      // 第二个元素过大，结束搜索
                for(left = j + 1, right = n - 1; left < right;) // 搜索第三和第四个元素 
                {
                    sum = nums[left] + nums[right] + nums[i] + nums[j];
                    if (sum < target)
                        left++;
                    else if (sum > target)
                        right--;
                    else
                    {
                        output.push_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
                        for (left++; nums[left] == nums[left - 1] && left < right; left++); 
                        for (right--; nums[right] == nums[right + 1] && left < right; right--);
                    }
                }
            }
        }
        return output;
    }
};

▶ 第 167 题，n = 2，默认已经排好了序，可以使用第 1 题结果，第170 题要付费 Orz

● 夹逼，7 ms，时间复杂度 O(n)

class Solution
{
public:
    vector<int> twoSum(vector<int>& numbers, int target)
    {
        int left, right;
        vector<int>output;
        for (left = 0, right = numbers.size() - 1; left < right;)
        {
            if (numbers[left] + numbers[right] == target)
                return vector<int>{left + 1, right + 1};
            else if (numbers[left] + numbers[right] > target)
                right--;
            else
                left++;
        }
        return vector<int>();
    }
};

● 大佬的代码，7 ms，使用二分法加速，时间复杂度 O(log n)

class Solution
{
public:
    int largestSmallerOrLastEqual(vector<int>& numbers, int start, int end, int target)
    {
        int lp, rp, mp;
        for (lp = start, rp = end, mp = lp + (rp - lp) / 2; lp <= rp; mp = lp + (rp - lp) / 2)
        {
            if (numbers[mp] > target)
                rp = mp - 1;
            else
                lp = mp + 1;
        }
        return rp;
    }
    int smallestLargerOrFirstEqual(vector<int>& numbers, int start, int end, int target)
    {
        int lp, rp, mp;
        for (lp = start, rp = end, mp = lp + (rp - lp) / 2; lp <= rp; mp = lp + (rp - lp) / 2)
        {
            if (numbers[mp] < target)
                lp = mp + 1;
            else
                rp = mp - 1;
        }
        return lp;
    }
    vector<int> twoSum(vector<int>& numbers, int target)
    {
        const int n = numbers.size();
        if (numbers.size() == 0)
            return vector<int>{};
        int start, end;
        for (start = 0, end = n - 1; start < end;)
        {
            if (numbers[start] + numbers[end] == target)
                return vector<int> {start + 1, end + 1};
            if (numbers[start] + numbers[end] > target)
                end = largestSmallerOrLastEqual(numbers, start, end, target - numbers[start]);// end 向前移动到满足 numbers[end] <= target - numbers[start] 的最后一个整数
            else
                start = smallestLargerOrFirstEqual(numbers, start, end, target - numbers[end]);// start 向后移动到满足 numbers[start] >= target - numbers[end] 的第一个整数           
        }
        return vector<int>{};
    }
};

▶ 第 454 题，n = 4，每个加数分别从指定的集合中选出

● 自己的方法，1550 ms，这是将第 18 题的算法移植过来得到的，在使用计数器 counta，countb，countc，countd 计算重复解以前结果为超时，说明这种逐步搜索的方法对于独立的集合来说效率不足

class Solution
{
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D)
    {
        const int n = A.size();
        int a, b, c, d, count, counta, countb, countc, countd;
        sort(A.begin(), A.end()), sort(B.begin(), B.end()), sort(C.begin(), C.end()), sort(D.begin(), D.end());

        for (a = count = 0; a < n; a++)
        {
            if (A[a] + B[n - 1] + C[n - 1] + D[n - 1] < 0)  // A[a] 过小
                continue;
            if (A[a] + B[0] + C[0] + D[0] > 0)              // A[a] 过大
                break;
            for (counta = 1; a < n - 1 && A[a + 1] == A[a]; a++, counta++);// A[a] 重复计数
            for (b = 0; b < n; b++)
            {
                if (A[a] + B[b] + C[n - 1] + D[n - 1] < 0)  // B[b] 过小
                    continue;
                if (A[a] + B[b] + C[0] + D[0] > 0)          // B[b] 过大
                    break;
                for (countb = 1; b < n - 1 && B[b + 1] == B[b]; b++, countb++);// B[b] 重复计数
                for (c = 0, d = n - 1; c < n && d >= 0;)
                {
                    if (A[a] + B[b] + C[c] + D[d] < 0)
                        c++;
                    else if (A[a] + B[b] + C[c] + D[d] > 0)
                        d--;
                    else
                    {
                        for (countc = 1; c < n - 1 && C[c + 1] == C[c]; c++, countc++);
                        for (countd = 1; d > 0 && D[d - 1] == D[d]; d--, countd++);
                        count += counta * countb * countc * countd;
                        c++, d--;
                    }
                }
            }
        }
        return count;
    }
};

● 大佬的解法，197 ms，unordered_map 查找

class Solution
{
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D)
    {
        unordered_map<int, int>  abSum;
        int count = 0;
        auto it = abSum.begin();
        for (auto a : A)
        {
            for (auto b : B)
                abSum[a + b]++;
        }        
        for (auto c : C)
        {
            for (auto d : D)
            {
                if ((it = abSum.find(0 - c - d))!= abSum.end())
                    count += it->second;
            }
        }
        return count;
    }
};

● 大佬的解法，203 ms，二分查找

class Solution
{
public:
    int biSearch(vector<int> & nums, int x, bool LEFT)// 在 nums 中搜索值为 x 的元素，由于存在重复元素，使用了两种二分搜索，用 LEFT 区分
    {
        int lp, rp, mp;
        for (lp = 0, rp = nums.size() - 1, mp = (lp + rp) / 2; lp <= rp; mp = (lp + rp) / 2)
        {            
            if (LEFT)// 搜索最靠左的 x
            {
                if (nums[mp] >= x)
                    rp = mp - 1;
                else
                    lp = mp + 1;
            }
            else     // 搜索最靠右的 x
            {
                if (nums[mp] <= x)
                    lp = mp + 1;
                else
                    rp = mp - 1;
            }
        }
        return LEFT ? lp : rp;
    }
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D)
    {
        const int n = A.size();
        vector<int> s, m;
        int i, j, sum, ans;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
                s.push_back(A[i] + B[j]), m.push_back(C[i] + D[j]);
        }
        sort(s.begin(), s.end()), sort(m.begin(), m.end());
        for (i = sum = ans = 0; i < s.size(); ++i)
        {
            if (i != 0 && s[i] == s[i - 1])//  重复计数
                ans += sum;
            else
            {
                sum = biSearch(m, -s[i], false) - biSearch(m, -s[i], true) + 1;// 第二个重复计数
                ans += sum;
            }
        }
        return ans;
    }
};

▶ 第 657 题，n = 2，数据结构是中根二叉树

● 代码，38 ms，中根序遍历这棵树，把数字都取出来（恰好为升序数列），再用前面的方法计算

class Solution
{
public:
    bool findTarget(TreeNode* root, int k)
    {
        vector<int> nums;
        inorder(root, nums);
        for (int i = 0, j = nums.size() - 1; i < j;)
        {
            if (nums[i] + nums[j] == k)
                return true;
            (nums[i] + nums[j] < k) ? i++ : j--; 
        }
        return false;
    }
    void inorder(TreeNode* root, vector<int>& nums)// 中根序遍历树
    {
        if (root == NULL)
            return;
        inorder(root->left, nums);
        nums.push_back(root->val);
        inorder(root->right, nums);
    }
};

● 代码，38 ms，从树的中根序两端向中间遍历

class BSTIterator
{
private:
    stack<TreeNode*> s;
    bool forward;
public:
    BSTIterator(TreeNode* root, bool forward)
    {
        for (this->forward = forward; root != nullptr; root = forward ? root->left : root->right)
            s.push(root);
    }
    TreeNode* next()
    {
        if (s.empty())
            return NULL;
        TreeNode *top, *tmp;        
        for (top = s.top(), s.pop(), tmp = (forward ? top->right : top->left); tmp != nullptr; s.push(tmp), tmp = (forward ? tmp->left : tmp->right));
        return top;
    }
};
class Solution
{
public:
    bool findTarget(TreeNode* root, int k)
    {
        int sum;
        BSTIterator forward(root, true), backward(root, false);// 获取最前结点和最后结点（最小和最大元素）
        TreeNode *fn, *bn;
        for (fn = forward.next(), bn = backward.next(); fn != bn;)
        {
            sum = fn->val + bn->val;
            if (sum == k)
                return true;
            (sum < k) ? (fn = forward.next()) : (bn = backward.next());
        }
        return false;
    }
};