随想录训练营6/60 | LC 454.四数相加II ；LC 383. 赎金信 ；LC 15. 三数之和 ；LC 18. 四数之和

LC 454.四数相加II

题目链接：LC 454.四数相加II
思路：
暴力法，遍历四个数组，统计符合规则的元组个数。
哈希法，（本题为四个数组各取一个数，比较简单；一个数组内的四数相加难，因为四个数不能重复）将数组分成两组，每组两个数组，第一组遍历两个数组组成哈希表（unordered_map），因为key为两数之和，val为和为key的个数。然后遍历第二组，每次查看哈希表中是否含有(0-sum)，若有则在数目上加上val。
代码：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        //前两个数组构成hash1
        unordered_map<int, int> hash1;
        for(int i : nums1){//因为不用保存下标所以不用下标遍历
            for(int j : nums2){
                ++hash1[i+j];
            }
        }
        //查看后两个数组中的和，并在hash1中查看是否有（0-sum）的key
        int result = 0;
        for(int x : nums3){
            for(int y : nums4){
                if(hash1.find(0-x-y)!=hash1.end()){
                    result = result + hash1[0-x-y];
                }
            }
        }
        return result;
    }
};

LC 383. 赎金信

题目链接：LC 383. 赎金信
思路：和有效字母异位词思路相似，遍历magazine得到哈希表，再遍历ransomnote将哈希表的值减一，最终遍历哈希表若里面的值小于0则false，全大于等于0为ture。
代码：

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        // int hash[26] = {0};
        vector<int> hash(26);//两个都可以
        for(char i : magazine){
            ++hash[i - 'a'];
        }
        for(char j : ransomNote){
            --hash[j - 'a'];
        }
        for(int z : hash){
            if(z<0)return false;
        }
        return true;
    }
};

LC 15. 三数之和

题目链接：LC 15. 三数之和
思路：与上面第一题不同，这个是给一个数组，三数之和为0，并且不能有重复的三元组，返回的也是多个符合规则的三元组（不是个数也不是下标）。
虽然哈希表可以去重，但是在本题目中使用哈希表去重是难以实现的。若两数之和组成哈希表，用和作为key，二元组作为value，但在加上第三项是难以判断之前是否出现过三元组，并且在最后步骤删除多余三元组也很难（时间复杂度高）；用三元组的话和暴力解法复杂度相似，并且不容易去重了。因此本题不适合用哈希法。

本题需要在遍历的时候去重，可用双指针法（实际上有三个指针）。首先把原数组进行排序（不用返回下标就可以排序）。然后设三个指针i，r，l，其中i负责遍历数组，l是从i后第一个向后遍历，r从最后一个向前遍历。若三数之和小于0则把l向后移动，大于0就将r向前移动，等于0就保存。
**重点是去重，去重，去重！！！**去重分为对i，r，l去重。
对i去重：除去数组第一个元素，若i对应的元素与上一个相同，就直接跳过（若是i与下一个元素相同就跳过，会忽略-1，-1，2这种情况）；
对r去重，当r对应元素与前一个相同时就跳过；
对l去重，当l对应元素与后一个相同时就跳过；

代码：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        //1.排序
        sort(nums.begin(), nums.end());
        //2.遍历数组
        for(int i=0; i<nums.size()-2; ++i){
            //可以加剪枝操作
            if(nums[i]>0)return result;
            //2.1 去重i
            if(i!=0 && nums[i]==nums[i-1])continue;//直接跳过进入下次循环，为什么条件可以这样写，因为&&服从短路原则，一个为false就不执后面的了
            //初始化l，r
            int l = i + 1;
            int r = nums.size() - 1;
            while(l<r){
                if(nums[i]+nums[l]+nums[r]==0){
                    result.push_back({nums[i], nums[l], nums[r]});
                    //2.2对l去重
                    while(l<r && nums[l]==nums[l+1])++l;//短路原则！！！while内的判断顺序不能换！！
                    //2.3对r去重
                    while(l<r && nums[r]==nums[r-1])--r;
                    //等于0的话两个指针都要改变
                    ++l;
                    --r;
                }
                else if(nums[i]+nums[l]+nums[r]>0)--r;
                else if(nums[i]+nums[l]+nums[r]<0)++l;
            }
        }
        return result;
    }
};

LC 18. 四数之和

题目链接：LC 18. 四数之和
思路：四数之和和三数之和思路基本相同，也是用双指针法。
首先对数组进行排序。
然后用两个for循环遍历数组，作为四数中的两个，然后用双指针遍历两个数之后的数，同样的去重手法。不过不能用上述的剪枝操作，因为target可能为负数。target为大于等于0时可以剪枝。
代码：

class Solution {
public:
        vector<vector<int>> fourSum(vector<int>& nums, int target) {
            vector<vector<int>> result;
            if(nums.size()<4)return result;
            sort(nums.begin(), nums.end());
            for(int i=0; i<nums.size()-3; ++i){
                //对i进行去重
                if(i!=0 && nums[i]==nums[i-1])continue;
                for(int j=i+1; j<nums.size()-2; ++j){
                    //对j进行去重
                    if(j!=i+1 && nums[j]==nums[j-1])continue;
                    int l = j+1;
                    int r = nums.size()-1;
                    //固定ij后，双指针开始
                    while(l<r){
                        //满足规则时
                        if((long)nums[i] + nums[j] + nums[l] + nums[r] == target){
                            result.push_back({nums[i], nums[j], nums[l], nums[r]});
                            //对l r去重
                            while(l<r && nums[l]==nums[l+1])++l;
                            while(l<r && nums[r]==nums[r-1])--r;
                            //去重后，l和r指向的值仍与之前的值相同
                            ++l;
                            --r;
                        }
                        else if((long)nums[i] + nums[j] + nums[l] + nums[r] > target)--r;
                        else if((long)nums[i] + nums[j] + nums[l] + nums[r] < target)++l;
                    }
                }
            }
            return result;
    }

总结，遍历的指针去重，不能因为指针对应的值与下一个值相等就去除，因为可能这两个值相加满足规则，因此需要比较指针对应值与上一个值是否相等；双指针去重可以用最基本的去重办法，与之后遍历的值比较，若相同就去除。

------------------------------------额外题目---------------------------------

（以上为训练营每日任务，本部分为自己刷题进度）

二叉树的层序遍历

层序遍历是广度优先遍历，之前的先序遍历，中序遍历，后序遍历都是深度优先遍历。深度优先遍历使用栈来帮助输出；广度优先遍历则用队列帮助输出。
思路：
自己的思路，从根节点进入队列，每次出队列时，保存出队列元素节点，然后让该节点的左子树，右子树节点进入队列，若为空则不用进，直到队列为空。这样可以遍历二叉树，但是不能直到树的层数。而且输出的为二维vector，这样的思路是一维的vector
随想录的思路，先根节点进入队列，每次先统计队列的长度，然后把队列的所有节点都进行以下操作（for）：保存头节点，弹出头节点，弹出的头节点的左右子树入队列。直至队列为空。
代码

class Solution{
public:
	vector<vector<int>> levelOrder(TreeNode* root){
		queue<TreeNode*> que;//创建队列
		vector<vector<int>> result;
		if(root!=nullptr)que.push(root);
		while(!que.empty()){//当队列不为空时
			int size = que.size();//统计队列长度,需保存因为队列长度在不断改变,只需弹出该层的节点个数
			vector<int> temp;//保存该层的节点
			for(int i=0; i<size; i++){//处理该层的节点
				TreeNode* cur = que.top();
				que.pop();
				temp.push_back(cur->val);
				if(cur->right!=nullptr)que.push(cur->right);
				if(cur->left!=nullptr)que.push(cur->left);
			}
			//处理完每一层要保存该层的结果
			result.push_back(temp);
		}
		return result;
	}
}