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

  1. 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 < = 1 0 4 1 <= n <= 10^4 1<=n<=104

还是比较简单的,代码如下:

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
解释:
两个元组如下:

  1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
  2. (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 < = n u m s 1 [ i ] , n u m s 2 [ i ] , n u m s 3 [ i ] , n u m s 4 [ i ] < = 2 28 -2^{28} <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^{28} 228<=nums1[i],nums2[i],nums3[i],nums4[i]<=228

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

#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
− 1 0 4 < = t a r g e t < = 1 0 4 -10^4 <= target <= 10^4 104<=target<=104

首先对数组进行排序,然后从前往后依次遍历数组,将遍历到的元素作为第一个元素。然后采用双指针,头指针指向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
− 1 0 9 < = n u m s [ i ] < = 1 0 9 -10^9 <= nums[i] <= 10^9 109<=nums[i]<=109
− 1 0 9 < = t a r g e t < = 1 0 9 -10^9 <= target <= 10^9 109<=target<=109

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

#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;
    }
};

运行结果如下:

在这里插入图片描述

  • 18
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cherries Man

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值