ch3_6四数相加 && ch3_7赎金信

1. 四数相加

lc454
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

例如:

输入: A = [ 1, 2] B = [-2,-1] C = [-1, 2] D = [ 0, 2] 输出: 2 解释: 两个元组如下:

(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

1.1 解题思路

思路：

1. 一采用分为两组，HashMap 存一组，另一组和 HashMap 进行比对。
2. 这样的话情况就可以分为三种：

• HashMap 存一个数组，如 A 。然后计算三个数组之和，如 BCD。时间复杂度为：$O(n)+O(n^3)，得到O(n^3)$.
• HashMap 存三个数组之和，如 ABC。然后计算一个数组，如 D。时间复杂度为：$O(n^3)+O(n)，得到O(n^3)$.
• HashMap存两个数组之和，如AB。然后计算两个数组之和，如 CD。时间复杂度为：$O(n^2)+O(n^2)，得到O(n^2)$.

3. 根据第二点我们可以得出要存两个数组算两个数组。

4. 我们以存 AB 两数组之和为例。首先求出 A 和 B 任意两数之和 sumAB，以 sumAB 为 key，sumAB 出现的次数为 value，存入 hashmap 中。

   然后计算 C 和 D 中任意两数之和的相反数 sumCD，在 hashmap 中查找是否存在 key 为 sumCD。算法时间复杂度为 $O(n^2)$。

其中关键点：

新建一个哈希容器， SumAB, 其中每一项的存储都是 <key, value>;

1. 先遍历 A，B 两个数组:
   将 两个数组中的元素和 SumAB 作为key, sumAB 出现的次数作为value;

2. 使用一个整型变量count， 用于存储 a +b +c + d = 0 出现的次数；

3. 遍历 C， D 两个数组：
   3.1 求 c,d 两数之和的 相反数， 即 -(c + d);
   3.2 在容器 SumAB 中 查找 是否存在该相反数，
   如果存在该相反数， 则将该相反数出现的次数，加入到count 中；

#include "vector"
#include "unordered_map"

using namespace std;

class Solution{
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D){
        // 新建一个哈希容器， key: 用于存放A B中两数之和， value: 用于存放该数值和出现的次数
        unordered_map<int, int>  sumAB;

        // 遍历 AB 两个数组，  <key,value>  :  <a+b, sumAB[a+b]> ;
        for(int a: A){
            for(int b: B){
                sumAB[a + b]++;
            }
        }

        int count = 0 ;  // 用于保存 a + b + c + d = 0 四数之和为0 的次数；
        // 遍历 CD  两个数组， 求出CD 其中的两数之和，  使用 该两数之和的相反数在 哈希容器中寻找，
        //  如果找到， 则 count 赋予为 该两数之和出现的次数 = 哈希容器中的 value;

        for(int c: C){
            for(int d: D){
                if( sumAB.find( 0 - (c+d))  != sumAB.end() ){
                    count += sumAB[0 - (c+d)];
                }
            }
        }

        return  count;

    }

};

2. 赎金信

lc383

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

题目要求使用字符串 $\text{magazine}$中的字符来构建新的字符串 $\text{ransomNote}$, 且$\text{magazine}$ 中的每个字符只能使用一次，

解题的关键点：
使用哈希映射的 思想， 即将 字母映射为 数组的下标；
字母a 对应数组下标0， 字母z 映射为数组下标25；

1. 只要判断 $\text{magazine}$ 中每个字母出现的次数 都大于 等于赎金信$\text{ransomNote}$ 中每个字母出现的次数；

2. 首先 如果字符串 $\text{magazine}$ 的长度小于字符串 $\text{ransomNote}$ 的长度，则$\text{magazine}$ 无法构成 $\text{ransomNote}$，此时直接返回 false。

3. 遍历杂志字符串，统计 $\text{magazine}$ 中每个英文字母的次数 $\text{cnt}[i]$，记录在数组中；

4. 再遍历统计 $\text{ransomNote}$ 中每个英文字母的次数，
   遍历过程中， 直接将$\text{ransomNote}$ 中的字母，在数组中对应的字母上， 该次数减一；
   如果该字母减一之后数值小于0， 说明杂志串中没有当前信中的字符， 则此时我们直接返回 $\text{false}$。

class Solution {
public:
    bool canConstruct(string ransomNote,  string magazine){
        // 如果杂志串的长度 小于 赎金信， 不能构成；
        if(magazine.size()  < ransomNote.size())  return false;
        
        int arr[26] = {0};

        //  先统计组成 构件 magazine， 因为magazine 构成 赎金信；
        for(int i = 0; i < magazine.size(); i++){
            arr[magazine[i] - 'a']++;

        }
        
        // 遍历赎金信中的字母， 该字符串中的字母没出现一次， 则记录数组中 对应字母的次数减一；
        for( int i = 0; i < ransomNote.size(); i++){
            arr[ransomNote[i] - 'a']--;
            
            // 当 记录数组中的 数值出现了小于0 的情况， 说明此时信中的字母 ，杂志串中不存在；
            if( arr[ransomNote[i] - 'a'] < 0)  return  false;
            
        }
        return true;

    }


};