Codeforces Round 913 (Div. 3)
CF1907总结
A. Rook
题面翻译
给出车在国际象棋棋盘中的位置，输出其可到达的坐标（不必在意顺序）。
车可以横着或竖着走任意格数。
分析
题意明了，输出车所在行和列所有格子的序号（除车所在位置外）。
code
#include <bits/stdc++.h>
using namespace std;
int t;
void solve()
{
string x;
cin>>x;
int a=x[0];
int b=x[1]-'0';
for(int i=1;i<=8;i++) if(i!=b) cout<<(char)a<<i<<"\n";
for(int i='a';i<='h';i++) if(a!=i) cout<<(char)i<<b<<"\n";
}
int main ()
{
cin>>t;
while(t--) solve();
return 0;
}
B. YetnotherrokenKeoard
题面翻译
Polycarp 的笔记本键盘坏了。
现在，当他按下 'b' 键时，它的行为类似于退格键：删除已输入字符串中最后一个小写字母。如果已输入字符串中没有小写字母，则完全忽略该按键。
类似地，当他按下 'B' 键时，它删除已输入字符串中最后一个大写字母。如果已输入字符串中没有大写字母，则完全忽略该按键。
给定一个按键序列，输出处理所有按键后的结果。
分析
用两个栈分别存下大写和小写字母的位置，每次删除时若栈非空则取对应栈顶位置删除。
code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e6+5;
int n,m,t,i1[N],i2[N];
char a[N];
string s;
void solve()
{
cin>>s;
n=s.size();
int t1=0,t2=0;
for(int i=0;i<n;i++)
{
a[i]=0;
int x=s[i];
if(x=='b')
{
if(t1)
{
a[i1[t1--]]=0;
}
}
else if(x=='B')
{
if(t2)
{
a[i2[t2--]]=0;
}
}
else
{
if(x>='a'&&x<='z') i1[++t1]=i;
if(x>='A'&&x<='Z') i2[++t2]=i;
a[i]=x;
}
}
for(int i=0;i<n;i++) if(a[i]!=0) cout<<a[i];
cout<<"\n";
}
int main ()
{
cin>>t;
while(t--) solve();
return 0;
}
C. Removal of Unattractive Pairs
题面翻译
有一个长为 \(n\) 的字符串，每次可以删除相邻两个不同的字符，问删除若干次最终可能的最短长度
分析
这让我想到一种类似的题，只不过是把题目和解法反过来。
已知小写字母组成的长度为 \(n\) 的字符串，求个数超过 \(n/2\) 的小写字母，保证至多至少有一个，\(1<n<1\times10^8\)。
- 直接排序，取最中间的那个数，复杂度为 \(O(n\log{n})\)。
- 用一个桶统计个数，再找出满足的那个，复杂度为 \(O(n)\)。
还能不能更快呢？于是聪明的你一定能想到每次读入后删掉两个不同的字母，没错，删掉两个不同的字母后，永远不会影响我们要求的答案。用我们要求的答案来和其他字母相删，最后一定有剩余。这样就能做到更快的线性复杂度求出答案了。
接下来回到这道题，考虑删除难想，不如考虑不删除的情况：
- 字符串为空。
- 只剩下一个字符。
那就好了，相邻的限制已经无所谓了，我们可以知道最短的长度就是让数量最多的字母与其他字母互删，得到剩下的数量 \(num\)，还要注意 \(n\) 如果是奇数的话一定会剩下一个，最后答案就是 \(\max(num,n\bmod2)\)。
code
#include <bits/stdc++.h>
using namespace std;
const int N=2e5+5;
int n,t,a[N];
string s;
void solve()
{
cin>>n>>s;
for(int i=0;i<n;i++) a[s[i]-'a']++;
int ma=0;
for(int i=0;i<26;i++) ma=max(ma,a[i]),a[i]=0;
cout<<max(n&1,ma*2-n)<<"\n";
}
int main ()
{
cin>>t;
while(t--) solve();
return 0;
}
D. Jumping Through Segments
题面翻译
数轴上有 \(n\) 条线段，第 \(i\) 条线段的范围是 \([l_i,r_i]\)。
开始时在原点，每次可以跳至多 \(k\) 的距离，但是在第 \(i\) 次跳跃后一定要站在第 \(i\) 条线段上。
求出最小的 \(k\) 使得你可以跳到第 \(n\) 条线段上。
分析
求最小的 k 值，已知上界和下界，不难看出可以用二分答案，重点思考如何进行判断。
考虑每一步可以到达的区间，第一步可到达 \([-k,k]\) 如果和第二段没有交集，那肯定不满足要求，如果有交集说明下一步要从这交集开始跳，于是范围就变为 \([l-k,r+k]\)。于是我们只需要一直求交集判断下一步是否有交集直到最后。
总复杂度为 \(O(n\log{k})\)。
code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+5;
int n,m,t,a[N],b[N];
int check(int k)
{
int l=0,r=0;
for(int i=1;i<=n;i++)
{
l-=k,r+=k;
if(l>b[i]||r<a[i]) return 1;
l=max(l,a[i]),r=min(r,b[i]);
}
return 0;
}
void solve()
{
cin>>n;
int l=0,r=1,mid;
for(int i=1;i<=n;i++) cin>>a[i]>>b[i],r=max(r,b[i]);
while(l<r)
{
mid=(l+r)>>1;
if(check(mid)) l=mid+1;
else r=mid;
}
cout<<l<<"\n";
}
int main ()
{
cin>>t;
while(t--) solve();
return 0;
}
E. Good Triples
题面翻译
给定一个整数 \(n\)，我们称三元组 \((a,b,c)\) 是“好的”，当且仅当 \(a+b+c=n\) 并且 \(digsum(a)+digsum(b)+digsum(c)=digsum(n)\)。这里的 \(digsum(x)\) 指的是 \(x\) 各个数位之和。
并且三元组的顺序也很重要。例如 \((4,12,10)\) 和 \((10,12,4)\) 不是相同的三元组。
求不同三元组的数量。
分析
容易看出，如果没有进位，则一定能满足条件，如果产生进位，则 \(digsum(a)+digsum(b)+digsum(c)>digsum(n)\)。所以每一位分开来考虑，计算贡献。
code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
int n,m,t,a[N];
void solve()
{
string s;
cin>>s;
n=s.size();
ll ans=1;
for(int i=0;i<n;i++) ans*=a[s[i]-'0'];
cout<<ans<<"\n";
}
int main ()
{
a[0]=1;
for(int i=1;i<=9;i++) a[i]=a[i-1]+i+1;
cin>>t;
while(t--) solve();
return 0;
}
F. Shift and Reverse
题面翻译
给定一个整数数组 \(a_1,a_2, \ldots,a_n\)，你可以对其进行两种操作：
- 移位：将最后一个元素移动到第一位，并将其他元素后移，得到数组 \(a_n,a_1,a_2,\ldots,a_{n-1}\)。
- 翻转：将整个数组翻转过来，得到数组 \(a_n,a_{n-1},\ldots,a_2,a_1\)。
你的任务是用最少得操作次数来对使数组非递增排序，做不到就输出 -1。
分析
从两个操作入手，先考虑移位，将最后一个移动到第一位，有一种比较好想的方法，把数组看成一个环，数组第一个元素位置为 \(i\)。这样操作就变为：
- 移位：按方向将 \(i\) 移动一位。
- 翻转：改变方向，从逆时针改为顺时针，从逆时针改为顺时针。
题目就变成：已知一个环，最初 \(i\) 为 \(1\),找到一个位置 \(i\)，满足从 \(i\) 开始按方向走使回到 \(i\) 前经过的数非递增。答案为 \(i\) 移动的距离加上改变方向的次数。
于是，可将数组复制一倍，从最后开始向前遍历，找到满足条件的 \(i\)，计算答案。翻转相当于改变方向，那么最多只要改变一次，分两种情况，刚开始就翻转或最后再翻转，分别处理。还有一点 \(n=1\) 时答案为 \(0\) 要特判一下。
code
// LUOGU_RID: 140107120
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+5,inf=0x3f3f3f3f;
int n,m,t,a[N];
int work()
{
for(int i=1;i<=n;i++) a[i+n]=a[i];
int ans=inf,cnt=1;
for(int i=2*n-1;i>=1;i--)
{
if(a[i]<=a[i+1]) cnt++;
else cnt=1;
if(cnt==n)
{
ans=min(ans,n-i+1);
break;
}
}
cnt=1;
for(int i=2*n-1;i>=1;i--)
{
if(a[i]>=a[i+1]) cnt++;
else cnt=1;
if(cnt==n)
{
ans=min(ans,n-i+2);
break;
}
}
return ans;
}
void solve()
{
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
if(n==1)
{
cout<<0<<"\n";
return ;
}
int ans=work();
reverse(a+1,a+n+1);
ans=min(ans,work()+1);
if(ans==inf) cout<<-1<<"\n";
else cout<<ans<<"\n";
}
int main ()
{
cin>>t;
while(t--) solve();
return 0;
}
