leetcode 1. 两数之和

leetcode 1：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的 两个 整数。

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

示例:

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

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

c++版本

1.暴力法

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

2.哈希表

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> result;
        map<int, int> tmp;
    
        for(int i = 0; i < nums.size(); ++i){
            tmp[nums[i]] = i;
        }
            
        for (int i = 0; i < nums.size(); ++i){
            if(tmp.count(target-nums[i]) != 0 && tmp[target-nums[i]] != i){
                result.push_back(i);
                result.push_back(tmp[target-nums[i]]);
                break;
            }
        }
        return result;
    }  
};

3.优化版的哈希方法

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> result;
        map<int, int> tmp;
    
        for (int i = 0; i < nums.size(); ++i){
            if(tmp.count(nums[i]) != 0){
                result.push_back(i);
                result.push_back(tmp[nums[i]]);
                break;
            }
            tmp[target - nums[i]] = i;
        }
        return result;
    }  
};

相似题集锦 

leetcode 15：三数之和：给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

 

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> result;
        int i=0, j = 0, k = nums.size()-1;
        
        if (nums.size() < 3) return {};
        
        sort(nums.begin(), nums.end());
        
        for (int i = 0; i < nums.size()-2; i++){ 
            
            j = i+1;
            k = nums.size()-1;
            
            while (j < k){
                if (nums[i] + nums[j] + nums[k] == 0){
                    result.push_back({nums[i], nums[j], nums[k]});
                    while (j < k && nums[j] == nums[j+1]) j++; // 去除重复
                    while (j < k && nums[k] == nums[k-1]) k--; // 去除重复
                    j++; k--; // 以当前i为基准，查看下一组
                }
                else if (nums[i] + nums[j] + nums[k] < 0) ++j; // 说明不够大
                else k--; // 说明过大
                
            }
            while (i < nums.size()-3 && nums[i] == nums[i+1]) i++; // 最后检查i，去除重复
            
        }
        
        return result;
        
            
    }
};

leetcode18 四数之和 :给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：

给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。

满足要求的四元组集合为：
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

 

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
                vector<vector<int>> res;
        int size = nums.size();
        if(size < 4){
            return res;
        }
        sort(nums.begin(),nums.end());        
        for(int i = 0; i < size - 3 ; i++){
            for(int j = i+1; j < size - 2 ; j++){//去重复
                if((i > 0 && nums[i] == nums[i-1]) || (j > i + 1 && nums[j] == nums[j-1])){
                    continue;
                }
                int l = j+1, r= size - 1;
                while(l < r){
                    int sum = nums[i] + nums[j] + nums[l] + nums[r];
                    if(sum == target){
                        // res.insert(res.begin(),{ nums[i],nums[j],nums[l],nums[r]});
                        res.push_back({ nums[i],nums[j],nums[l],nums[r]});
                        while(l < r && nums[l] == nums[l+1]) l++;
                        while(l < r && nums[r] == nums[r-1]) r--;
                        l++;
                        r--;
                    }else if(sum > target){
                        r--;
                    }else
                        l++;
                } 
            }
        }
        return res;
        
    }
};

leetcode167 两数之和 || -输入有序数组:给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明:

    返回的下标值（index1 和 index2）不是从零开始的。

   你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

示例:

输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> result;
        int begin = 0;
        int end = numbers.size()-1;
        while(begin < end){
            if(numbers[begin] + numbers[end] ==target){
                result.push_back(begin+1);
                result.push_back(end+1);
                return result;
            }
            else if(numbers[begin] + numbers[end] < target){
                ++begin;
            }
            else{
                --end;
            }
        }
        return result;
    }
};

leetcode560 和为K的子数组:给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。
说明 :

1.数组的长度为 [1, 20,000]。
2.数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int sum = 0;
        int n = nums.size();
        unordered_map<int, int> m;
        int count = 0;
        m[0] = 1;
        for(int i = 0; i < n; ++i){
            sum += nums[i];
            count += m[sum -k];
            m[sum] += 1;
        }
        return count;
    }
};

 这种解法比较巧妙。用map建立hash表，记录和为sum出现的次数。设b=sum[i]-k，那么b如果不是连续子数组的和则出现次数为0，否则为实际出现次数，然后累加即可。