代码随想录算法训练营第六天| 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

454.四数相加II

1，难点：

　　1，多个数组之间，会有重复出现的数组，如果单用multiset也是会出错的

　　2，如果用mutliset，在使用 distance 找出来 equal_range的值的时候，也是会出现奇怪的错误的

2，正确思路

　　1，把重复出现的节点，次数 存放到map种，然后进行遍历

3，代码：

int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4)
{
    int result = 0;
    unordered_map<int,int> selected;
    for (int num1 : nums1)
    {
        for (int num2 : nums2)
        {
            if (selected.find(num1 + num2) == selected.end())
            {
                selected.insert(make_pair(num1 + num2, 0));
            }
            selected[num1 + num2] ++;
        }
    }

    for (int num3 : nums3)
    {
        for (int num4 : nums4)
        {
            //或许可以判断target里面有几个pair
            auto target = selected.find(-(num3 + num4));
            if (target != selected.end())
            {
                result += target->second;
            }
        }
    }

    return result;
}

 383. 赎金信

代码

// 需要让ransomNote 加上一些其他的字符 == magazine
// 思路：用滑块的思想？
// 先获得 ransomNote的长度，如果<magazine -> False
// 然后进行双指针-》快指针找到第一个相等的节点后，我们就判断是不是一样的，
// 注意这个是没有顺序的
// 存储每一个字母对应的出现次数，然后如果他小于magazine，那么就可以
bool canConstruct(string ransomNote, string magazine) {
    int ransomNoteCount[26] = {};

    for (char charItem : ransomNote)
    {
        ransomNoteCount[charItem - 'a']++;
    }
    for (char charItem : magazine)
    {
        ransomNoteCount[charItem - 'a']--;
    }

    for (int i : ransomNoteCount)
    {
        if (i > 0)
        {
            return false;
        }
    }
    return true;
}

 15. 三数之和

1,哈希法

难度：特别难

注意：

1，需要考虑 下标不同

2，相同下标，可出现在多个元组中

3，元组需要不一样

代码：

vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> result;
    sort(nums.begin(), nums.end());

    for (int i = 0; i < nums.size(); i++)
    {
        if (i > 0 && nums[i - 1] == nums[i])
            continue;
        unordered_set<int> selected;
        for (int j = i+1; j < nums.size(); j++)
        {
            if (j > i+2 && nums[j - 2] == nums[j - 1] && nums[j - 1] == nums[j])
                continue;
            auto target = selected.find(-(nums[i] + nums[j]));
            if (target != selected.end())
            {
                result.push_back({ nums[i], nums[j], -(nums[i] + nums[j]) });
                selected.erase(target);
            }
            else
            {
                selected.insert(nums[j]);
            }
        }
    }
    return result;
}

 2，双指针：

注意的点：1，left right在哪里去重

2，获得结果后 left right需要移动

代码：

//指针法，l r，如果 l = l+1 continue r = r-1 continue
vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> result;
    sort(nums.begin(), nums.end());

    for (int i = 0; i < nums.size(); i++)
    {
        if (nums[i] > 0) {
            return result;
        }

        if (i > 0 && nums[i - 1] == nums[i])
            continue;
        int left = i + 1;
        int right = nums.size() - 1;
        while (left < right)
        {
            int target = nums[i] + nums[left] + nums[right];
            if (target == 0)
            {
                result.push_back({ nums[i], nums[left],nums[right] });
                //应该在哪里放left移动的代码？ 就是放到这里，但是需要注意 left>right
                while (left<right&&nums[left] == nums[left + 1])
                    left++;
                while (left < right && nums[right] == nums[right - 1])
                    right--;

                left++;
                right--;
            }
            else if (target < 0)
            {
                left++;
            }
            else if (target > 0)
            {
                right--;
            }
        }

    }
    return result;
}

 18. 四数之和  

难点：

1，需要注意剪枝，nums[i]>targeat && nums[i]>0
2，注意可能存在溢出

需要 long num[i]+... 而不是 long(num[i] ... )

代码：

vector<vector<int>> fourSum(vector<int>& nums, int target) 
{
    vector<vector<int>> result;

    sort(nums.begin(), nums.end());

    for (int k = 0; k < nums.size(); k++)
    {
        if (nums[k] > target && nums[k] >= 0)
        {
            break;
        }

        if (k > 0 && nums[k] == nums[k - 1])
        {
            continue;
        }

        //为什么不是nums.size()-2
        for (int i = k + 1; i < nums.size(); i++)
        {
            // target>0不行么，这样的话target可能小于0
            if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0)
            {
                break;
            }

            if (i > k + 1 && nums[i] == nums[i - 1])
            {
                continue;
            }

            int left = i + 1;
            int right = nums.size() - 1;
            while (right > left)
            {
                long sumVal = (long)nums[i] + nums[k] + nums[left] + nums[right];
                if (sumVal > target)
                {
                    right--;
                }
                else if (sumVal < target)
                {
                    left++;
                }
                else
                {
                    result.push_back({ nums[i] , nums[k] , nums[left] , nums[right] });

                    while (right > left && nums[left] == nums[left + 1]) left++;
                    while (right > left && nums[right] == nums[right - 1]) right--;

                    right--;
                    left++;
                }
            }
        }
    }

    return result;
}