这篇文章涵盖了多个编程挑战，包括数组操作的优化策略，RSA算法的条件判断，寻找特定数对的计数方法，数位计算的规律探索，定义完美数的条件，解决新国王游戏中的最优策略，Lusir的游戏中的能量管理，以及01序列的构造方法。这些挑战涉及到算法设计、数学思维和问题解决技巧。
数组操作
给你一个有 nn 个元素的数组 aa 。你可以对它进行如下操作，次数不限。
从一个偶数大小为 2k2k 的数组中选择一些从位置 ll 开始的子数组(1≤l≤l+2⋅k−1≤n1≤l≤l+2⋅k−1≤n , k≥1k≥1) ，对于 00 到 k−1k−1（包括）之间的每一个 ii ，将值 al+k+ial+k+i 分配给 al+ial+i 。
例如，如果 a=[2,1,3,4,5,3]a=[2,1,3,4,5,3] ，然后选择 l=1l=1 和 k=2k=2 ，应用这个操作，数组将变成 a=[3,4,3,4,5,3]a=[3,4,3,4,5,3]。
请找出使数组中所有元素相等所需的最少操作数（可能是零）。
输入格式
输入由多个测试用例组成。第一行输入一个整数 t(1≤t≤2×104)t(1≤t≤2×104)表示测试用例的数量。
每个测试用例的包含 (n+1)(n+1) 个整数：
第一个整数 n(1≤n≤2×105)n(1≤n≤2×105) 表示数组的长度。
此后 nn 个整数 a1,a2,...,an(1≤ai≤n)a1,a2,...,an(1≤ai≤n) 表示数组的元素。
输出格式
输出 tt 行，每行一个整数表示用给定的操作使数组中所有元素相等所需的最小操作数。
样例输入
5
3 1 1 1
2 2 1
5 4 4 4 2 4
4 4 2 1 3
1 1样例输出
0
1
1
2
0数据规模
保证所有测试用例的 nn 之和不超过 200000200000。
提示
在第一个测试中，所有元素都是相等的，因此不需要任何操作。
在第二个测试中，你可以应用一个操作，k=1，l=1k=1，l=1，设置 a1←a2a1←a2 ，通过 11 个操作，数组变成 [1,1][1,1]。
在第三个测试中，你可以应用一个操作，k=1，l=4k=1，l=4，设置 a4←a5a4←a5 ，然后数组变成 [4,4,4,4,4][4,4,4,4,4]。
在第四个测试中，你可以应用一个操作，k=1，l=3k=1，l=3，设置 a3←a4a3←a4 ，数组变成 [4,2,3,3][4,2,3,3]，然后你可以应用另一个操作，k=2，l=1k=2，l=1，设置 a1←a3,a2←a4，a1←a3,a2←a4， 数组变成 [3,3,3,3][3,3,3,3]。
在第五次测试中，只有一个元素，因此不需要任何操作。
1.题目为区间赋值，将长度为k的后一个区间赋值给长度为k的前一个区间，因为是从后面往前面赋值，最终所有的数都会和最后一个数相同 。、
2.我们可以从后面开始枚举与最后一个数相同的数的个数，当不相同时开始赋值，相同的时候继续数长度
3.题目卡输入输出
#include<iostream>
#include<cstdio>
#include<cstring>
#define endl '\n'
using namespace std;
const int N = 2e5+10;
int t,a[N],n,num,len,cnt;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin>>t;
while(t--)
{
cin>>n;
for(int i=1;i<=n;i++)cin>>a[i];
len=1,cnt=0;
while(len<n)
{
if(a[n-len]==a[n])len++;
else
{
cnt++;
len*=2;
}
}
cout<<cnt<<endl;
}
return 0;
}
RSA
RSA算法选择两个不同质数的积作为模数。现在有两个正整数 A,BA,B，如果它们是不同的质数，则判定为 full credit；否则，如果A⋅BA⋅B不是任意大于11的整数的平方的整数倍，则判定 partial credit；否则判定为no credit。
输入格式
一行两个正整数 A,BA,B。
输出格式
full credit 或 partial credit 或 no credit。
样例1输入
13 23样例1输出
full credit样例2输入
3 3样例2输出
no credit数据规模
所有数据保证 2≤A,B≤10122≤A,B≤1012。
数据范围有点大然后超时不会了...
1.先判断a和b是否相等，如果相等直接输出no credit，因为他们的乘积一定是平方数的倍数（！！）
2.求出a和b的所有因子，并记录下所有因子的出现次数，3.如果有一个因子出现了两次以上（说明不是质数了或者该两个数相等或者有平方数），或者已经有一个因子是某个数的平方数时，输出no credit
4.如果这两个数没有除了1和自身以外的数，就输出full credit
5.剩余情况输出partial credit
https://blog.youkuaiyun.com/fnmdpnmsl/article/details/123761642#include<iostream>
#include<cmath>
using namespace std;
#include<algorithm>
#include<string>
#include<unordered_map>
#define int ll
#define endl '\n'
typedef long long ll;
const int N = 5e2 + 5;
//记录因数出现次数
unordered_map<int, int>mymap;
//求出x的全部因数
void check(int x)
{
for (int i = 2; i <= x / i; i++)
{
if (x % i == 0)
{
mymap[i]++;
mymap[x / i]++;
}
}
}
void solve()
{
int a, b;
cin >> a >> b;
if (a == b)
{
cout << "no credit" << endl;
return;
}
check(a);
check(b);
bool flag = false;
for (auto i : mymap)
{
int x = sqrt(i.first);
//如果当前因数出现了两次，或者当前因数已经是某个数得平方数了，输出no credit
if (i.second > 1 || x * x == i.first)
{
flag = true;
break;
}
}
if (mymap.size() == 0)cout << "full credit" << endl;
else if(flag)cout << "no credit" << endl;
else cout << "partial credit" << endl;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}A-B 数对
给出一串数以及一个数字 CC ，要求计算出所有 A−B=CA−B=C 的数对的个数（不同位置的数字一样的数对算不同的数对）。
输入格式
输入共两行。
第一行，两个整数 NN, CC。
第二行， NN 个整数，作为要求处理的那串数。
输出格式
一行，表示该串数中包含的满足 A−B=CA−B=C 的数对的个数。
样例输入
4 1
1 1 2 3样例输出
3数据范围
1≤N≤2×1051≤N≤2×105, 1≤C≤2×1051≤C≤2×105, 题目保证输入的 NN 个数范围小于 230230。
数据范围不是很大，枚举能过^~^
#include<iostream>
#include<cstring>
#include<algorithm>
#include<unordered_map>
using namespace std;
const int N = 2e5+10;
long long n,c,ans,a[N];
unordered_map<int,int> mp;
int main(){
cin>>n>>c;
for(int i=0;i<n;i++){
cin>>a[i];
mp[a[i]]++;
}
for(int i=0;i<n;i++){
ans+=mp[a[i]+c];
}
cout<<ans<<endl;
return 0;
}数位计算
给出一个整数 nn，请解决下面的问题：
使 f(x)=f(x)=（不超过 xx 且与 xx 具有相同位数的正整数的个数）。
求出 f(1)+f(2)+...+f(n)f(1)+f(2)+...+f(n) ，结果对 998244353998244353 取模。
输入格式
一个整数 NN。
输出格式
一个整数——上面问题的答案，并对 998244353998244353 取模。
样例输入1
16样例输出1
73样例解释：对从 11 到 99 的每个 xx，不超过 xx 且与 xx 具有相同位数的正整数有 1,2,..,x1,2,..,x，因此，f(1)=1,f(2)=2,...,f(9)=9f(1)=1,f(2)=2,...,f(9)=9。对从 1010 到 1616 的每个 xx，不超过 xx 且与 xx 具有相同位数的正整数有 10,11,..,x10,11,..,x，因此，f(10)=1,f(11)=2,...,f(16)=7f(10)=1,f(11)=2,...,f(16)=7。所以答案为 7373。
样例输入2
238样例输出2
13870样例输入3
999999999999999999样例输出3
762062362数据规模
所有数据保证 1≤N<10181≤N<1018，且 NN 是整数。
从10开始枚举10的倍数。如f(1)+...+f(9)有（1+2+3...+9;f(100)+..+f(999)=(1+..+900)=(1000-100+1)*(1000-100)/2;
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
const int MOD = 998244353;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
unsigned long long n, res = 0, num = 0, power = 10;
cin >> n;
while (1)
{
if (n > power - 1)
{
ll x = (1 + power - power / 10) % MOD;
ll y = ((power - power / 10)) % MOD;
res =res+ (x*y/2)%MOD;
res %= MOD;
}
else
{
ll x = (1 + n - power / 10 + 1) % MOD;
ll y = ((n - power / 10 + 1)) % MOD;
res = res+ (x*y/2)%MOD;
res %= MOD;
break;
}
power *= 10;
}
cout << res%MOD << endl;
return 0;
}
#669. 完美数
对于给定的数字 aa , bb ,当整数 nn 在十进制下的所有数位都为 aa 或 bb 时，我们称 nn 是“好数”
对于好数 nn ，当 nn 在十进制下每一位的数字之和也为“好数”时，我们称 nn 是一个“完美数”
请你求出有多少 mm 位数是“完美数”
输入格式
输入一行三个整数 aa , bb , mm , 含义如题面所示 (1≤m≤106,1≤a,b≤9)(1≤m≤106,1≤a,b≤9)。
输出格式
输出一行一个整数表示完美数的数量 ， 由于答案可能很大 ， 请你将答案对 109+7109+7 取模
样例输入
5 1 5样例输出
1样例解释
只有 1111111111 满足要求
1.枚举每个数位上a,b的个数，最后将枚举出来的数各个数位上的和加起来，判断每一位是否都为a或者b
2.需要对组合数取模（知识盲区了）(225条消息) 组合数取模_ACdreamers的博客-优快云博客
https://juejin.cn/post/7081175247197732900
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#include<set>
#include<numeric>
#include<string>
#include<string.h>
#include<iterator>
#include<map>
#include<unordered_map>
#include<stack>
#include<list>
#include<queue>
#include<iomanip>
#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
const int MOD = 1e9 + 7, N = 1e6 + 10;
ll fact[N], infact[N];
ll qmi(int a, int b)
{
ll res = 1;
while (b)
{
if (b & 1) res = res * a % MOD;
a = a * (ll)a % MOD;
b >>= 1;
}
return res;
}
void init()
{
fact[0] = infact[0] = 1;
for (int i = 1; i < N; i++)
fact[i] = fact[i - 1] * i % MOD;
infact[N - 1] = qmi(fact[N - 1], MOD - 2);
for (int i = N - 2; i; i--)
infact[i] = infact[i + 1] * (i + 1) % MOD;
}
int C(int a, int b)
{
return (fact[a] * infact[b] % MOD * infact[a - b] % MOD) % MOD;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int a, b, m;
cin >> a >> b >> m;
init();
char c = a + '0', d = b + '0';
int x;
ll res = 0;
for (int i = 0; i <= m; i++)
{
x = m - i;
ll num = x * a + i * b;
bool flag = true;
while (num)
{
if (num % 10 != a && num % 10 != b)
{
flag = false;
break;
}
num /= 10;
}
if (!flag)continue;
res = (res + C(m,i)) % MOD;
}
cout << (res%MOD) << endl;
return 0;
}
新国王游戏
又到了 HH 国国庆, 国王再次邀请 nn 位大臣来玩有奖游戏。上次国庆被众臣吐槽国王小气后，国王决定今年大方点，改变游戏规则且不再参与游戏，免得被大臣们质疑。首先, 他让每位大臣在左、 右手上面分别写下一个正整数。然后让这 nn 位大臣排成一排。排好队后, 所有的大臣都会获得国王奖赏的若千金币, 每位大臣获得的金币数分别是：排在该大臣后面的所有人的左手上的数的乘积乘以他自己右手上的数。国王希望所有大臣获得的金币数之和最多，所以他想请你帮他重新安排一下队伍的顺序。
简而言之，给定 nn 对数 ai,biai,bi，找到一种排列顺序，使得 b1×a2∗a3∗…an+b2×a3∗a4∗…an+⋯+bnb1×a2∗a3∗…an+b2×a3∗a4∗…an+⋯+bn 最大，求最大值，由于答案可能很大，需要对 10000000071000000007 取模
输入格式：
第一行，包含一个整数 nn。 第二行到第 n+1n+1 行，包含两个整数 ai,biai,bi
输出格式:
输出一行，表示按某种排序后的 b1×a2∗a3∗…an+b2×a3∗a4∗…an+⋯+bnb1×a2∗a3∗…an+b2×a3∗a4∗…an+⋯+bn 的最大值对 10000000071000000007 取模的结果
样例输入
2
1 2
3 4样例输出
10说明
只有两种情况：
1.
1 2
3 4(2∗3)+4=10(2∗3)+4=10
2.
3 4
1 2(4∗1)+2=6(4∗1)+2=6
所以答案为 1010
数据限制
对于 100%100% 的数据，保证 1≤n≤106,1≤ai,bi≤230
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const int max_n = 1e6;
const int max_ab = pow(2, 30);
const int mod_num = 1000000007;
struct person { long long l, r; }persons[max_n + 1];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> persons[i].l >> persons[i].r;
sort(persons + 1, persons + 1 + n, [](person p1, person p2) {
return p1.r * p2.l + p2.r > p2.r * p1.l + p1.r;
});
long long ans = 0;
long long sum = 1;
for (int i = n; i > 0; i--) {
ans = (ans + persons[i].r * sum) % mod_num;
sum = (sum * persons[i].l) % mod_num;
}
cout << ans << endl;
return 0;
}
Lusir的游戏
LusirLusir 正在玩一个古老的基于 DOSDOS 的游戏。
游戏中有 N+1N+1 座建筑——从 00 到 NN 编号，从左到右排列。编号为 00 的建筑高度为 00 个单位，编号为 ii 的建筑高度为 H(i)H(i) 个单位。 起初，LusirLusir 在编号为 00 的建筑处。每一步，它跳到下一个（右边）建筑。假设 LusirLusir 在第 kk 个建筑，且它现在的能量值是 EE，下一步它将跳到第 k+1k+1 个建筑。
如果 H(k+1)>EH(k+1)>E，那么 LusirLusir 就失去 H(k+1)−EH(k+1)−E 的能量值，否则他将得到 E−H(k+1)E−H(k+1) 的能量值。
游戏目标是到达第 NN 个建筑，在这个过程中能量值不能为负数个单位。
现在的问题是 LusirLusir 至少以多少能量值开始游戏，才可以保证成功完成游戏？
输入格式
第一行输入整数 NN。 第二行是 NN 个空格分隔的整数，H(1),H(2),…,H(N)H(1),H(2),…,H(N) 代表建筑物的高度。
输出格式
输出一个整数，表示所需的最少单位的初始能量值上取整后的结果。
数据范围
1≤N,H(i)≤1051≤N,H(i)≤105
输入样例1：
5
3 4 3 2 4输出样例1：
41.二分进行枚举
2.注意枚举的数大于建筑高度a[i] 最大值maxn时就一定满足，直接返回true即可
#include<iostream>
#include<queue>
using namespace std;
typedef long long ll;
const int N = 1e5;
int a[N],n;
ll ans,maxn;
int check(int mid)
{
ll res=mid;
for(int i=1;i<=n;i++)
{
res=res+(res-a[i]);
if(res>maxn)return 1;
if(res<0)return 0;
}
return 1;
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
if(a[i]>maxn)maxn = a[i];
}
int l = 0,r = 1e6;
while(l<=r)
{
int mid = l+r>>1;
if(check(mid))ans=mid,r=mid-1;
else l=mid+1;
}
cout<<ans;
return 0;
}#147. BFS练习1
给你一个数字aa，每次可以选择下面四种操作中的一种：
- 把数字aa加上一。
- 把数字aa乘以22。
- 把数字aa乘以33。
- 把数字aa减去一。
问把这个aa变成bb最少需要多少步。
你要回答qq个询问，b1,b2,…,bqb1,b2,…,bq，输出把aa变成b1,b2,…,bqb1,b2,…,bq的最小步数。
输入格式
第一行两个整数a,qa,q。
接下来一行qq个整数b1,…,bqb1,…,bq。
输入格式
输出qq个数字，分别表示把aa变成b1,b2…,bqb1,b2…,bq的最小步数。
样例输入
3 10
1 2 3 4 5 6 7 8 9 10样例输出
2 1 0 1 2 1 2 2 1 2数据规模
对于所有数据，保证1≤a,q,bi≤1051≤a,q,bi≤105。
BFS减枝
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#include<set>
#include<numeric>
#include<string>
#include<string.h>
#include<iterator>
#include<map>
#include<unordered_map>
#include<stack>
#include<list>
#include<queue>
#include<iomanip>
#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
const int N = 300050;
int a[N], f[N];
inline int read() {
int x = 0; char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x;
}
void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 | '0');
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, num;
num = read(), n = read();
vector<int>v(n);
for (int i = 0; i < n; i++)
{
v[i] = read();
a[v[i]] = -1;
}
queue<int>que;
que.push(num);
int res = 0;
while (!que.empty()&&n)
{
int len = que.size();
for (int i = 0; i < len; i++)
{
int ans = que.front();
que.pop();
if (a[ans] == -1)
{
a[ans] = res;
n--;
}
if (ans * 3 < 100050 && f[ans * 3] == 0)
{
que.push(ans * 3);
f[ans * 3] = 1;
}
if (ans * 2 < 100050 && f[ans * 2] == 0)
{
que.push(ans * 2);
f[ans * 2] = 1;
}
if (ans - 1 > 0 && f[ans - 1] == 0)
{
que.push(ans - 1);
f[ans - 1] = 1;
}
if (ans + 1 < 100050 && f[ans + 1] == 0)
{
que.push(ans + 1);
f[ans + 1] = 1;
}
}
res++;
}
for (auto i : v)
{
write(a[i]);
putchar(' ');
}
return 0;
}
01序列2
又是大家最喜欢的01序列问题了呢
这次的问题非常的简单，cc觉得一个01序列中两个1之间至少要有kk个00，现在他要构造出一个长度为nn的01序列，请问他有多少种不同的构造方法
这个数字可能会非常大，请你对109+7109+7取模
输入格式
一行，给出两个整数n，kn，k
输出格式
一个整数，代表不同的构造方法数
数据范围
1≤n≤1061≤n≤106
0≤k<n0≤k<n
样例输入
4 2样例输出
6需要用组合数取模。组合数取模用Lucas定理最后一个点似乎会超时
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#include<set>
#include<numeric>
#include<string>
#include<string.h>
#include<iterator>
#include<map>
#include<unordered_map>
#include<stack>
#include<list>
#include<queue>
#include<iomanip>
#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
const int N = 1000050, MOD = 1e9 + 7;
ll fact[N], infact[N];
ll qmi(int a, int b)
{
ll res = 1;
while (b)
{
if (b & 1) res = res * a % MOD;
a = a * (ll)a % MOD;
b >>= 1;
}
return res;
}
void init()
{
fact[0] = infact[0] = 1;
for (int i = 1; i < N; i++)
fact[i] = fact[i - 1] * i % MOD;
infact[N - 1] = qmi(fact[N - 1], MOD - 2);
for (int i = N - 2; i; i--)
infact[i] = infact[i + 1] * (i + 1) % MOD;
}
int C(int a, int b)
{
return (fact[a] * infact[b] % MOD * infact[a - b] % MOD) % MOD;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, k;
init();
cin >> n >> k;
int i = 1;
ll res = 1;
while (i <= n - (i - 1) * k)
{
res = (res + C(n - (i - 1) * k, i) % MOD) % MOD;
i++;
}
cout << res << endl;
return 0;
}
整除光棍
这里所谓的“光棍”，并不是指单身汪啦~ 说的是全部由 11 组成的数字，比如 1、111、111、11111、111、111、1111 等。传说任何一个光棍都能被一个不以 55 结尾的奇数整除。比如， 111111111111 就可以被 1313 整除。 现在，你的程序要读入一个整数 xx ，这个整数一定是奇数并且不以 55 结尾。然后，经过计算，输出两个数字：第一个数字 ss，表示xx 乘以 ss 是一个光棍，第二个数字nn是这个光棍的位数。这样的解当然不是唯一的,题目要求你输出最小的解。
提示：一个显然的办法是逐渐增加光棍的位数，直到可以整除 xx 为止。但难点在于，ss 可能是个非常大的数 —— 比如，程序输入 3131 ，那么就输出 35842293906813584229390681和 1515 ，因为 3131 乘以 35842293906813584229390681 的结果是 111111111111111111111111111111 ，一共 1515 个 11。
输入格式
输入在一行中给出一个不以 55 结尾的正奇数 x（x<1000)x（x<1000)。
输出格式
在一行中输出相应的最小的 ss 和 nn，其间以 11 个空格分隔。
样例输入
31样例输出
3584229390681 15数太大枚举肯定会超出数据范围，因为被除数都是由1组成的，我们可以模拟直接除法的过程
#include<iostream>
using namespace std;
int x,n,num;
int main()
{
cin>>x;
while(num<x)
{
num=num*10+1;
n++;
}
while(1)
{
cout<<num/x;
num%=x;
if(num==0)break;
num=num*10+1;
n++;
}
cout<<' '<<n;
return 0;
}
扫一扫
11万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
