[Leetcode] #01-Two Sum

Posted 2022-07-05 zhouleyi

抱着试一试的心态打开了著名的Leetcode去做了第一题，结果连续两次提交都失败了，其间还有3次编译错误= =。

看了一下导致解答错误的输入。

第一次错误，虽然很正确地想到了使用hashmap，但没有考虑相同的输入，因为[3,3,2] 6对应的输出可以是[0,1]，而不是[]，而这个错误输出是由于hashmap的特性导致的。

不服再来，于是就有了第二次错误...这次我使用了双数组+hashmap，对于重复出现的整数，我给它标记两个下标，反正答案只有一对整数，这样处理完全没有问题。但是，我把自身考虑了两次，比如说，对于输入[3,2,4]，我的程序输出的是[0,0]。

好的，有了两次失败的经验，第三次通过了。看一看结果：用时20ms--击败了68.46%的用户，还不错？ 占用内存10.5MB--击败了12.42%的用户——我。。。

那一瞬间我感觉自己真是菜得无地自容。。。。。

以下是我的代码：

vector<int> twoSum(const vector<int>& nums, int target)

    std::array<int, 2> mark =  -1,-1 ;
    std::vector<int> result;
    std::map<int, std::array<int, 2>> ref;
    int buffer = 0;
    std::map<int, std::array<int, 2>>::iterator iter;

    for (std::size_t i = 0; i < nums.size(); i++)
    
        if (ref.find(nums[i]) == ref.end())
        
            ref[nums[i]] = mark;
            ref[nums[i]][0] = i;
        
        else
            ref[nums[i]][1] = i;
    
    for (std::size_t j = 0; j < nums.size(); j++)
    
        buffer = target - nums[j];
        iter = ref.find(buffer);
        if (iter != ref.end())
        
            if (iter->first == nums[j])
            
                if (iter->second[0] != j)
                
                    result.push_back(iter->second[0]);
                    result.push_back(iter->second[1]);
                    return result;
                
            
            else
            
                result.push_back(j);
                result.push_back(iter->second[0]);
                return result;
            
        
    
    return result;

分割线—————————————————————————————————————————————

研究了一下和我用时相同的代码：

vector<int> twoSum(vector<int>& nums, int target) 
        vector<int> result;
        map<int,int> hash_map;
        for(size_t i=0;i<nums.size();++i)
        
            hash_map[nums[i]]=i;
        
        for(size_t j=0;j<nums.size();++j)
        
            if(hash_map.count(target-nums[j])!=0&&j!=hash_map[target-nums[j]])
            
                result.push_back(j);
                result.push_back(hash_map[target-nums[j]]);
                break;
                       
        
        return result;
    

人家根本不用检查自身是否重复！totally make sense！本来就不用检查，因为第一个for循环中添加元素时重复元素的下标会覆盖之前的，而第二个for循环中恰好可以考虑到之前的下标。

 

再研究一下用时0ms的代码：

vector<int> twoSum(vector<int>& nums, int target) 
        vector<int> result;
        if(nums.size() == 0)
            return result;
        unordered_map<int, int> table;
        for(int i=0; i<nums.size(); i++)
            if(table.find(target - nums[i]) != table.end())
                result.push_back(table[target - nums[i]]);
                result.push_back(i);
                break;
            
            else
                table.insert(pair<int, int> (nums[i], i));
        
        return result;
    

非常巧妙，使用了unordered_map减少了一个for循环。

但是，我连unordered_map在标准库里都不知道，更别谈用它了。所以，先把标准库中重要的部分多了解了解。

完毕。