力扣水题：找规律、计算
目录
252. 会议室
253. 会议室 II
258. 各位相加
263. 丑数
319. 灯泡开关
672. 灯泡开关 Ⅱ
1093. 大样本统计
1133. 最大唯一数
1150. 检查一个数是否在数组中占绝大多数
1151. 最少交换次数来组合所有的 1
1196. 最多可以买到的苹果数量
1213. 三个有序数组的交集
1228. 等差数列中缺失的数字
1663. 具有给定数值的最小字符串
1664. 生成平衡数组的方案数
1732. 找到最高海拔
1742. 盒子中小球的最大数量
1752. 检查数组是否经排序和轮转得到
1828. 统计一个圆中点的数目
2180. 统计各位数字之和为偶数的整数个数
2303. 计算应缴税款总额
2319. 判断矩阵是否是一个 X 矩阵
2481. 分割圆的最少切割次数
2544. 交替数字和
2600. K 件物品的最大和
2679. 矩阵中的和
252. 会议室
给定一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，请你判断一个人是否能够参加这里面的全部会议。
示例 1：
输入：intervals = [[0,30],[5,10],[15,20]]
输出：false
示例 2：
输入：intervals = [[7,10],[2,4]]
输出：true
提示：
0 <= intervals.length <= 104
intervals[i].length == 2
0 <= starti < endi <= 106
bool cmp(vector x, vector y)
{
return x[0] < y[0];
}
class Solution {
public:
bool canAttendMeetings(vector>& v) {
sort(v.begin(), v.end(), cmp);
for (int i = 1; i < v.size(); i++)if (v[i - 1][1] > v[i][0])return false;
return true;
}
}; 253. 会议室 II
给你一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，返回 所需会议室的最小数量 。
示例 1：
输入：intervals = [[0,30],[5,10],[15,20]]
输出：2
示例 2：
输入：intervals = [[7,10],[2,4]]
输出：1
提示：
1 <= intervals.length <= 104
0 <= starti < endi <= 106
struct Node {
int t;
int flag;
};
bool cmp(Node n1, Node n2)
{
if (n1.t == n2.t)return n1.flag > n2.flag;
return n1.t < n2.t;
}
class Solution {
public:
int minMeetingRooms(vector>& v) {
vectorns;
for (auto &vi : v)ns.push_back({ vi[0],0 }), ns.push_back({ vi[1],1 });
sort(ns.begin(), ns.end(), cmp);
int ans = 0, k = 0;
for (auto &ni : ns) {
if (ni.flag == 0)k++;
else k--;
ans = max(ans, k);
}
return ans;
}
}; 258. 各位相加
题目：
给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。
示例:
输入: 38
输出: 2
解释: 各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。 由于 2 是一位数，所以返回 2。
进阶:
你可以不使用循环或者递归，且在 O(1) 时间复杂度内解决这个问题吗？
class Solution {
public:
int addDigits(int num) {
int ans = num % 9;
return ans ? ans : 9;
}
};263. 丑数
题目：
编写一个程序判断给定的数是否为丑数。
丑数就是只包含质因数 2, 3, 5 的正整数。
示例 1:
输入: 6
输出: true
解释: 6 = 2 × 3
示例 2:
输入: 8
输出: true
解释: 8 = 2 × 2 × 2
示例 3:
输入: 14
输出: false
解释: 14 不是丑数，因为它包含了另外一个质因数 7。
说明：
1 是丑数。
输入不会超过 32 位有符号整数的范围: [−231, 231 − 1]。
代码：
class Solution {
public:
bool isUgly(int num) {
if(num<=0)return false;
while(num%2==0)num/=2;
while(num%3==0)num/=3;
while(num%5==0)num/=5;
return (num==1);
}
};319. 灯泡开关
题目：
初始时有 n 个灯泡关闭。 第 1 轮，你打开所有的灯泡。 第 2 轮，每两个灯泡你关闭一次。 第 3 轮，每三个灯泡切换一次开关（如果关闭则开启，如果开启则关闭）。第 i 轮，每 i 个灯泡切换一次开关。 对于第 n 轮，你只切换最后一个灯泡的开关。 找出 n 轮后有多少个亮着的灯泡。
示例:
输入: 3
输出: 1
解释:
初始时, 灯泡状态 [关闭, 关闭, 关闭].
第一轮后, 灯泡状态 [开启, 开启, 开启].
第二轮后, 灯泡状态 [开启, 关闭, 开启].
第三轮后, 灯泡状态 [开启, 关闭, 关闭].
你应该返回 1，因为只有一个灯泡还亮着。
代码：
class Solution {
public:
int bulbSwitch(int n) {
return int(sqrt(n));
}
};672. 灯泡开关 Ⅱ
房间中有 n 只已经打开的灯泡，编号从 1 到 n 。墙上挂着 4 个开关 。
这 4 个开关各自都具有不同的功能，其中：
开关 1 ：反转当前所有灯的状态（即开变为关，关变为开）
开关 2 ：反转编号为偶数的灯的状态（即 0, 2, 4, ...）
开关 3 ：反转编号为奇数的灯的状态（即 1, 3, ...）
开关 4 ：反转编号为 j = 3k + 1 的灯的状态，其中 k = 0, 1, 2, ...（即 1, 4, 7, 10, ...）
你必须 恰好 按压开关 presses 次。每次按压，你都需要从 4 个开关中选出一个来执行按压操作。
给你两个整数 n 和 presses ，执行完所有按压之后，返回 不同可能状态 的数量。
示例 1：
输入：n = 1, presses = 1
输出：2
解释：状态可以是：
- 按压开关 1 ，[关]
- 按压开关 2 ，[开]
示例 2：
输入：n = 2, presses = 1
输出：3
解释：状态可以是：
- 按压开关 1 ，[关, 关]
- 按压开关 2 ，[开, 关]
- 按压开关 3 ，[关, 开]
示例 3：
输入：n = 3, presses = 1
输出：4
解释：状态可以是：
- 按压开关 1 ，[关, 关, 关]
- 按压开关 2 ，[关, 开, 关]
- 按压开关 3 ，[开, 关, 开]
- 按压开关 4 ，[关, 开, 开]
提示：
1 <= n <= 1000
0 <= presses <= 1000
class Solution {
public:
int flipLights(int n, int presses) {
if (presses == 0)return 1;
if (n ==1)return 2;
if (n == 2)return 4 - presses % 2;
if (presses ==1)return 4;
if (presses == 2)return 7;
return 8;
}
};
1093. 大样本统计
我们对 0 到 255 之间的整数进行采样，并将结果存储在数组 count 中：count[k] 就是整数 k 在样本中出现的次数。
计算以下统计数据:
minimum：样本中的最小元素。maximum：样品中的最大元素。mean：样本的平均值，计算为所有元素的总和除以元素总数。median：- 如果样本的元素个数是奇数，那么一旦样本排序后，中位数
median就是中间的元素。 - 如果样本中有偶数个元素，那么中位数
median就是样本排序后中间两个元素的平均值。
- 如果样本的元素个数是奇数，那么一旦样本排序后，中位数
mode：样本中出现次数最多的数字。保众数是 唯一 的。
以浮点数数组的形式返回样本的统计信息 [minimum, maximum, mean, median, mode] 。与真实答案误差在 10-5 内的答案都可以通过。
示例 1：
输入：count = [0,1,3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] 输出：[1.00000,3.00000,2.37500,2.50000,3.00000] 解释：用count表示的样本为[1,2,2,2,3,3,3,3]。 最小值和最大值分别为1和3。 均值是(1+2+2+2+3+3+3+3) / 8 = 19 / 8 = 2.375。 因为样本的大小是偶数，所以中位数是中间两个元素2和3的平均值，也就是2.5。 众数为3，因为它在样本中出现的次数最多。
示例 2：
输入：count = [0,4,3,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] 输出：[1.00000,4.00000,2.18182,2.00000,1.00000] 解释：用count表示的样本为[1,1,1,1,2,2,3,3,3,4,4]。 最小值为1，最大值为4。 平均数是(1+1+1+1+2+2+2+3+3+4+4)/ 11 = 24 / 11 = 2.18181818…(为了显示，输出显示了整数2.18182)。 因为样本的大小是奇数，所以中值是中间元素2。 众数为1，因为它在样本中出现的次数最多。
提示：
count.length == 2560 <= count[i] <= 1091 <= sum(count) <= 109-
count的众数是 唯一 的
class Solution {
public:
vector sampleStats(vector& count) {
int minid = 0, maxid = 0, num = 0;
double s = 0;
for (int i = 0; i <= 255; i++) {
if (count[i] == 0)continue;
if (count[minid]==0)minid = i;
maxid = i;
num += count[i], s += i * 1.0 * count[i];
}
vectorans{ minid * 1.0,maxid * 1.0 ,s / num };
int num2 = 0, median = 0, mode = 0;
for (int i = 0; i <= 255; i++) {
if (count[i] == 0)continue;
if (num2 < (num + 1) / 2 && num2 + count[i] >= (num + 1) / 2)median+= i;
if (num2 < num / 2 + 1 && num2 + count[i] >= num / 2 + 1)median += i;
num2 += count[i];
if (count[mode] < count[i])mode = i;
}
ans.push_back(median / 2.0);
ans.push_back(mode);
return ans;
}
}; 1133. 最大唯一数
给你一个整数数组 A，请找出并返回在该数组中仅出现一次的最大整数。
如果不存在这个只出现一次的整数，则返回 -1。
示例 1：
输入：[5,7,3,9,4,9,8,3,1] 输出：8 解释： 数组中最大的整数是 9，但它在数组中重复出现了。而第二大的整数是 8，它只出现了一次，所以答案是 8。
示例 2：
输入：[9,9,8,8] 输出：-1 解释： 数组中不存在仅出现一次的整数。
提示：
1 <= A.length <= 20000 <= A[i] <= 1000
class Solution {
public:
int largestUniqueNumber(vector& nums) {
mapm;
for(auto x:nums)m[x]++;
int ans=-1;
for(auto p:m)if(p.second==1)ans=p.first;
return ans;
}
}; 1150. 检查一个数是否在数组中占绝大多数
给出一个按 非递减 顺序排列的数组 nums，和一个目标数值 target。假如数组 nums 中绝大多数元素的数值都等于 target，则返回 True，否则请返回 False。
所谓占绝大多数，是指在长度为 N 的数组中出现必须 超过 N/2 次。
示例 1：
输入：nums = [2,4,5,5,5,5,5,6,6], target = 5 输出：true 解释： 数字 5 出现了 5 次，而数组的长度为 9。 所以，5 在数组中占绝大多数，因为 5 次 > 9/2。
示例 2：
输入：nums = [10,100,101,101], target = 101 输出：false 解释： 数字 101 出现了 2 次，而数组的长度是 4。 所以，101 不是 数组占绝大多数的元素，因为 2 次 = 4/2。
提示：
1 <= nums.length <= 10001 <= nums[i] <= 10^91 <= target <= 10^9
class Solution {
public:
bool isMajorityElement(vector& nums, int target) {
int n=0;
for(auto x:nums)n+=(x==target);
return n*2>nums.size();
}
}; 1151. 最少交换次数来组合所有的 1
给出一个二进制数组 data，你需要通过交换位置，将数组中 任何位置 上的 1 组合到一起，并返回所有可能中所需 最少的交换次数。
示例 1:
输入: data = [1,0,1,0,1] 输出: 1 解释: 有三种可能的方法可以把所有的 1 组合在一起： [1,1,1,0,0]，交换 1 次； [0,1,1,1,0]，交换 2 次； [0,0,1,1,1]，交换 1 次。 所以最少的交换次数为 1。
示例 2:
输入：data = [0,0,0,1,0] 输出：0 解释： 由于数组中只有一个 1，所以不需要交换。
示例 3:
输入：data = [1,0,1,0,1,0,0,1,1,0,1] 输出：3 解释： 交换 3 次，一种可行的只用 3 次交换的解决方案是 [0,0,0,0,0,1,1,1,1,1,1]。
示例 4:
输入: data = [1,0,1,0,1,0,1,1,1,0,1,0,0,1,1,1,0,0,1,1,1,0,1,0,1,1,0,0,0,1,1,1,1,0,0,1] 输出: 8
提示:
1 <= data.length <= 105data[i]==0or1.
class Solution {
public:
int minSwaps(vector& data) {
int num=0,s=0,ans=data.size();
for(auto x:data)num+=(x==1);
for(int i=0;i=num)s-=data[i-num];
ans=min(ans,num-s);
}
return ans;
}
}; 1196. 最多可以买到的苹果数量
你有一些苹果和一个可以承载 5000 单位重量的篮子。
给定一个整数数组 weight ，其中 weight[i] 是第 i 个苹果的重量，返回 你可以放入篮子的最大苹果数量 。
示例 1：
输入：weight = [100,200,150,1000] 输出：4 解释：所有 4 个苹果都可以装进去，因为它们的重量之和为 1450。
示例 2：
输入：weight = [900,950,800,1000,700,800] 输出：5 解释：6 个苹果的总重量超过了 5000，所以我们只能从中任选 5 个。
提示：
1 <= weight.length <= 1031 <= weight[i] <= 103
class Solution {
public:
int maxNumberOfApples(vector& weight) {
sort(weight.begin(),weight.end());
int s=5000;
for(int i=0;i 1213. 三个有序数组的交集
给出三个均为 严格递增排列 的整数数组 arr1，arr2 和 arr3。返回一个由 仅 在这三个数组中 同时出现 的整数所构成的有序数组。
示例 1：
输入: arr1 = [1,2,3,4,5], arr2 = [1,2,5,7,9], arr3 = [1,3,4,5,8] 输出: [1,5] 解释: 只有 1 和 5 同时在这三个数组中出现.
示例 2:
输入: arr1 = [197,418,523,876,1356], arr2 = [501,880,1593,1710,1870], arr3 = [521,682,1337,1395,1764] 输出: []
提示：
1 <= arr1.length, arr2.length, arr3.length <= 10001 <= arr1[i], arr2[i], arr3[i] <= 2000
class Solution {
public:
vector arraysIntersection(vector& arr1, vector& arr2, vector& arr3) {
arr1=GetSameData(arr1,arr2);
return GetSameData(arr1,arr3);
}
}; 1228. 等差数列中缺失的数字
在某个数组 arr 中，值符合等差数列的数值规律：在 0 <= i < arr.length - 1 的前提下，arr[i+1] - arr[i] 的值都相等。
我们会从该数组中删除一个 既不是第一个 也 不是最后一个的值，得到一个新的数组 arr。
给你这个缺值的数组 arr，返回 被删除的那个数 。
示例 1：
输入：arr = [5,7,11,13] 输出：9 解释：原来的数组是 [5,7,9,11,13]。
示例 2：
输入：arr = [15,13,12] 输出：14 解释：原来的数组是 [15,14,13,12]。
提示：
3 <= arr.length <= 10000 <= arr[i] <= 105- 给定的数组 保证 是一个有效的数组。
class Solution {
public:
int missingNumber(vector& arr) {
int dif = (arr[arr.size() - 1] - arr[0]) / int(arr.size());
for (int i = 1; i < arr.size(); i++)if (arr[i] != arr[i - 1] + dif)return arr[i - 1] + dif;
return arr[0];
}
}; 1663. 具有给定数值的最小字符串
小写字符 的 数值 是它在字母表中的位置（从 1 开始），因此 a 的数值为 1 ，b 的数值为 2 ，c 的数值为 3 ，以此类推。
字符串由若干小写字符组成，字符串的数值 为各字符的数值之和。例如，字符串 "abe" 的数值等于 1 + 2 + 5 = 8 。
给你两个整数 n 和 k 。返回 长度 等于 n 且 数值 等于 k 的 字典序最小 的字符串。
注意，如果字符串 x 在字典排序中位于 y 之前，就认为 x 字典序比 y 小，有以下两种情况：
x 是 y 的一个前缀；
如果 i 是 x[i] != y[i] 的第一个位置，且 x[i] 在字母表中的位置比 y[i] 靠前。
示例 1：
输入：n = 3, k = 27
输出："aay"
解释：字符串的数值为 1 + 1 + 25 = 27，它是数值满足要求且长度等于 3 字典序最小的字符串。
示例 2：
输入：n = 5, k = 73
输出："aaszz"
提示：
1 <= n <= 105
n <= k <= 26 * n
class Solution {
public:
string getSmallestString(int n, int k) {
int x=n-1-(k-n)/25;
k-=x;
string ans(n,'a');
for(int i=x+1;i1664. 生成平衡数组的方案数
给你一个整数数组 nums 。你需要选择 恰好 一个下标（下标从 0 开始）并删除对应的元素。请注意剩下元素的下标可能会因为删除操作而发生改变。
比方说，如果 nums = [6,1,7,4,1] ，那么：
选择删除下标 1 ，剩下的数组为 nums = [6,7,4,1] 。
选择删除下标 2 ，剩下的数组为 nums = [6,1,4,1] 。
选择删除下标 4 ，剩下的数组为 nums = [6,1,7,4] 。
如果一个数组满足奇数下标元素的和与偶数下标元素的和相等，该数组就是一个 平衡数组 。
请你返回删除操作后，剩下的数组 nums 是 平衡数组 的 方案数 。
示例 1：
输入：nums = [2,1,6,4]
输出：1
解释：
删除下标 0 ：[1,6,4] -> 偶数元素下标为：1 + 4 = 5 。奇数元素下标为：6 。不平衡。
删除下标 1 ：[2,6,4] -> 偶数元素下标为：2 + 4 = 6 。奇数元素下标为：6 。平衡。
删除下标 2 ：[2,1,4] -> 偶数元素下标为：2 + 4 = 6 。奇数元素下标为：1 。不平衡。
删除下标 3 ：[2,1,6] -> 偶数元素下标为：2 + 6 = 8 。奇数元素下标为：1 。不平衡。
只有一种让剩余数组成为平衡数组的方案。
示例 2：
输入：nums = [1,1,1]
输出：3
解释：你可以删除任意元素，剩余数组都是平衡数组。
示例 3：
输入：nums = [1,2,3]
输出：0
解释：不管删除哪个元素，剩下数组都不是平衡数组。
提示：
1 <= nums.length <= 105
1 <= nums[i] <= 104
class Solution {
public:
int waysToMakeFair(vector& nums) {
if (nums.size() < 2)return 1;
vector v1 = dif(nums);
vector v2 = dif(Frev(nums));
int x = nums.size() % 2 ? -1 : 1, ans = 0;
for (int i = 0; i <= nums.size()-3; i++)if (v1[i] + v2[nums.size()-i-3] * x == 0)ans++;
if (v1[nums.size()-2] == 0)ans++;
if (v2[nums.size() - 2] == 0)ans++;
return ans;
}
vector dif(const vector &v)
{
vectorans = v;
for (int i = 1; i < v.size(); i++)ans[i] = i % 2 ? ans[i - 1] - ans[i] : ans[i - 1] + ans[i];
return ans;
}
}; 1732. 找到最高海拔
有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。
给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 <= i < n）。请你返回 最高点的海拔 。
示例 1：
输入：gain = [-5,1,5,0,-7] 输出：1 解释：海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。
示例 2：
输入：gain = [-4,-3,-2,-1,4,3,2] 输出：0 解释：海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。
提示：
n == gain.length1 <= n <= 100-100 <= gain[i] <= 100
class Solution {
public:
int largestAltitude(vector& gain) {
int ans=0,s=0;
for(auto g:gain)s+=g,ans=max(ans,s);
return ans;
}
}; 1742. 盒子中小球的最大数量
你在一家生产小球的玩具厂工作，有 n 个小球，编号从 lowLimit 开始，到 highLimit 结束（包括 lowLimit 和 highLimit ，即 n == highLimit - lowLimit + 1）。另有无限数量的盒子，编号从 1 到 infinity 。
你的工作是将每个小球放入盒子中，其中盒子的编号应当等于小球编号上每位数字的和。例如，编号 321 的小球应当放入编号 3 + 2 + 1 = 6 的盒子，而编号 10 的小球应当放入编号 1 + 0 = 1 的盒子。
给你两个整数 lowLimit 和 highLimit ，返回放有最多小球的盒子中的小球数量。如果有多个盒子都满足放有最多小球，只需返回其中任一盒子的小球数量。
示例 1：
输入：lowLimit = 1, highLimit = 10 输出：2 解释： 盒子编号：1 2 3 4 5 6 7 8 9 10 11 ... 小球数量：2 1 1 1 1 1 1 1 1 0 0 ... 编号 1 的盒子放有最多小球，小球数量为 2 。
示例 2：
输入：lowLimit = 5, highLimit = 15 输出：2 解释： 盒子编号：1 2 3 4 5 6 7 8 9 10 11 ... 小球数量：1 1 1 1 2 2 1 1 1 0 0 ... 编号 5 和 6 的盒子放有最多小球，每个盒子中的小球数量都是 2 。
示例 3：
输入：lowLimit = 19, highLimit = 28 输出：2 解释： 盒子编号：1 2 3 4 5 6 7 8 9 10 11 12 ... 小球数量：0 1 1 1 1 1 1 1 1 2 0 0 ... 编号 10 的盒子放有最多小球，小球数量为 2 。
提示：
1 <= lowLimit <= highLimit <= 105
class Solution {
public:
int countBalls(int lowLimit, int highLimit) {
mapm;
int ans=0;
for(int x=lowLimit;x<=highLimit;x++)ans=max(ans,++m[id(x)]);
return ans;
}
int id(int x)
{
int ans=0;
while(x)ans+=x%10,x/=10;
return ans;
}
}; 1752. 检查数组是否经排序和轮转得到
给你一个数组 nums 。nums 的源数组中，所有元素与 nums 相同，但按非递减顺序排列。
如果 nums 能够由源数组轮转若干位置（包括 0 个位置）得到，则返回 true ；否则，返回 false 。
源数组中可能存在 重复项 。
注意：我们称数组 A 在轮转 x 个位置后得到长度相同的数组 B ，当它们满足 A[i] == B[(i+x) % A.length] ，其中 % 为取余运算。
示例 1：
输入：nums = [3,4,5,1,2] 输出：true 解释：[1,2,3,4,5] 为有序的源数组。 可以轮转 x = 3 个位置，使新数组从值为 3 的元素开始：[3,4,5,1,2] 。
示例 2：
输入：nums = [2,1,3,4] 输出：false 解释：源数组无法经轮转得到 nums 。
示例 3：
输入：nums = [1,2,3] 输出：true 解释：[1,2,3] 为有序的源数组。 可以轮转 x = 0 个位置（即不轮转）得到 nums 。
提示：
1 <= nums.length <= 1001 <= nums[i] <= 100
class Solution {
public:
bool check(vector& nums) {
int x=1;
for(int i=1;i<=nums.size();i++)if(nums[i%nums.size()] 1828. 统计一个圆中点的数目
给你一个数组 points ，其中 points[i] = [xi, yi] ，表示第 i 个点在二维平面上的坐标。多个点可能会有 相同 的坐标。
同时给你一个数组 queries ，其中 queries[j] = [xj, yj, rj] ，表示一个圆心在 (xj, yj) 且半径为 rj 的圆。
对于每一个查询 queries[j] ，计算在第 j 个圆 内 点的数目。如果一个点在圆的 边界上 ，我们同样认为它在圆 内 。
请你返回一个数组 answer ，其中 answer[j]是第 j 个查询的答案。
示例 1：
输入：points = [[1,3],[3,3],[5,3],[2,2]], queries = [[2,3,1],[4,3,1],[1,1,2]]
输出：[3,2,2]
解释：所有的点和圆如上图所示。
queries[0] 是绿色的圆，queries[1] 是红色的圆，queries[2] 是蓝色的圆。
示例 2：
输入：points = [[1,1],[2,2],[3,3],[4,4],[5,5]], queries = [[1,2,2],[2,2,2],[4,3,2],[4,3,3]]
输出：[2,3,2,4]
解释：所有的点和圆如上图所示。
queries[0] 是绿色的圆，queries[1] 是红色的圆，queries[2] 是蓝色的圆，queries[3] 是紫色的圆。
提示：
1 <= points.length <= 500
points[i].length == 2
0 <= xi, yi <= 500
1 <= queries.length <= 500
queries[j].length == 3
0 <= xj, yj <= 500
1 <= rj <= 500
所有的坐标都是整数。
class Solution {
public:
vector countPoints(vector>& points, vector>& queries) {
vectorret;
for(auto q:queries){
int ans=0;
for(auto p:points){
if((p[0]-q[0])*(p[0]-q[0])+(p[1]-q[1])*(p[1]-q[1])<=q[2]*q[2])ans++;
}
ret.push_back(ans);
}
return ret;
}
}; 2180. 统计各位数字之和为偶数的整数个数
给你一个正整数 num ，请你统计并返回 小于或等于 num 且各位数字之和为 偶数 的正整数的数目。
正整数的 各位数字之和 是其所有位上的对应数字相加的结果。
示例 1：
输入：num = 4
输出：2
解释：
只有 2 和 4 满足小于等于 4 且各位数字之和为偶数。
示例 2：
输入：num = 30
输出：14
解释：
只有 14 个整数满足小于等于 30 且各位数字之和为偶数，分别是：
2、4、6、8、11、13、15、17、19、20、22、24、26 和 28 。
提示：
1 <= num <= 1000
class Solution {
public:
int countEven(int num) {
int x=0,a=num-num%10;
while(a)x+=a%10,a/=10;
return num/2-(x%2==1 && num%2==0);
}
};2303. 计算应缴税款总额
给你一个下标从 0 开始的二维整数数组 brackets ，其中 brackets[i] = [upperi, percenti] ，表示第 i 个税级的上限是 upperi ，征收的税率为 percenti 。税级按上限 从低到高排序（在满足 0 < i < brackets.length 的前提下，upperi-1 < upperi）。
税款计算方式如下：
不超过 upper0 的收入按税率 percent0 缴纳
接着 upper1 - upper0 的部分按税率 percent1 缴纳
然后 upper2 - upper1 的部分按税率 percent2 缴纳
以此类推
给你一个整数 income 表示你的总收入。返回你需要缴纳的税款总额。与标准答案误差不超 10-5 的结果将被视作正确答案。
示例 1：
输入：brackets = [[3,50],[7,10],[12,25]], income = 10
输出：2.65000
解释：
前 $3 的税率为 50% 。需要支付税款 $3 * 50% = $1.50 。
接下来 $7 - $3 = $4 的税率为 10% 。需要支付税款 $4 * 10% = $0.40 。
最后 $10 - $7 = $3 的税率为 25% 。需要支付税款 $3 * 25% = $0.75 。
需要支付的税款总计 $1.50 + $0.40 + $0.75 = $2.65 。
示例 2：
输入：brackets = [[1,0],[4,25],[5,50]], income = 2
输出：0.25000
解释：
前 $1 的税率为 0% 。需要支付税款 $1 * 0% = $0 。
剩下 $1 的税率为 25% 。需要支付税款 $1 * 25% = $0.25 。
需要支付的税款总计 $0 + $0.25 = $0.25 。
示例 3：
输入：brackets = [[2,50]], income = 0
输出：0.00000
解释：
没有收入，无需纳税，需要支付的税款总计 $0 。
提示：
1 <= brackets.length <= 100
1 <= upperi <= 1000
0 <= percenti <= 100
0 <= income <= 1000
upperi 按递增顺序排列
upperi 中的所有值 互不相同
最后一个税级的上限大于等于 income
class Solution {
public:
double calculateTax(vector>& brackets, int income) {
int ans=0,bf=0;
for(auto v:brackets){
ans+=min(v[0]-bf,income)*v[1];
income=max(income-v[0]+bf,0);
bf=v[0];
}
return ans*0.01;
}
}; 2319. 判断矩阵是否是一个 X 矩阵
如果一个正方形矩阵满足下述 全部 条件，则称之为一个 X 矩阵 ：
矩阵对角线上的所有元素都 不是 0
矩阵中所有其他元素都是 0
给你一个大小为 n x n 的二维整数数组 grid ，表示一个正方形矩阵。如果 grid 是一个 X 矩阵 ，返回 true ；否则，返回 false 。
示例 1：
输入：grid = [[2,0,0,1],[0,3,1,0],[0,5,2,0],[4,0,0,2]]
输出：true
解释：矩阵如上图所示。
X 矩阵应该满足：绿色元素（对角线上）都不是 0 ，红色元素都是 0 。
因此，grid 是一个 X 矩阵。
示例 2：
输入：grid = [[5,7,0],[0,3,1],[0,5,0]]
输出：false
解释：矩阵如上图所示。
X 矩阵应该满足：绿色元素（对角线上）都不是 0 ，红色元素都是 0 。
因此，grid 不是一个 X 矩阵。
提示：
n == grid.length == grid[i].length
3 <= n <= 100
0 <= grid[i][j] <= 105
class Solution {
public:
bool checkXMatrix(vector>& grid) {
for(int i=0;i 2481. 分割圆的最少切割次数
圆内一个 有效切割 ，符合以下二者之一：
该切割是两个端点在圆上的线段，且该线段经过圆心。
该切割是一端在圆心另一端在圆上的线段。
一些有效和无效的切割如下图所示。
给你一个整数 n ，请你返回将圆切割成相等的 n 等分的 最少 切割次数。
示例 1：
输入：n = 4
输出：2
解释：
上图展示了切割圆 2 次，得到四等分。
示例 2：
输入：n = 3
输出：3
解释：
最少需要切割 3 次，将圆切成三等分。
少于 3 次切割无法将圆切成大小相等面积相同的 3 等分。
同时可以观察到，第一次切割无法将圆切割开。
提示：
1 <= n <= 100
class Solution {
public:
int numberOfCuts(int n) {
return n>1?(n%2?n:n/2):0;
}
};2544. 交替数字和
给你一个正整数 n 。n 中的每一位数字都会按下述规则分配一个符号：
- 最高有效位 上的数字分配到 正 号。
- 剩余每位上数字的符号都与其相邻数字相反。
返回所有数字及其对应符号的和。
示例 1：
输入：n = 521 输出：4 解释：(+5) + (-2) + (+1) = 4
示例 2：
输入：n = 111 输出：1 解释：(+1) + (-1) + (+1) = 1
示例 3：
输入：n = 886996 输出：0 解释：(+8) + (-8) + (+6) + (-9) + (+9) + (-6) = 0
提示：
1 <= n <= 109
class Solution {
public:
int alternateDigitSum(int n) {
int ans=0,num=0;
while(n){
ans+=num%2?-(n%10):(n%10);
n/=10,num++;
}
return num%2?ans:-ans;
}
};2600. K 件物品的最大和
袋子中装有一些物品，每个物品上都标记着数字 1 、0 或 -1 。
给你四个非负整数 numOnes 、numZeros 、numNegOnes 和 k 。
袋子最初包含：
numOnes件标记为1的物品。numZeroes件标记为0的物品。numNegOnes件标记为-1的物品。
现计划从这些物品中恰好选出 k 件物品。返回所有可行方案中，物品上所标记数字之和的最大值。
示例 1：
输入：numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2
输出：2
解释：袋子中的物品分别标记为 {1, 1, 1, 0, 0} 。取 2 件标记为 1 的物品，得到的数字之和为 2 。
可以证明 2 是所有可行方案中的最大值。
示例 2：
输入：numOnes = 3, numZeros = 2, numNegOnes = 0, k = 4
输出：3
解释：袋子中的物品分别标记为 {1, 1, 1, 0, 0} 。取 3 件标记为 1 的物品，1 件标记为 0 的物品，得到的数字之和为 3 。
可以证明 3 是所有可行方案中的最大值。
提示：
0 <= numOnes, numZeros, numNegOnes <= 500 <= k <= numOnes + numZeros + numNegOnes
class Solution {
public:
int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {
if(k2679. 矩阵中的和
给你一个下标从 0 开始的二维整数数组 nums 。一开始你的分数为 0 。你需要执行以下操作直到矩阵变为空：
- 矩阵中每一行选取最大的一个数，并删除它。如果一行中有多个最大的数，选择任意一个并删除。
- 在步骤 1 删除的所有数字中找到最大的一个数字，将它添加到你的 分数 中。
请你返回最后的 分数 。
示例 1：
输入：nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]] 输出：15 解释：第一步操作中，我们删除 7 ，6 ，6 和 3 ，将分数增加 7 。下一步操作中，删除 2 ，4 ，5 和 2 ，将分数增加 5 。最后删除 1 ，2 ，3 和 1 ，将分数增加 3 。所以总得分为 7 + 5 + 3 = 15 。
示例 2：
输入：nums = [[1]] 输出：1 解释：我们删除 1 并将分数增加 1 ，所以返回 1 。
提示：
1 <= nums.length <= 3001 <= nums[i].length <= 5000 <= nums[i][j] <= 103
class Solution {
public:
int matrixSum(vector>& nums) {
for(int i=0;i