Leetcode 01-两数之和c++

今天和小猪在奶茶店闲聊，不知怎么就打开了LeetCode，看到第一题通过率竟然那么低，就想做做…，不愧是我。

题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解法一 暴力遍历

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ans;
        for (int i=0;i<nums.size();i++)
        {
            for (int j=i+1;j<nums.size();++j)
            {
                if(nums[i]+nums[j]==target)
                {
                    ans.push_back(i);
                    ans.push_back(j);
                    return ans;
                }
            }
        }
        return {};//第一次知道可以这样返回
    }
};

时间O(n²) 空间O(n)


然后我就知道通过率怎么来的了。

解法二 哈希

涉及到查找多半沾点哈希

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hs;
        vector<int>ans;
        int i=0;
        for(auto num:nums)
        {
            if(hs.find(target-num)!=hs.end())
            {
                ans.push_back(hs.find(target-num)->second);
                ans.push_back(i);
                return ans;
            }
            else
            hs[num]=i;
            i++;
        }
        return ans;
    }
};

时间O(n),空间O(n)
称之为强化版遍历。

解法三 排序+双指针

先把数组排序。head指针从头往后找，tail从后往前，当head->num+tail->num<target时，head往后；反之tail往前；相同时退出。
要注意排序前后下标会变化，所以创建了一个vector用来查找。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ans;
        vector<int> temp;
        temp=nums;
        int n=temp.size();
        sort(temp.begin(),temp.end());
        int i=0,j=n-1;
        while(i<j)
        {  
            if(temp[i]+temp[j]>target)
                j--;
            else if(temp[i]+temp[j]<target)
                i++;
            else break; 
       }
       if(i<j)
       {
        for(int k=0;k<n;k++)
        {
            if(i<n&&nums[k]==temp[i])
            {
              ans.push_back(k);
              i=n;
        }
            else if(j<n&&nums[k]==temp[j])
            {
              ans.push_back(k);
              j=n;
            }
          if(i==n&&j==n)return ans;
        }
      }
        return ans;
    }
};

时间O(nlogn)，空间O(n)
那么关键就来了，为什么这样能保证如果存在num[i]+num[j]=target时一定成立呢。
数学归纳法写不出来，于是七想八想弄出了一张图来解释。

1.开始时从a1+an开始，此时为第一行的最大值，如果发现大于target，则往左边探索，相当于tail- -；如果发现相等则结束。
2.但一旦中间出现小于target的情况，设为a组合，则这行的剩余其他组合都没有意义，于是head++转到下一行斜对角的组合。这时只要继续往左探索，因为右边的组合c必然大于a组合右边的组合b，既然是因为b>target才移动到a，就没必要考虑大于b的c，此时相当于head++，tail不变。
3.如果又发现太大，则继续tail- -往左探索，太小则head++进入下一行。
以此类推。
关键点在于每一行往右都是递增的，一旦该组合小于target，说明此行其他组合都没有意义。并且每次往下都可以忽略其他没用意义的组合。因此在不遗漏的情况下最快寻找到满足的组合。