时间复杂度为
O
(
n
)
O(n)
O(n),空间复杂度为
O
(
1
)
O(1)
O(1)。
参考代码
- Python
def solution():
n, m = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
sumA = sum(A)
sumB = sum(B)
ans = 0
for a in A:
if a == sumB - sumA:
ans += 1
print(ans)
if __name__ == "\_\_main\_\_":
solution()
- Java
import java.util.Scanner;
public class Solution {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
long[] A = new long[n];
long[] B = new long[m];
long sumA = 0;
for (int i = 0; i < n; i++) {
A[i] = scanner.nextLong();
sumA += A[i];
}
long sumB = 0;
for (int i = 0; i < m; i++) {
B[i] = scanner.nextLong();
sumB += B[i];
}
int ans = 0;
for (long a : A) {
if (a == sumB - sumA) {
ans++;
}
}
System.out.println(ans);
}
}
- Cpp
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long long> A(n), B(m);
long long sumA = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
sumA += A[i];
}
long long sumB = 0;
for (int i = 0; i < m; i++) {
cin >> B[i];
sumB += B[i];
}
int ans = 0;
for (long long a : A) {
if (a == sumB - sumA) {
ans++;
}
}
cout << ans << endl;
return 0;
}
02.切绳子
问题描述
K 小姐有
n
n
n 根绳子,从
1
1
1 到
n
n
n 编号,第
i
i
i 根绳子的长度为
a
i
a_i
ai。她希望通过切割操作,使所有绳子长度相等。每次切割操作可以选择一根长度为
s
s
s 的绳子,将其切成长度分别为
x
x
x 和
y
y
y 的两段,其中
x
x
x 和
y
y
y 均为正整数且满足
x
y
=
s
x+y=s
x+y=s。K 小姐最多进行
k
k
k 次切割操作。请你帮她判断是否可以通过不超过
k
k
k 次切割操作,使所有绳子长度相等。
输入格式
输入包含多组测试数据。第一行包含一个正整数
T
T
T(
1
≤
T
≤
1
0
4
1 \leq T \leq 10^4
1≤T≤104),表示测试数据的组数。
对于每组测试数据:
- 第一行包含两个正整数
n
n
n(
1
≤
n
<
1
0
5
1 \leq n < 10^5
1≤n<105)和
k
k
k(
0
≤
k
≤
1
0
14
0 \leq k \leq 10^{14}
0≤k≤1014),分别表示绳子的数量和最多允许的切割操作次数。
- 第二行包含
n
n
n 个正整数
a
1
,
a
2
,
…
,
a
n
a_1, a_2, \ldots, a_n
a1,a2,…,an(
1
≤
a
i
≤
1
0
9
1 \leq a_i \leq 10^9
1≤ai≤109),表示每根绳子的初始长度。
保证所有测试数据中
n
n
n 的总和不超过
1
0
5
10^5
105。
输出格式
对于每组测试数据,如果可以通过不超过
k
k
k 次切割操作使所有绳子长度相等,则输出 YES
,否则输出 NO
。
样例输入
2
3 4
1 3 2
4 1
2 2 2 3
样例输出
YES
NO
数据范围
- 1
≤
T
≤
1
0
4
1 \leq T \leq 10^4
1≤T≤104
- 1
≤
n
<
1
0
5
1 \leq n < 10^5
1≤n<105
- 0
≤
k
≤
1
0
14
0 \leq k \leq 10^{14}
0≤k≤1014
- 1
≤
a
i
≤
1
0
9
1 \leq a_i \leq 10^9
1≤ai≤109
- 所有测试数据中
n
n
n 的总和不超过
1
0
5
10^5
105
题解
本题可以使用最大公约数(GCD)来求解。我们可以发现,如果所有绳子最终长度相等,那么它们的长度一定是所有初始绳子长度的最大公约数的倍数。因此,我们可以先求出所有绳子长度的最大公约数,然后计算每根绳子需要切割的次数,看是否不超过
k
k
k 即可。
具体步骤如下:
- 求出所有绳子长度的最大公约数
g
g
g。
2. 对于每根绳子,计算它需要切割的次数,即
a
i
/
g
−
1
a_i / g - 1
ai/g−1。
3. 将所有绳子需要切割的次数相加,如果不超过
k
k
k,则输出 YES
,否则输出 NO
。
时间复杂度为
O
(
n
log
a
max
)
O(n \log a_{\max})
O(nlogamax),其中
a
max
a_{\max}
amax 为绳子长度的最大值。空间复杂度为
O
(
1
)
O(1)
O(1)。
参考代码
- Python
def gcd(x, y):
return x if y == 0 else gcd(y, x % y)
T = int(input())
for _ in range(T):
n, k = map(int, input().split())
a = list(map(int, input().split()))
g = a[0]
for i in range(1, n):
g = gcd(g, a[i])
cnt = sum(x // g - 1 for x in a)
print("YES" if cnt <= k else "NO")
- Java
import java.io.\*;
import java.util.\*;
public class Main {
static int gcd(int x, int y) {
return y == 0 ? x : gcd(y, x % y);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
while (T-- > 0) {
int n = sc.nextInt();
long k = sc.nextLong();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
int g = a[0];
for (int i = 1; i < n; i++) {
g = gcd(g, a[i]);
}
long cnt = 0;
for (int x : a) {
cnt += x / g - 1;
}
System.out.println(cnt <= k ? "YES" : "NO");
}
}
}
- Cpp
#include <iostream>
using namespace std;
int gcd(int x, int y) {
return y == 0 ? x : gcd(y, x % y);
}
int main() {
ios::sync\_with\_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n;
long long k;
cin >> n >> k;
int g = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
g = i == 0 ? x : gcd(g, x);
}
long long cnt = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
cnt += x / g - 1;
}
cout << (cnt <= k ? "YES" : "NO") << '\n';
}
return 0;
}
03.卢小姐的魔法强化
问题描述
卢小姐是一位魔法少女,她拥有一把初始攻击力为
0
0
0 的魔法棒。现在,她面前有
n
n
n 块魔法石,每块魔法石都可以用于强化她的魔法棒。第
i
i
i 块魔法石有一个强化上限
a
i
a_i
ai。
当卢小姐使用第
i
i
i 块魔法石强化她的魔法棒时,她需要选择一个不超过强化上限
a
i
a_i
ai 的非负整数
x
x
x 作为强化系数。假设卢小姐当前的魔法棒攻击力为
k
k
k,那么强化后的攻击力将变为
k
∣
x
k \mid x
k∣x(其中
∣
\mid
∣ 表示按位或操作)。每块魔法石只能使用一次,用后即失效。
卢小姐想知道,利用这
n
n
n 块魔法石,她的魔法棒最多能达到多大的攻击力。
输入格式
输入包含多组测试数据。
第一行输入一个正整数
T
T
T(
1
≤
T
≤
1
0
4
1 \leq T \leq 10^4
1≤T≤104),表示测试数据的组数。
接下来,对于每组测试数据:
- 第一行输入一个正整数
n
n
n(
1
≤
n
≤
2
×
1
0
5
1 \leq n \leq 2 \times 10^5
1≤n≤2×105),表示魔法石的数量。
- 第二行输入
n
n
n 个整数
a
1
,
a
2
,
…
,
a
n
a_1, a_2, \ldots, a_n
a1,a2,…,an(
0
≤
a
i
≤
1
0
9
0 \leq a_i \leq 10^9
0≤ai≤109),表示每块魔法石的强化上限。
保证所有测试数据中
n
n
n 的总和不超过
2
×
1
0
5
2 \times 10^5
2×105。
输出格式
输出包含
T
T
T 行,每行一个整数,表示对应测试数据中卢小姐的魔法棒能达到的最大攻击力。
样例输入
2
5
2 3 3 3 6
3
1 0 0
样例输出
7
1
数据范围
- 1
≤
T
≤
1
0
4
1 \leq T \leq 10^4
1≤T≤104
- 1
≤
n
≤
2
×
1
0
5
1 \leq n \leq 2 \times 10^5
1≤n≤2×105
- 0
≤
a
i
≤
1
0
9
0 \leq a_i \leq 10^9
0≤ai≤109
- 所有测试数据中
n
n
n 的总和不超过
2
×
1
0
5
2 \times 10^5
2×105
题解
我们可以用贪心的思想来解决这个问题。对于每一个二进制位,我们优先使用能够强化该位的魔法石。如果该位已经被强化,我们就不需要再使用其他能够强化该位的魔法石了。
具体步骤如下:
-
统计每个二进制位上有多少块魔法石能够强化该位。
-
从高位到低位遍历每个二进制位:
- 如果当前位上有能够强化该位的魔法石,我们就使用其中一块,将答案的该位置为
1
1
1。
- 如果当前位上还有剩余的能够强化该位的魔法石,我们可以使用它们来强化答案的低位。具体地,我们可以将答案的低位全部置为
1
1
1,然后退出遍历。
时间复杂度为
O
(
n
log
a
max
)
O(n \log a_{\max})
O(nlogamax),其中
a
max
a_{\max}
amax 为魔法石强化上限的最大值。空间复杂度为
O
(
1
)
O(1)
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Python工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Python开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上前端开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以扫码获取!!!(备注Python)
所有测试数据中
n
n
n 的总和不超过
2
×
1
0
5
2 \times 10^5
2×105
题解
我们可以用贪心的思想来解决这个问题。对于每一个二进制位,我们优先使用能够强化该位的魔法石。如果该位已经被强化,我们就不需要再使用其他能够强化该位的魔法石了。
具体步骤如下:
-
统计每个二进制位上有多少块魔法石能够强化该位。
-
从高位到低位遍历每个二进制位:
- 如果当前位上有能够强化该位的魔法石,我们就使用其中一块,将答案的该位置为
1
1
1。
- 如果当前位上还有剩余的能够强化该位的魔法石,我们可以使用它们来强化答案的低位。具体地,我们可以将答案的低位全部置为
1
1
1,然后退出遍历。
时间复杂度为
O
(
n
log
a
max
)
O(n \log a_{\max})
O(nlogamax),其中
a
max
a_{\max}
amax 为魔法石强化上限的最大值。空间复杂度为
O
(
1
)
O(1)
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Python工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Python开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-vmfsp1kI-1712626034215)]
[外链图片转存中…(img-i3UGazvQ-1712626034216)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上前端开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以扫码获取!!!(备注Python)
![img](https://i-blog.csdnimg.cn/blog_migrate/1eb11dcbfa3d4438996a269105c125f0.jpeg)