1. 两数之和 - 力扣（LeetCode）

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

解法1：暴力排序，两个for循环暴力遍历数组

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

                    return result;
                }
            }
        }
        return result;
    }
};

解法2：哈希表来解决问题

我们利用map容器来存储已经遍历过的数字以及下标，每一次在待遍历数组中得到新的数字时，我们就在map容器中搜索有没有已经便利过的数字与新得数字相加值等于target，如果有我们就输出。

知识点：因为map容器为我们提供了搜索内部数据的find函数，因此我们把key设为数字，把value设为下标，这样便于搜索。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int>result;
        map<int,int>d1;
        for(int i=0;i<nums.size();i++)
        {
          d1.insert(pair<int,int>(nums[i],i));
          int findnums=target-nums[i];
          
          auto a=d1.find(findnums);

          if(a!=d1.end()&&a->second!=i)
          {
              result.push_back(i);
              result.push_back(a->second);
              return result;
          }
          
        }
          return result;
    }
    
};

454. 四数相加 II - 力扣（LeetCode）

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

暴力解法：
存在超时问题，过不了最后一个测试用例。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, 
                     vector<int>& nums3, vector<int>& nums4) {
        int count = 0;
        for(int i=0; i<nums1.size(); i++){
            for(int j=0; j<nums2.size(); j++){
                for(int k=0; k<nums3.size(); k++){
                    for(int l=0; l<nums4.size(); l++){
                        if(nums1[i]+nums2[j]+nums3[k]+nums4[l] == 0){
                            count++;
                        }
                    }
                }
            }
        }
        return count;
    }
};

哈希表解法：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, 
                     vector<int>& nums3, vector<int>& nums4) {
        int count = 0;
        map<int ,int>ab;
        for(int i=0;i<nums1.size();i++)
        {
            for(int j=0;j<nums2.size();j++)
            {
              int a=nums1[i]+nums2[j];
              ab[a]++;
            }
        }
        for(int n=0;n<nums3.size();n++)
        {
            for(int m=0;m<nums4.size();m++)
            {
                int c=nums3[n]+nums4[m];
                
              if (ab.find(0 - (nums3[n] + nums4[m])) != ab.end()) {
                    count += ab[0 - (nums3[n] + nums4[m])];
                }
            }
        }
        
        return count;
    }
};