总结：
这次比赛上来看见有人L过了，然后题意读明白就直接写了，然后去看B，发现是一个环，而负数相当于（n+x），然后用个指针记录下位置就过了，然后去看A，刚开始想错了，以为蛤可以存起来，然后wa了一发，后来发现蛤不能存，直接把离线下来倒着处理，就过了。然后开C和F，C想到了要判断最长边然后找大小拇指，但是找到之后却不知道怎么判断就写了一半，F想到了ef-ed=a，是扩展欧几里得，但是没想到d、f怎么处理，也是写了一半，总的来说，还是菜。
A
题意
有一个鱼池，共有4种状态1，2，3，4分别对应无虫无鱼，有虫无鱼，无虫有鱼，有虫有鱼，鱼塘每天更新一次状态，你每天可以进行一次行动如在有鱼的情况下抓一条鱼不消耗鱼饵，无鱼的情况下消耗一个鱼饵抓一条鱼，在有虫的情况下制作一个鱼饵。
思路
对于3，4情况是固定的必抓鱼，只需讨论0，1，用贪心的思想从后往前做，如果鱼饵大于0就抓鱼，否则制作鱼饵。
代码
using namespace std;
int t,n,x,i,j,tot;
int main()
{
string s;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
cin>>s;
tot=x=i=0;
bool flag=0;
while(s[i]=='0') i++;
for(;i<n;i++)
{
if(s[i]=='2' || s[i]=='3')
{
tot++;
continue;
}
if(flag==0 && s[i]=='1') flag=1;
if(flag==1 && s[i]=='1') x++;
if(flag==1 && s[i]=='0' && x) tot++,x--;
}
if(x>=2) tot+=x/2;
printf("%d\n",tot);
}
return 0;
}
B
题意
给你一个字符串，n次操作。m表示把前面k个字符挪后面，或把后面-k（k为负数）个挪前面。a表示询问，第k个字母是什么。
思路
将整个字符串循环起来看的话，其实每次操作并没有改变整体的顺序，就是用一个数组来模拟这个循环队列就好。每次操作改变的就是起始位置的下标值而已。
代码
#include<iostream>
#include<cmath>
#include<stack>
#include<vector>
#include<cstring>
#include<algorithm>
#include<set>
#include<queue>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <complex>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cassert>
using namespace std;
typedef long long ll;
const ll inf =1e17;
#define scn(a) scanf("%d",&a)
#define scd(a) scanf("%lf",&a)
#define scc(a) scanf("%c",&a)
#define scl(a) scanf("%lld",&a)
#define ptf(a) printf("%d\n",a)
#define mes(a,b) memset(a,b,sizeof(a))
#define fon(s,n) for(int i=s;i<=n;i++)
#define range(i,a,b) for(int i=a;i<=b;++i)
#define rerange(i,a,b) for(int i=a;i>=b;--i)
//#define N 100010
const int S=20;
ll gcd(ll a,ll b) { return b>0 ? gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
ll q_pow(ll a,ll b,ll mod)
{
ll ans=1,res=a;
while(b){
if(b&1) ans=ans*res%mod;
res=res*res%mod;
b>>=1;
}
return ans%mod;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
string s;
cin>>s;
string temp;
int q,pos;char c;
cin>>q;
int n=s.length();
int head=0;
while(q--){
cin>>c;
if(c=='M'){
cin>>pos;
head+=pos;
head=(head+n)%n;
//ptf(head);
}
else{
cin>>pos;
//pos=(pos+n)%n;
cout<<s[(head+pos-1+n)%n]<<"\n";
}
}
return 0;
}
C
题意
爱丽丝是机器人社会中的美人。很多机器人都想娶她。爱丽丝决定嫁给一个能解决以下难题的机器人：首先，爱丽丝的右掌形状如下：爱丽丝的左掌形状与右手掌对称。在这个谜题中，爱丽丝会给挑战者许多她手掌的手印。挑战者必须正确地告诉爱丽丝每个手印是她的左手还是右手。请注意，Alice手掌的手印是由其二维平面坐标按顺时针或逆时针顺序给出的。形状可以旋转和平移。但形状不会被放大或缩小。虽然你不是机器人，但你对解谜感兴趣。请试着解决这个难题。
多个测试组。爱丽丝手印的数量拼图。每一个手印由一个由20个点组成的简单多边形来描述。这个多边形中的每个点都将按顺时针或逆时针顺序给出。每行包含两个实数，小数点后正好有六位数，代表一个点的坐标。所以手印是由20行组成的输入。全部输入中坐标值的范围为[-1000.0000000，1000.000000]。
对于每一个手掌印，打印一行包含“right”或“left”，分别表示脚印是右掌还是左掌。
思路
按照输入点的顺序，找到边为9，即边最长的一条边的两端点、其后输入的点。若三点叉积和为正，说明逆时针输入点，反之，说明顺时针输入点。
若逆时针输入点，边出现的顺序为9，6时，为左手图形；若顺时针输入点，边出现的顺序为9，8时，为左手图形。其余情况为右手图形。
代码
#include<bits/stdc++.h>
using namespace std;
#define IO ios::sync_with_stdio(false),cin.tie(0);
#define ll long long
#define inf 0x3f3f3f3f
const int N=1e5+5;
//set<string>b;
//set<string>::iterator it;
double eps=1e-4;
struct node
{
double x,y;
}p[25];
double dis(node a,node b)
{
return 1.0*sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
double cross(node a,node b,node c)
{
return (a.x-c.x)*(b.y-c.y)-(a.y-c.y)*(b.x-c.x);
}
int main()
{
IO;
int T,flag,i;
cin>>T;
while(T--)
{
flag=0;
node a,b,c;
for(i=0;i<20;i++)
{
cin>>p[i].x>>p[i].y;
}
for(i=0;i<20;i++)
{
if(fabs(dis(p[i],p[(i+1)%20])-9.0)<eps)
{
break;
}
}
a=p[i],b=p[(i+1)%20],c=p[(i+2)%20];
if(cross(a,b,c)>0&&fabs(dis(b,c)-6.0)<eps) flag=1;
if(cross(a,b,c)<0&&fabs(dis(b,c)-8.0)<eps) flag=1;
if(flag==1) cout<<"left\n";
else cout<<"right\n";
}
return 0;
}
E
题意
给你一个有n个元素的数列，然后要求你构造两个数列，使得p[p[i]]=i，q[q[i]]=i，且满足使得a[i]−a[p[i]]的绝对值和/2 最小，a[i]−a[q[i]]的绝对值和/2 也要最小，且p和q每一位都不等。
思路
比赛时没看，下来看的，第一反应就是将a排序，得到一组有序数列，直接相邻两个相减就是最小值了，但是很明显，这是有局限性的。我们还需要考虑次小值，也就是将数列前移一格，然后让第一个数到末尾，然后两个一组相减，那么这个就是次优解。由于匹配规则要不一样，不能出现两两相邻匹配，第一个排列的构造肯定是2 1 4 3 6 5…，即交换相邻两位，这样花费最小。第二个排列不能与第一个排列冲突，假设可以拆成很多4，那么构造方法为 3 1 4 2。
除了4，为了使得交换位置的数尽可能相近，我们可以再拆6，对长度为6的排列，最优的构造方法为 3 1 5 2 4 6，可以枚举出所以排列方法，发现此种方法最优。最后一定是多个4和多个6的组合，dp即可。
Ps：这个题答案到了ll，习惯性inf设0x3f3f3f3f会wa。
代码
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=2e5+5;
const ll inf=1e18;
int a[maxn];
ll dp[maxn];
int main(){
int te;
cin>>te;
while(te--){
int n;
cin>>n;
for(int i=1;i<=n;++i)
cin>>a[i];
sort(a+1,a+1+n);
ll ans=0;
for(int i=2;i<=n;i+=2)
ans+=(a[i]-a[i-1]);
for(int i=1;i<=n;++i)
dp[i]=inf;
dp[4]=a[4]+a[3]-a[2]-a[1];
dp[6]=a[6]-a[4]+a[5]-a[2]+a[3]-a[1];
for(int i=8;i<=n;i+=2){
ll x,y;
x=dp[i-4]+a[i]+a[i-1]-a[i-2]-a[i-3];
y=dp[i-6]+a[i]-a[i-2]+a[i-1]-a[i-4]+a[i-3]-a[i-5];
dp[i]=min(x,y);
}
printf("%lld\n",ans+dp[n]);
}
return 0;
}
F
题意
给出a，b，求c / d - e / f = a / b的一个可行解。且d, f < b
思路
如果gcd(a, b)> 1, 一定有解如下 c = a / gcd(a,b) + 1, d = f = b / gcd(a,b),e = 1。
如果b = 1或者为素数，则一定无解。
如果b 只含有一个素因数，比如27 = 3^3,也一定无解。
b 拆分成 d * f， 所以c * f - d * e = a，这里就可以用扩展欧几里得求解。
代码
#include<bits/stdc++.h>
#define ll long long
#define INF 0x3f3f3f3f
#define LLINF 0x3f3f3f3f3f3f3f3f
#define pii pair<int,int>
#define vi vector<int>
#define SZ(x) (int)x.size()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
using namespace std;
const int N = 2000005;
bool notp[N];
ll prime[N], pnum;
void sieve() {
memset(notp, 0, sizeof(notp));
notp[0] = notp[1] = 1;
pnum = 0;
for(int i = 2; i < N; i++) {
if(!notp[i]) prime[++pnum] = i;
for(int j = 1; j <= pnum && prime[j] * i < N; j++) {
notp[i *prime[j]] = 1;
if(i % prime[j] == 0) break;
}
}
}
void exgcd(ll a,ll b,ll &g,ll &x,ll &y) {//ax+by=gcd(a,b)=g
if (b == 0) {
g = a;
x = 1;
y = 0;
return;
}
exgcd(b, a % b, g, y, x);
y -= (a / b) * x;
}
int main() {
sieve();
int t;
scanf("%d", &t);
while(t--) {
ll a, b, c, d, e, f;
scanf("%lld%lld", &a, &b);
if(__gcd(a,b) != 1) {
ll gcd = __gcd(a,b);
printf("%lld %lld %lld %lld\n", a / gcd + 1, b / gcd, 1, b / gcd);
continue;
}
if(b == 1 || notp[b] == 0) {
printf("-1 -1 -1 -1\n");
continue;
}
ll tmp = b;
d = 1;
for(int i = 1; i <= pnum; i++) {
if(tmp == 1) break;
if(tmp % prime[i] == 0) {
while(tmp % prime[i] == 0) {
tmp /= prime[i];
d *= prime[i];
}
break;
}
}
f = tmp;
// cout << f << " " << d << '\n';
if(tmp == 1) { // x^n
printf("-1 -1 -1 -1\n");
}
else {
ll g;
exgcd(f, d, g, c, e); // cf - de = a
if(a % g) {
printf("-1 -1 -1 -1\n");
continue;
}
c *= (a / g);
e *= (a / g);
if (c < 0 && e > 0)
printf("%lld %lld %lld %lld\n", e, f, -c, d);
else
printf("%lld %lld %lld %lld\n", c, d, -e, f);
}
}
}
G
题意
给你n个点，m条边，然后有q次操作，每次给一个x，表示将于x所连的所有点归并到x团里面，最后问每个点属于哪个团。
思路
自己只想到了并查集，但是有关合并的地方却很乱，看了大佬的博客才明白一点。每次将给出的集合所连的集合全都合并，且每个点只会产生一次贡献，即若询问的是该点，那么之后该点与其所连的点将永远一个集合。我们选择用并查集维护属于哪个集合，再用vector存储该集合外部所连的点有哪几个。
代码
#include<bits/stdc++.h>
#define pb(a) push_back(a)
using namespace std;
const int maxn=8e5+5;
int fa[maxn];
vector<int> g[maxn];
int Find(int x){
return fa[x]==x?x:fa[x]=Find(fa[x]);
}
void hb(vector<int>&x,vector<int>&y){
if(x.size()<y.size())swap(x,y);
for(int u:y)x.pb(u);
}
int main(){
int te;
cin>>te;
while(te--){
int n,m;
cin>>n>>m;
for(int i=0;i<n;++i)
fa[i]=i,g[i].clear();
int x,y;
for(int i=1;i<=m;++i){
cin>>x>>y;
g[x].pb(y);
g[y].pb(x);
}
int q;
cin>>q;
while(q--){
cin>>x;
if(Find(x)!=x) continue;
vector<int>now=g[x];
g[x].clear();
for(auto v:now){
int f=Find(v);
if(f==x) continue;
hb(g[x],g[f]);
fa[f]=x;
}
}
for(int i=0;i<n;++i)
printf("%d ",Find(i));
puts("");
}
return 0;
}
256
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
