第二期训练题目来源：Daimayuan Online Judge, div2
link
首先解决上周被难倒的两道题106和107
106订单编号
题目描述
小缘开了一家公司，生意很好，每天都会收到很多订单，自动交易系统会自动给这些订单生成没有重复的订单编号。但是有一天，系统出现了未知的错误，导致当天的订单编号可能有重复的，这可把小缘急坏了。你可以帮助小缘按照规则给这些订单重新编号吗？
按照时间先后顺序给出 N 个正整数作为原订单编号，你需要按照规则依次赋予这些订单新的编号，对于任意一个订单，要找到大于等于其原订单编号且未被使用过的（没有被之前的订单作为新的订单编号）的最小整数，作为它的新订单编号。
例如： 原订单编号依次为1 2 3 1，则新订单编号应该为1 2 3 4 （前3个订单的原订单编号都没有使用过，所以用其原订单编号即可，对于第四个订单，原订单编号为1，而1, 2, 3都已经被使用过，所以新订单编号为4）。
输入格式
第一行输入一个整数 N ( 1 ≤ N ≤ 5 × 1 0 5 ) N (1≤N≤5×10^5) N(1≤N≤5×105)。
第二行输入 N 个数 a i ( 1 ≤ a i ≤ 1 0 9 ) a_i (1≤a_i≤10^9) ai(1≤ai≤109) 作为原订单编号。
输出格式
输出一行，包含 N 个整数为新的订单编号。
样例输入1
6
2 3 4 1 1 1
样例输出1
2 3 4 1 5 6
样例输入2
3
1000000000 1000000000 1000000000
样例输出2
1000000000 1000000001 1000000002
样例输入3
6
4 5 1 2 1 1
样例输出3
4 5 1 2 3 6
思路
这道题学会很多新知识：set集合、low_bound()、auto、scanf/cin
- set
set 集合，是一个内部自动有序且不含重复元素的容器。
set 常用函数
insert(x) 可将 x 插入 set 容器中，并自动递增排序和去重，时间复杂度为 O（logN），其中 N 为 set 内的元素个数。
find(value) 返回 set 中对应值为 value 的迭代器，时间复杂度为 O（logN），其中 N 为 set 内的元素个数。
st.erase(it) ，即删除迭代器为 it 处的元素，时间复杂度为 O（1）。
st.erase(value) ，value 为所需要删除元素的值。时间复杂度为 O（logN），N 为 set 内的元素个数。 - low_bound()
lower_bound在set中用法：二分查找一个有序数列，返回第一个大于等于x的数，如果没找到，返回末尾的迭代器位置 - auto
在C++11新特性中，auto是用来修饰局部变量的，所以局部变量也叫auto变量/自动变量。auto是个自动推导出数据类型的关键字，应用的场景较为广
本题auto it 即auto推导成了vector< make_pair<int , int > >的迭代器 - scanf与cin
scanf要比cin快，cin，cout之所以效率低，是因为先把要输出的东西存入缓冲区，再输出，导致效率降低，而std::ios::sync_with_stdio(false);这段语句可以来打消iostream的输入、输出缓存，可以节省许多时间，使效率与scanf与printf相差无几
不过本题scanf通过了，而使用std::ios::sync_with_stdio(false);并没有通过。
接下来我们再来看这道题，维护一个区间，我们一开始放一个很大的区间，在这个区间里找到x后把它分成两个部分，即x左区间，x右区间。x输出。
接着在这两个区域里面再去找下一个值，如果这个值不在一个个的子区间里面，也就是这个数重复了，我们就把大于x的那个区间的第一个数x+1输出（可以利用set里面的lower_bound来实现），再把那个区间变成x+1为左边界，右边界不变的区域
代码
#include <bits/stdc++.h>
using namespace std;
int n;
set< pair<int, int> > q;
inline void insert(int l, int r){
if(l>r) return;
q.insert(make_pair(r,l));
}
int main(){
q.insert(make_pair(2e9, 1));
cin >> n;
for(int i = 0; i < n; i++){
int a;
scanf("%d",&a);
auto it = q.lower_bound(make_pair(a,0));
if(it->second <= a){
cout << a << " ";
insert(it->second,a-1);
insert(a+1, it->first);
q.erase(it);
}
else{
cout << it->second << " ";
insert(it->second+1, it->first);
q.erase(it);
}
}
return 0;
}
107饿饿 饭饭
题目描述
有n个同学正在排队打饭，第i个同学排在从前往后第i个位置。但是这天食堂内只有一个食堂阿姨，为了使同学们都能尽快的吃上饭，每一个同学在打完一份饭之后就会排在队伍的末尾先吃着打到的饭，我们知道第i个同学的饭量为 a i a_i ai，也就是说第i个同学要吃 a i a_i ai份饭才能吃饱，当一位同学吃饱后，他就会立刻离开食堂，不会排在队伍的末尾。食堂阿姨想知道，在打完k份饭之后，队伍的样子是怎样的，但是食堂阿姨数学不太好，想让你帮忙想想办法。
输入格式
第一行给出两个整数n，k。
第二行给出n个整数 a 1 , a 2 , . . . . . . a n a_1,a_2,......a_n a1,a2,......an
输出格式
如果食堂阿姨打饭数少于k，请输出"-1"。
否则按照队伍顺序输出每一个同学的编号。
样例输入1
3 3
1 2 1
样例输出1
2
样例输入2
4 10
3 3 2 1
样例输出2
-1
样例输入3
7 10
1 3 3 1 2 3 1
样例输出3
6 2 3
数据规模
数据保证 1 ≤ n ≤ 1 0 5 , 0 ≤ k ≤ 1 0 14 , 1 ≤ a i ≤ 1 0 9 1≤n≤10^5, 0≤k≤10^{14}, 1≤a_i≤10^9 1≤n≤105,0≤k≤1014,1≤ai≤109。
思路
二分找轮次+拟合最后一轮
代码
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5+5;
int n;
long long k;
long long a[Max];
int ind[Max]; //记录剩余人编号
long long p(int x){
long long now = 0;
for(int i = 1; i <= n; i++){
if(a[i]<=x) now += a[i];
else now += x;
}
return now;
}
int main(){
cin >> n >> k;
long long sum = 0;
for(int i = 1; i <= n; i++){
cin >> a[i];
sum+=a[i];
}
if(sum < k){
cout << -1 << endl;
return 0;
}
int l = 0, r = 1e9;
while(l+1<r){ //l+1 把饭打完，l最后一轮
int mid = (l+r)/2;
if(p(mid)<=k) l=mid;
else r = mid;
}
int s = k-p(l);
int tmp=0;
for(int i = 1; i <= n; i++){
if(a[i]>l) ind[tmp++]=i;
}
for(int i = s; i < tmp; i++){
cout << ind[i] << " ";
}
for(int i = 0; i < s; i++){
if(a[ind[i]]>l+1)
cout << ind[i] << " ";
}
}
204加一
题目描述
给定一个整数 n。你需要对它做 m 次操作。在一次操作中，你要将这个数的每一位 d 替换成 d+1。比如，1912 在进行一次操作后将变成 21023。
请求出整数 n 进行了 m 次操作后的长度。答案可能很大，输出对 1 0 9 + 7 10^9+7 109+7 取模后的结果。
输入格式
第一行一个整数 t，表示测试单元的个数。
接下来 t 行，每行有两个整数 n 和 m，表示最初的数字和进行多少次操作。
输出格式
对于每个测试单元输出最终数字的长度，答案对 1 0 9 + 7 10^9+7 109+7 取模。
样例输入
5
1912 1
5 6
999 1
88 2
12 100
样例输出
5
2
6
4
2115
数据范围
所有数据保证 1 ≤ t ≤ 2 ⋅ 1 0 5 ， 1 ≤ n ≤ 1 0 9 ， 1 ≤ m ≤ 2 ⋅ 1 0 5 1≤t≤2⋅10^5，1≤n≤10^9，1≤m≤2⋅10^5 1≤t≤2⋅105，1≤n≤109，1≤m≤2⋅105。
思路
对每一个数字统计进行k次后的位数
动态规划，dp[i][j]表示数字j加了i后的位数
状态转移方程为：
dp[i][j-1]=dp[i-1][j],
0
≤
j
<
9
0≤j<9
0≤j<9
dp[i][9]=dp[i-1][1]+dp[i-1][0], j=9
代码
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9+7;
const int Max = 2e5+5;
int t,m;
int dp[Max][10];
int main(){
scanf("%d", &t);
for(int i = 0; i <= 9; i++) dp[0][i]=1;
for(int i = 1; i < Max; i++){
for(int j = 1; j <= 9; j++){
dp[i][j-1]=dp[i-1][j];
}
dp[i][9]=(dp[i-1][0]+dp[i-1][1])%mod;
}
for(int i = 1; i <= t; i++){
//string s;
//cin >> s;
//scanf("%d",&m);
char s[50];
scanf("%s %d",&s,&m);
long long ans=0;
for(int j = 0; j < strlen(s); j++){
ans+=dp[m][s[j]-'0'];
ans %= mod;
}
//cout << ans << endl;
printf("%ld\n",ans);
}
}
205跳跳
题目描述
平面上给定了一些整点（横纵坐标均为整数的点），被称为 “魔法阵”。魔法少女派派想要在各魔法阵之间传送，每一次传送，她将使用下面的方式：
刚开始，派派已经位于某传送阵之上；
如果派派掌握一种魔法 (A,B)，其中 A,B 均为整数。使用一次这个魔法可以让派派从任意整点 (X,Y) 瞬间移动至 (X+A,Y+B)；
选择一种魔法并开始传送，在一次传送过程中可以使用多次该魔法，但在抵达下一个传送阵之前仅能使用这一种魔法。
问派派至少需要掌握多少种魔法，才能在从任意魔法阵直接传送到任意魔法阵？
输入格式
第一行一个整数 N。
接下来一行 N 行，每行包含两个整数 X i , Y i X_i,Y_i Xi,Yi， 表示每个魔法阵的坐标。
输出格式
一个数，表示答案。
样例输入1
3
1 1
4 5
1 4
样例输出1
6
解释
任务是从 (1,1) 传送至 (4,5) 以及 (1,4) 、从 (4,5) 传送至 (1,1) 以及 (1,4) 、从 (1,4) 传送至 (1,1) 以及 (4,5) 。
注意你不能使用 (0,3)+(3,1) 的魔法从 (1,1) 到达 (4,5)。因为每次移动，你只能使用一种魔法。
当然，你可以学习 (0,1)，那样的话，从 (1,1) 到达 (1,4) 则需要使用 3 次 (0,1) 魔法了。
样例输入2
3
1 1
2 2
1000000000 1000000000
样例输出2
2
数据规模
N ∈ [ 10 , 500 ] , X i , Y i ∈ [ 0 , 1 0 9 ] N∈[10,500], X_i,Y_i∈[0,10^9] N∈[10,500],Xi,Yi∈[0,109], 但保证坐标之间两两不同。
思路
最坏情况下每次移动一次到位，但是可以求最小移动单位，例如移动（8，4）与移动（2，1）4次的效果相同，求出每一个最小单位，去除重复的即是答案。
难点在于怎么去重，使用map作为数组，{A，B}作为下标，判断是否已经存在过了
代码
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > s;
int main(){
cin >> n;
map<pair<int, int>, int> mapp;
int x, y;
for(int i = 1; i <= n; i++){
cin >> x >> y;
s.push_back({x,y});
}
int ans=0;
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n; j++){
if(i==j) continue;
int xx = s[i].first-s[j].first;
int yy = s[i].second-s[j].second;
if(xx==0 || yy==0){
xx = (xx==0)? 0: xx/abs(xx);
yy = (yy==0)? 0: yy/abs(yy);
}
else{
int gcd = __gcd(xx,yy);
xx/=abs(gcd);
yy/=abs(gcd);
}
if(mapp[{xx,yy}]==0){
ans++;
mapp[{xx,yy}]=1;
}
}
}
cout << ans << endl;
}
206异或和或
题目描述
对于一个长度为 n 的01序列 a 1 , a 2 , … , a n a_1,a_2,…,a_n a1,a2,…,an。
你可以执行以下操作任意多次：
选择两个下标 1 ≤ i , j ≤ n ( i ≠ j ) 1≤i,j≤n(i≠j) 1≤i,j≤n(i=j)。
记 x = a i x o r a j , y = a i o r a j x=a_i xor a_j , y=a_i or a_j x=aixoraj,y=aioraj , 其中 xor 表示按位异或 , or 表示按位或。
然后令 a i = x , a j = y 或 a i = y , a j = x a_i=x,a_j=y 或 a_i=y,a_j=x ai=x,aj=y或ai=y,aj=x。
给定两个01序列 s,t , 请你判断是否可以通过有限次(可以为0次)操作将序列 s 变为 t。
输入格式
第一行一个整数 t , 表示数据的组数 ( 1 ≤ t ≤ 1 0 3 ) (1≤t≤10^3) (1≤t≤103)。接下来 t 组数据：
每组第一行一个01字符串 s ( 1 ≤ ∣ s ∣ ≤ 1 0 3 ) s(1≤|s|≤10^3) s(1≤∣s∣≤103)，每组第二行一个01字符串 t ( 1 ≤ ∣ t ∣ ≤ 1 0 3 ) t(1≤|t|≤10^3) t(1≤∣t∣≤103)。
注意：|s| 可能不等于 |t|。
输出格式
如果可以通过有限次(可以为0次)操作将序列 s 变为 t , 输出 YES , 否则输出 NO。
样例输入
2
001
011
11
101
样例输出
YES
NO
样例解释
第一组数据选择 i=2,j=3 , 那么 x=1,y=1 , 接着令 a i = x , a j = y a_i=x,a_j=y ai=x,aj=y 即可得到 t 序列。
第二组数据 |s|=2,|t|=3 显然无法满足要求。
思路
s和t同时含有1或都不含1，则最终可以转化为一样的
否则不可以
代码
#include <bits/stdc++.h>
using namespace std;
int T;
string s,t;
int main(){
cin >> T;
for(int i = 1; i <= T; i++){
cin >> s >> t;
if(s.length()!= t.length()) cout << "NO" << endl;
else{
int flag1(0),flag2(0);
for(int j = 0; j <= s.length(); j++){
if(s[j]=='1') flag1=1;
if(t[j]=='1') flag2=1;
}
if(flag1==flag2) cout << "YES" << endl;
else cout << "NO" << endl;
}
}
}
207 01序列
题目描述
我们称一个字符串为好字符串，指这个字符串中只包含0和1。
现在有一个好字符串，求这个字符串中1恰好出现k次的子串有多少个。
输入格式
第一行给出一个数字k，表示子串中1的个数。
第二行给出好字符串。
输出格式
输出一个整数，表示好字符串中有多少个符合条件的子串
数据范围
0 ≤ k ≤ 106 , ∣ s ∣ ≤ 106 0≤k≤106, |s|≤106 0≤k≤106,∣s∣≤106
样例输入1
1
1010
样例输出1
6
样例输入2
2
01010
样例输出2
4
思路
找出最短字串，统计最短字串两边的0的个数，则由该最短字串可以构成的满足条件的新字串的个数为：1+左边0的个数+右边0的个数+左边0的个数*右边0的个数
代码
#include <bits/stdc++.h>
using namespace std;
long long k;
string s;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> k;
cin >> s;
vector<pair<long long, long long> > num;
long long l(0),r(0),m(0);
for(long long i = 0; i < s.length(); i++){
if(s[i]=='0' && m==0) l++;
else if(s[i]=='0' && m==1) r++;
else if(s[i]=='1' && m==0) m=1;
else {
//cout << "#";
num.push_back(make_pair(l,r));
l=r;
r=0;
}
}
if(s[s.length()-1]!=1) num.push_back(make_pair(l,r));
//cout << num.size() << endl;
long long ans=0;
if(k==0){
if(num[0].first!=0)
ans+=num[0].first*(num[0].first+1)/2;
for(long long i = 0; i < num.size();i++){
long long sub0r=num[i].second;
//cout << sub0r << " ";
ans+=sub0r*(sub0r+1)/2;
//cout << ans << " ";
}
}
else{
for(long long i = 0; i < num.size(); i++){
if(i+k>num.size()) continue;
long long subl=num[i].first;
long long subr=num[i+k-1].second;
ans+=1+subl+subr+subl*subr;
}
}
cout << ans << endl;
}
301出栈序列判断
题目描述
现在有一个栈，有 n 个元素，分别为 1,2,…,n。我们可以通过 push 和 pop 操作，将这 n 个元素依次放入栈中，然后从栈中弹出，依次把出栈的元素写下来得到的序列就是出栈序列。
比如 n=3，如果执行 push 1, push 2, pop, push 3, pop, pop，那么我们 pop 操作得到的元素依次是 2,3,1。也就是说出栈序列就是 2,3,1。
现在给定一个合法的出栈序列，请输出一个合法的由 push 和 pop 操作构成的操作序列。这里要求 push 操作一定是按 1,2,…,n 的顺序。
输入格式
第一行一个整数 n。接下来一行 n 个整数，表示出栈序列。
输出格式
输出 2n 行，每行一个 push 或 pop 操作，可以证明一个出栈序列对应的操作序列是唯一的。
样例输入1
3
2 3 1
样例输出1
push 1
push 2
pop
push 3
pop
pop
样例输入2
5
1 3 5 4 2
样例输出2
push 1
pop
push 2
push 3
pop
push 4
push 5
pop
pop
pop
数据规模
对于 100% 的数据，保证 1≤n≤100000，输入一定是个合法的出栈序列。
思路
可以发现出栈序列中前一个数小于当前数，那么它就一定是进栈，而小的数先弹出就说明大的数还没有进。前一个数大于当前数，那么当前数就一定是出栈的，而弹出的数一定是当前最大的，也就相当于栈顶。
代码
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5+5;
int n;
int a[Max];
stack<int> w;
int main(){
cin >> n;
int now=1;
w.push(0);
for(int i = 1; i <= n; i++){
scanf("%d",a+i);
}
//int s = 0;
for(int i = 1; i <= n; i++){
while(a[i] != w.top()){
w.push(now++);
printf("push %d\n",w.top());
}
printf("pop\n");
w.pop();
/*if(a[i]==now){
//cout << "push " << a[i] << endl;
//cout << "pop" << endl;
printf("push %d\n",a[i]);
printf("pop\n");
s+=2;
now++;
i++;
}
else if(a[i]>now){
//cout << "push" << " " << now << endl;
printf("push %d\n",now);
s+=1;
now++;
}
if(now>n){
break;
}*/
}
/*while(s++<2*n){
//cout << "pop" << endl;
printf("pop\n");
}*/
}
302序列维护
题目描述
你有一个序列，现在你要支持几种操作：
insert
x y，在从前往后的第x个元素后面插入y这个数。如果x=0，那么就在开头插入。
delete x，删除从前往后的第x个元素。
query k，询问从前往后数第k个元素是多少。
输入格式
第一行一个整数m，表示操作个数。
接下来m行，每行一个上面所述的操作。
输出格式
输出若干行，对于每个查询操作，输出答案。
样例输入
10
insert 0 1
insert 1 2
query 1
query 2
insert 0 3
query 1
delete 1
query 1
insert 1 4
query 2
样例输出
1
2
3
1
4
数据规模
对于100%的数据，保证 m ≤ 1 0 3 m≤10^3 m≤103。
对于insert操作，保证 1 ≤ y ≤ 1 0 9 1≤y≤10^9 1≤y≤109。
对于所有操作，保证位置不会超出当前序列的长度。
思路
直接使用vector，自带位置插入，位置删除和查询
代码
#include <bits/stdc++.h>
using namespace std;
int m;
vector<int> q;
int main(){
cin >> m;
for(int i = 1; i <= m; i++){
string s;
int x,y,k;
cin >> s;
if(s == "insert"){
cin >> x >> y;
q.insert(q.begin()+x,y);
}
else if(s == "delete"){
cin >> x;
q.erase(q.begin()+x-1);
}
else{
cin >> k;
cout << q[k-1] << endl;
}
}
}
最大公约数求法——辗转相除法
int gcd(int x,int y){
int z = y;
while(x%y!=0){
z = x%y;
x = y;
y = z;
}
return z;
}
303网格判断
题目描述
您将获得一个 n×n 的网格，网格中每个正方形的颜色为黑色或白色。如果满足以下所有条件，则网格是正确的：
每行的黑色方块数与白色方块数相同。
每列的黑色正方形数与白色方块数相同。
没有行或列具有 3 个及以上相同颜色的连续正方形。
给定网格，确定它是否正确。
输入格式
第一行一个数字 n（2≤n≤24)， 并且数字 n 是偶数。
接下来 n 行，每行包含一个长度为n的由字符B和W组成的字符串，代表网格正方形的颜色。
输出格式
如果网格正确，请打印数字 1 在一行上。否则，请打印数字 0 在一行上。
样例输入
4
WBBW
WBWB
BWWB
BWBW
样例输出
1
思路
分别计算行、列白or黑数是否为n/2
分别判断是否有超过三个的连续色块
代码
#include <bits/stdc++.h>
using namespace std;
int n;
char a[25][25];
int main(){
cin >> n;
int ans = 1;
for(int i = 1; i <= n; i++){
int sh=0;
for(int j = 1; j <= n; j++){
cin >> a[i][j];
if(a[i][j]=='W') sh++;
}
if(sh!=n/2) ans=0;
}
for(int i = 1; i <= n; i++){
int sl = 0;
for(int j = 1; j <= n; j++){
if(a[j][i]=='W') sl++;
if(a[j-1][i]==a[j][i] && a[j+1][i]==a[j][i]) ans = 0;
}
if(sl!=n/2) ans=0;
}
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n; j++){
if(a[i][j-1]==a[i][j] && a[i][j]==a[i][j+1]) ans = 0;
}
}
cout << ans << endl;
}
304整齐的数组
题目描述
Polycarp 有一个长度为 n 的数组 a 1 , a 2 , . . . , a n a_1,a_2,...,a_n a1,a2,...,an（n 是偶数）。Polycarp 还得到了一个正整数 k，他开始对数组 a 做如下操作：选择一个下标 i (1≤i≤n) 使 a i a_i ai 减去 k。
在 Polycarp 进行若干次操作后（可能 0 次），数组 a 中的所有数都变成相同的了。请你找到最大的符合要求的 k，如果 k 可以为任意大，请输出 −1。
输入格式
第一行一个整数 t，表示测试单元的个数。
接下来每个测试单元有两行。第一行包含一个偶数 n。第二行包含 n 个整数 a 1 , a 2 , . . . , a n a_1,a_2,...,a_n a1,a2,...,an。
输出格式
对于每个测试单元输出单独一行一个整数 k (k≥1) —— Polycarp 能用来对数组进行操作的最大的数，或者 −1 —— 如果 k 能任意大的话。
样例输入
3
6
1 5 3 1 1 5
8
-1 0 1 -1 0 1 -1 0
4
100 -1000 -1000 -1000
样例输出
2
1
1100
数据规模
所有数据保证 1 ≤ t ≤ 10 ， 4 ≤ n ≤ 40 1≤t≤10，4≤n≤40 1≤t≤10，4≤n≤40（n 是偶数）， − 106 ≤ a i ≤ 106 −106≤a_i≤106 −106≤ai≤106，并且 n 的总和不超过100。
思路
找各个元素与最小元素距离的最大公因数
（竟然不会求两个数之间的最大公因数了，我真垃圾）不过还好，有__gcd()帮我解决
代码
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e6;
int t,n;
int a[45];
int main(){
cin >> t;
for(int i = 1; i <= t; i++){
cin >> n;
int Min = Max;
for(int j = 1; j <= n; j++){
cin >> a[j];
Min = min(Min,a[j]);
}
int gcd = 0;
for(int j = 1; j <= n; j++){
if(a[j]>Min) gcd = __gcd(gcd,a[j]-Min);
}
if(gcd) cout << gcd << endl;
else cout << -1 << endl;
}
}
443
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
