- 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
解释：
两个元组如下：
- (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
<
=
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;
}
};
运行结果如下：
扫一扫
200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
