leetcode-1-两数之和-easy

题目描述

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

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

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

解题思路

• 我一开始想用map的思想，把值存到map数组里，用空间换取时间，复杂度为0n，
• 后来提交以后发现有负整数项，那就改程序，添加一个负整数数组（程序逻辑变复杂以后，出了很多关于bound的bug）。
• 改好以后再提交发现它用大数卡了map的做法，行吧。

class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
        int minn = 999999;
        for(int i=0;i<nums.size();i++){
            minn = min(minn,nums[i]);
        }
        int ex_bound = 0;
        
        if(minn<0){
            ex_bound = -1*minn;
        }
        pair <int,int> a[target+ex_bound+5];
        pair <int,int> b[ex_bound+5];
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));

        int maxx=-9999;
        for(int i=0;i<nums.size();i++){
            maxx = max(maxx,nums[i]);
            if(nums[i]<target+ex_bound+1&&nums[i]>0){
                a[nums[i]].first++;
                a[nums[i]].second = i;
                
            }else if(nums[i]<0){
                b[-1*nums[i]].first++;
                b[-1*nums[i]].second = i;
            }
        }
        vector <int> res;
        for(int i=0;i<target+ex_bound;i++){
            if(target>=i){
                if(a[i].first>0&&a[target-i].first>0&&(i!=target-i)){
                    res.push_back(a[i].second);
                    res.push_back(a[target-i].second);
                    break;
                }
                
            }else if(i>target){
                if(a[i].first>0&&b[i-target].first>0){
                    res.push_back(a[i].second);
                    res.push_back(b[i-target].second);
                    break;
                }
            }
        }
        return res;
    }
};

• 然后气急败坏使用笨比操作A了

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

---

去康康优秀题解

• 我为什么想到用vector做map了，没想到直接用map。我肯定是个弱智

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