leetcode刷题记录30（2024-1-11）【Fizz Buzz(小模拟) | 四数相加 II(数组、哈希) | 最接近的三数之和(排序、双指针) | 四数之和(排序、双指针)】

Cherries Man

已于 2024-03-13 11:32:45 修改

阅读量855

点赞数 18

分类专栏：刷题笔记文章标签： leetcode 哈希算法算法 c++

于 2024-03-13 11:32:30 首次发布

本文链接：https://blog.csdn.net/myf_666/article/details/135523197

版权

刷题笔记专栏收录该内容

53 篇文章 0 订阅

订阅专栏

Fizz Buzz

给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1 开始）返回结果，其中：

answer[i] == “FizzBuzz” 如果 i 同时是 3 和 5 的倍数。
answer[i] == “Fizz” 如果 i 是 3 的倍数。
answer[i] == “Buzz” 如果 i 是 5 的倍数。
answer[i] == i （以字符串形式）如果上述条件全不满足。

示例 1：

输入：n = 3
输出：[“1”,“2”,“Fizz”]
示例 2：

输入：n = 5
输出：[“1”,“2”,“Fizz”,“4”,“Buzz”]
示例 3：

输入：n = 15
输出：[“1”,“2”,“Fizz”,“4”,“Buzz”,“Fizz”,“7”,“8”,“Fizz”,“Buzz”,“11”,“Fizz”,“13”,“14”,“FizzBuzz”]

提示：

$1 <= n <= 10^4$

还是比较简单的，代码如下：

class Solution
{
public:
    vector<string> fizzBuzz(int n)
    {
        vector<string> ans(n);
        for (int i = 1; i <= n; i++)
        {
            if (i % 3 == 0 && i % 5 == 0)
            {
                ans[i - 1] = "FizzBuzz";
            }
            else if (i % 3 == 0)
            {
                ans[i - 1] = "Fizz";
            }
            else if (i % 5 == 0)
            {
                ans[i - 1] = "Buzz";
            }
            else
            {
                ans[i - 1] = to_string(i);
            }
        }
        return ans;
    }
};

454. 四数相加 II

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

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

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]

输出：2
解释：
两个元组如下：

(0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

提示：

n == nums1.length
n == nums2.length
n == nums3.length
n == nums4.length
1 <= n <= 200
$2^{28} <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^{28}$

主要思路是，通过空间来换时间，利用哈希来存储两个数组组合的可能取值，把 $n^4$ 的复杂度降到了 $n^2$ 。同时，可以将数组转为哈希，来记录数组元素出现的次数。

#include <vector>
#include <unordered_map>

using namespace std;

class Solution
{
public:
    int fourSumCount(vector<int> &nums1, vector<int> &nums2, vector<int> &nums3, vector<int> &nums4)
    {
        unordered_map<int, int> mp1, mp2, mp3, mp4, mp12;
        for (int i = 0; i < nums1.size(); i++)
        {
            mp1[nums1[i]]++;
        }
        for (int i = 0; i < nums2.size(); i++)
        {
            mp2[nums2[i]]++;
        }
        for (int i = 0; i < nums3.size(); i++)
        {
            mp3[nums3[i]]++;
        }
        for (int i = 0; i < nums4.size(); i++)
        {
            mp4[nums4[i]]++;
        }
        int res = 0;
        for (auto it1 : mp1)
        {
            for (auto it2 : mp2)
            {
                mp12[it1.first + it2.first] += it1.second * it2.second;
            }
        }

        for (auto it3 : mp3)
        {
            for (auto it4 : mp4)
            {
                int num = mp12[-(it3.first + it4.first)];
                if (num > 0)
                {
                    res += num * it3.second * it4.second;
                }
            }
        }
        return res;
    }
};

提交后，发现时间效率超过了题解。
在这里插入图片描述

16. 最接近的三数之和

给你一个长度为 n 的整数数组 nums 和一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

示例 2：

输入：nums = [0,0,0], target = 1
输出：0

提示：

3 <= nums.length <= 1000
-1000 <= nums[i] <= 1000
$10^4 <= target <= 10^4$

首先对数组进行排序，然后从前往后依次遍历数组，将遍历到的元素作为第一个元素。然后采用双指针，头指针指向i+1个元素，尾指针指向n-1个元素，根据sum的值，来移动两个指针，进而实现对res的寻找。

#include <vector>
#include <algorithm>

using namespace std;

class Solution
{
public:
    int threeSumClosest(vector<int> &nums, int target)
    {
        sort(nums.begin(), nums.end());
        int res = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < nums.size(); i++)
        {
            int j = i + 1, k = nums.size() - 1;
            while (j < k)
            {
                int sum = nums[i] + nums[j] + nums[k];
                res = abs(res - target) < abs(sum - target) ? res : sum;
                if (sum == target)
                {
                    return res;
                }
                else if (sum < target)
                {
                    j++;
                }
                else
                {
                    k--;
                }
            }
        }
        return res;
    }
};

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按任意顺序返回答案。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：

1 <= nums.length <= 200
$10^9 <= nums[i] <= 10^9$
$10^9 <= target <= 10^9$

主要思路就是双指针，遍历组合所有第一个、第二个元素的组合，然后利用双指针将第三个第四个元素的组合遍历的复杂度降低到O(n)级别，因此，就实现了 $O(n^3)$ 的时间复杂度。

#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

class Solution
{
public:
    vector<vector<int>> fourSum(vector<int> &nums, int target)
    {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++)
        {
            if (i - 1 >= 0 && nums[i - 1] == nums[i])
            {
                continue;
            }
            for (int j = i + 1; j < nums.size(); j++)
            {
                if (j - 1 >= i + 1 && nums[j - 1] == nums[j])
                {
                    continue;
                }
                int k = j + 1, l = nums.size() - 1;
                while (k < l)
                {
                    long long sum = (long long)nums[i] + nums[j] + nums[k] + nums[l];
                    if (sum == (long long)target)
                    {
                        res.push_back({nums[i], nums[j], nums[k], nums[l]});
                        int k0 = k;
                        while (k < l && nums[k0] == nums[k])
                        {
                            k++;
                        }
                        int l0 = l;
                        while (l > k && nums[l0] == nums[l])
                        {
                            l--;
                        }
                    }
                    else if (sum < (long long)target)
                    {
                        k++;
                    }
                    else if (sum > (long long)target)
                    {
                        l--;
                    }
                }
            }
        }
        return res;
    }
};

int main()
{
    vector<int> vec = {1000000000, 1000000000, 1000000000, 1000000000};
    Solution sol;
    vector<vector<int>> res = sol.fourSum(vec, 0);
    for (int i = 0; i < res.size(); i++)
    {
        for (int j = 0; j < res[i].size(); j++)
        {
            cout << res[i][j] << " ";
        }
        cout << endl;
    }
}

提交后，发现运行结果并不好，如下：

在这里插入图片描述

参考了题解的做法，发现是对遍历过程中，确定不可能的情况提前进行了剪枝，大大降低了无用的搜索，进而节约了时间。改进后的代码如下：

class Solution
{
public:
    vector<vector<int>> fourSum(vector<int> &nums, int target)
    {
        vector<vector<int>> res;
        if (nums.size() < 4)
        {
            return res;
        }
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size() - 3; i++)
        {
            if (i - 1 >= 0 && nums[i - 1] == nums[i])
            {
                continue;
            }
            if ((long long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target)
            { // 剪枝1：如果最小的组合都>target，可以结束当前循环了
                break;
            }
            if ((long long)nums[i] + nums[nums.size() - 1] + nums[nums.size() - 2] + nums[nums.size() - 3] < target)
            { // 剪枝3：如果当前最大的组合都<target，继续下一个循环
                continue;
            }
            for (int j = i + 1; j < nums.size() - 2; j++)
            {
                if (j - 1 >= i + 1 && nums[j - 1] == nums[j])
                {
                    continue;
                }
                if ((long long)nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target)
                { // 剪枝2：如果最小的组合都>target，可以结束当前循环了
                    break;
                }
                if ((long long)nums[i] + nums[j] + nums[nums.size() - 1] + nums[nums.size() - 2] < target)
                { // 剪枝4：如果当前最大的组合都<target，继续下一个循环
                    continue;
                }
                int k = j + 1, l = nums.size() - 1;
                while (k < l)
                {
                    long long sum = (long long)nums[i] + nums[j] + nums[k] + nums[l];
                    if (sum == (long long)target)
                    {
                        res.push_back({nums[i], nums[j], nums[k], nums[l]});
                        int k0 = k;
                        while (k < l && nums[k0] == nums[k])
                        {
                            k++;
                        }
                        int l0 = l;
                        while (l > k && nums[l0] == nums[l])
                        {
                            l--;
                        }
                    }
                    else if (sum < (long long)target)
                    {
                        k++;
                    }
                    else if (sum > (long long)target)
                    {
                        l--;
                    }
                }
            }
        }
        return res;
    }
};

运行结果如下：

在这里插入图片描述

Cherries Man

关注

18
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
0
评论
leetcode刷题记录30（2024-1-11）【Fizz Buzz(小模拟) | 四数相加 II(数组、哈希) | 最接近的三数之和(排序、双指针) | 四数之和(排序、双指针)】

leetcode刷题记录30（2024-1-11）【Fizz Buzz(小模拟) | 四数相加 II(数组、哈希) | 最接近的三数之和(排序、双指针) | 四数之和(排序、双指针)】
复制链接

扫一扫