前言
byd从B开始就初见端倪了，连着好几题都多少带点guess成分，两题从2000到10000名......
一、A. Carnival Wheel
cpp
#include <bits/stdc++.h>
using namespace std;
/* /\_/\
* (= ._.)
* / > \>
*/
/*
*想好再写
*注意审题 注意特判
*不要红温 不要急躁 耐心一点
*WA了不要立马觉得是思路不对 先耐心找反例
*/
#define dbg(x) cout<<#x<<endl;cout<<x<<endl;
#define vdbg(a) cout<<#a<<endl;for(auto x:a)cout<<x<<" ";cout<<endl;
#define INF 1e9
#define INFLL 1e18ll
#define YES cout<<"YES"<<endl;return ;
#define Yes cout<<"Yes"<<endl;return ;
#define NO cout<<"NO"<<endl;return ;
#define No cout<<"No"<<endl;return ;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int dx[]={-1,1,0,0};
const int dy[]={0,0,-1,1};
const int ddx[]={-2,-1,1,2,2,1,-1,-2};
const int ddy[]={1,2,2,1,-1,-2,-2,-1};
void solve()
{
int l,a,b;
cin>>l>>a>>b;
int ans=a;
for(int i=1;i<=l;i++)
{
a=(a+b)%l;
ans=max(ans,a);
}
cout<<ans<<endl;
}
void init()
{
}
signed main()
{
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t=1;
cin>>t;
init();
while(t--)
{
solve();
}
return 0;
}这个A没啥好说的，直接模拟就可以了，因为最多最多就是跳l次把整个环上每个点都覆盖，再加上环的大小不大，所以直接暴力模拟取最大值即可。
二、B. Ashmal
cpp
#include <bits/stdc++.h>
using namespace std;
/* /\_/\
* (= ._.)
* / > \>
*/
/*
*想好再写
*注意审题 注意特判
*不要红温 不要急躁 耐心一点
*WA了不要立马觉得是思路不对 先耐心找反例
*/
#define dbg(x) cout<<#x<<endl;cout<<x<<endl;
#define vdbg(a) cout<<#a<<endl;for(auto x:a)cout<<x<<" ";cout<<endl;
#define INF 1e9
#define INFLL 1e18ll
#define YES cout<<"YES"<<endl;return ;
#define Yes cout<<"Yes"<<endl;return ;
#define NO cout<<"NO"<<endl;return ;
#define No cout<<"No"<<endl;return ;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int dx[]={-1,1,0,0};
const int dy[]={0,0,-1,1};
const int ddx[]={-2,-1,1,2,2,1,-1,-2};
const int ddy[]={1,2,2,1,-1,-2,-2,-1};
void solve()
{
int n;
cin>>n;
vector<string>a(n+1);
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
string s;
for(int i=1;i<=n;i++)
{
if(s+a[i]<a[i]+s)
{
s+=a[i];
}
else
{
s=a[i]+s;
}
}
cout<<s<<endl;
}
void init()
{
}
signed main()
{
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t=1;
cin>>t;
init();
while(t--)
{
solve();
}
return 0;
}从这个题开始就初见端倪了。
贪心的思路很好想，就是每次如果往前面放所拼出来的字符串比往后面放小，那么就往前面拼，否则就往后面拼。
最草的是赛时guess到了没敢写，还简单证明了一下。证明就是，假设此时拼好的字符串为s，当前字符串为a，下一个字符串为b。若a+s小于s+a，但此时选择了往后放的话，当来到字符串b时，往前拼就是b+s+a，往后拼就是s+a+b。那么可以发现，不管如何拼，字典序都大于a+s的情况。所以这个贪心策略是合理的，每次只考虑当前字符即可。
三、C. XOR-factorization
对数器都跑穿了，一直在debug......
cpp
#include <bits/stdc++.h>
using namespace std;
/* /\_/\
* (= ._.)
* / > \>
*/
/*
*想好再写
*注意审题 注意特判
*不要红温 不要急躁 耐心一点
*WA了不要立马觉得是思路不对 先耐心找反例
*/
#define dbg(x) cout<<#x<<endl;cout<<x<<endl;
#define vdbg(a) cout<<#a<<endl;for(auto x:a)cout<<x<<" ";cout<<endl;
#define INF 1e9
#define INFLL 1e18ll
#define YES cout<<"YES"<<endl;return ;
#define Yes cout<<"Yes"<<endl;return ;
#define NO cout<<"NO"<<endl;return ;
#define No cout<<"No"<<endl;return ;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int dx[]={-1,1,0,0};
const int dy[]={0,0,-1,1};
const int ddx[]={-2,-1,1,2,2,1,-1,-2};
const int ddy[]={1,2,2,1,-1,-2,-2,-1};
void solve()
{
int n,k;
cin>>n>>k;
vector<int>ans(k+1);
if(k%2)
{
//很显然，当k为奇数时，直接让所有元素都是n即可
for(int i=1;i<=k;i++)
{
ans[i]=n;
}
}
else
{
//当k为偶数时，在从高位到低位贪心的过程中
//当遇到一个1时，在给某一个数填0后，之后这个数就可以随便填了
//所以每当遇到一个1，就可以多一个自由填的数
int free=0;
for(int b=31;b>=0;b--)
{
if((n>>b)&1)
{
//能自由填的数可以增加
if(free+1<=k)
{
free++;
}
//当前新增的数填0，其他都填1
for(int i=1;i<free;i++)
{
ans[i]+=1<<b;
}
for(int i=free+1;i<=k;i++)
{
ans[i]+=1<<b;
}
}
else
{
//当前位置是0时，若此时有奇数个可以自由填的数
//那么前free-1个数可以都填1，之后的数都只能填0
if(free%2)
{
for(int i=1;i<=free-1;i++)
{
ans[i]+=1<<b;
}
}
//若当前有偶数个，那么这些可以自由填的数都可以填1
else
{
for(int i=1;i<=free;i++)
{
ans[i]+=1<<b;
}
}
}
}
}
for(int i=1;i<=k;i++)
{
cout<<ans[i]<<" ";
}
cout<<endl;
}
void init()
{
}
signed main()
{
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t=1;
cin>>t;
init();
while(t--)
{
solve();
}
return 0;
}首先，根据异或运算的性质，如果n的某位为0，那么这k个数的这位上1的个数必然是偶数，否则就必然是奇数。
之后，很显然当k为奇数时，可以直接让所有数都是n，那么奇数个n异或完还是n，且自然保证累加和最大。但当k为偶数时，情况就很复杂了。
当k为偶数时，在贪心地从高位到低位填的过程中，如果当前位是1，那么肯定考虑一个数不填，其他数全填1，那么这样就存在奇数个1，且保证收益最大。而如果当前位是0，因为填的数不能比n大，所以对于之前照搬着填的数，此时就只能填0了。此时又可以发现，之前位是1时，有一个数填了0，那么之后这个数不管怎么填，肯定都不会超过n了。所以对于这些可以自由填的数，此时就可以填偶数个1了。
所以结论就是，每出现一个1，就可以新增一个可以自由填的数。那么此时除了新增的这个数，其他数都可以填1。当遇到一个0时，不管有几个可以自由填的数，此时都只能填偶数个1。
四、D. Insolvable Disks
cpp
#include <bits/stdc++.h>
using namespace std;
/* /\_/\
* (= ._.)
* / > \>
*/
/*
*想好再写
*注意审题 注意特判
*不要红温 不要急躁 耐心一点
*WA了不要立马觉得是思路不对 先耐心找反例
*/
#define dbg(x) cout<<#x<<endl;cout<<x<<endl;
#define vdbg(a) cout<<#a<<endl;for(auto x:a)cout<<x<<" ";cout<<endl;
#define INF 1e9
#define INFLL 1e18
#define YES cout<<"YES"<<endl;return ;
#define Yes cout<<"Yes"<<endl;return ;
#define NO cout<<"NO"<<endl;return ;
#define No cout<<"No"<<endl;return ;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int dx[]={-1,1,0,0};
const int dy[]={0,0,-1,1};
const int ddx[]={-2,-1,1,2,2,1,-1,-2};
const int ddy[]={1,2,2,1,-1,-2,-2,-1};
void solve()
{
int n;
cin>>n;
vector<ll>a(n+1);
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
if(n==1)
{
cout<<0<<endl;
return ;
}
//对于第i个点，其半径的最大值取决于到左右两个点距离的最小值
//若当前点能形成的圆半径的取值范围为[l,r]，当前点和下一个点的间距为d
//那么下一个点能形成的圆半径的取值范围就是[d-r,d-l]
//若[l,r]不合法了，那么就说明无法外切，此时让ans--，重设l和r
vector<ll>d(n+1,INFLL);
for(int i=2;i<=n;i++)
{
ll x=a[i]-a[i-1];
d[i]=min(d[i],x);
d[i-1]=min(d[i-1],x);
}
ll l=0,r=d[1];
ll ans=n-1;
for(int i=2;i<=n;i++)
{
ll x=a[i]-a[i-1];
ll nl=max(x-r,0ll);
ll nr=min(x-l,d[i]);
l=nl,r=nr;
if(l>=r)
{
ans--;
l=0,r=d[i];
}
}
cout<<ans<<endl;
}
void init()
{
}
signed main()
{
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t=1;
cin>>t;
init();
while(t--)
{
solve();
}
return 0;
}这题怎么能没写出来的......
很容易发现，对于每个点，其能形成的圆的半径，最大不超过到其左右两点距离的最小值d。那么对于当前点能形成的圆的半径，若取值范围在[l,r]内，到下一个点的距离为x，那么下一个点能形成的圆的半径就在[x-r,x-l]内。在和d取最小值后，若当前的[l,r]不合法了，那么就说明当前点没法和前面的圆外切，那么就需要重置当前点的[l,r]重新考虑了。
感觉这个题其实和之前abc写过的那个鸟上下飞过障碍的一道题很像，都是维护能到达的区间[l,r]，然后判断是否能通过或能连上，这没写出来真该给自己两巴掌......
总结
现在总是莫名其妙地犯病，脑子一团浆糊......