A. All with Pairs（KMP+Hash+map）
思路:
我们很容易想到的一个方法就是，就算出每个字符串的每个后缀的哈希值将其存入一个$map$，然后计算每个前缀的哈希值，在$map$中查看有多少个后缀的哈希值与其相同，累加即为答案
但是这样做有时候我们会重复计数，比如在对$“aba”$ 与 $"caba"$比对时，后缀$"a"$，与后缀$“aba”$都会被统计到，但是我们只希望最长的那个被统计
现在我们考虑如何去除重复部分，我们可以考虑用$kmp$算法中的$next$数组来帮助我们去除重复
我们知道对于每个位置$i$的$nxt[i]$值，会有这样的性质，$S_{1...nxt[i]}=S_{i-nxt[i]+1...i}$
又由于，如果两个字符串的匹配长度为$i$时，会有$S_{1...nxt[i]}=T_{|t|-nxt[i]+1...|t|}$，所以$S_{i-nxt[i]+1...i}=T_{|t|-nxt[i]+1...|t|}$
这样我们就知道了对于长度为$i$的前缀，会在$nxt[i]$处发生一起重叠计算，在计算时我们在减去重叠部分即可
#include<iostream> #include<algorithm> #include<map> using namespace std; typedef unsigned long long ull; typedef long long ll; const int maxn=1e6+10; const ll mod=998244353; const int p = 233; map<ull,int> m; string s[maxn]; int nxt[maxn]; ll tmp[maxn]; void get_next(string w){ int len=w.size(),k=-1; nxt[0]=-1; for(int i=1;i<len;i++){ while(k>-1&&w[k+1]!=w[i]) k=nxt[k]; if(w[k+1]==w[i]) k++; nxt[i]=k; } } void get_hash(string s) { ull t=0,k=1; for(int i=s.length()-1;i>=0;i--){ t+=(s[i]-'a'+1)*k; k*=p; m[t]++; } } int main() { ll ans=0,n; cin>>n; for(int i=1;i<=n;i++){ cin>>s[i]; get_hash(s[i]); } for(int i=1;i<=n;i++){ ull t=0; get_next(s[i]); for(int j=0;j<s[i].length();j++){ t=t*p+(s[i][j]-'a'+1); tmp[j]=m[t]; } for(int j=0;j<s[i].length();j++) if(nxt[j]>=0) tmp[nxt[j]]-=tmp[j]; for(ll j=0;j<s[i].length();j++){ ans+=(tmp[j]%mod)*((j+1)*(j+1)%mod); ans%=mod; } } cout<<ans; return 0; }
B - Boundary（sort）
思路：
枚举两个点确定出圆心直接计数即可。
这里通过$sort$来计数，比直接$map$来要快一些
#include<bits/stdc++.h> #define MP make_pair #define fi first #define se second #define pb push_back #define sz(x) (int)(x).size() #define all(x) (x).begin(), (x).end() #define INF 0x3f3f3f3f using namespace std; typedef long long ll; typedef pair<int, int> pii; //head const int N = 2000 + 5; const double eps = 1e-10; typedef pair<double, double> pdd; int n; struct Point { int x, y; } a[N]; pdd solve(Point a, Point b, Point c) //三点共圆圆心公式 { double fm1=2 * (a.y - c.y) * (a.x - b.x) - 2 * (a.y - b.y) * (a.x - c.x); double fm2=2 * (a.y - b.y) * (a.x - c.x) - 2 * (a.y - c.y) * (a.x - b.x); if (fm1 == 0 || fm2 == 0) { return MP(1e18, 1e18); } double fz1=a.x * a.x - b.x * b.x + a.y * a.y - b.y * b.y; double fz2=a.x * a.x - c.x * c.x + a.y * a.y - c.y * c.y; double X = (fz1 * (a.y - c.y) - fz2 * (a.y - b.y)) / fm1; double Y = (fz1 * (a.x - c.x) - fz2 * (a.x - b.x)) / fm2; return MP(X, Y); } bool operator == (pdd A, pdd B) { return fabs(A.fi - B.fi) <= eps && fabs(A.se - B.se) <= eps; } void run() { cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i].x >> a[i].y; } vector<pdd> res; for (int i = 1; i <= n; i++) { for (int j = i + 1; j <= n; j++) { pdd now = solve({0, 0}, a[i], a[j]); if (now == MP(1e18, 1e18)) continue; res.push_back(now); } } if (sz(res) == 0) { cout << 1 << ' '; return; } sort(all(res)); int ans = 1, t = 1; pdd now = res[0]; for (int i = 1; i < sz(res); i++) { if (res[i] == now) { ++t; } else { ans = max(ans, t); now = res[i]; t = 1; } } ans = max(ans, t); for (int i = 2; i <= n; i++) { if (i * (i - 1) == 2 * ans) { cout << i << ' '; return; } } } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cout << fixed << setprecision(20); run(); return 0; }
C - Cover the Tree（DFS）
思路:
最少链的个数为$left lceil frac{num}{2}
ight
ceil$，$num$为叶子节点的个数
对于$n≤2$的情况，直接将两个节点相连
当$n≥3$时，链连接的方法为，我们先找出一个非叶子作为根，进行$dfs$，求出每个叶子节点的$dfs$序
之后，将$l_{1}$与$l_{frac{num}{2}+1}$，$l_{1}$与$l_{frac{num}{2}+2}$进行配对以此类推，如果$num$为奇数，则将最后一个点与根节点进行配对
#include<iostream> #include<algorithm> #include<vector> using namespace std; const int maxn=2e5+10; vector<int> a[maxn],ans; int d[maxn]; void dfs(int x,int fa) { int son=0; for(int i=0;i<a[x].size();i++){ int v=a[x][i]; if(v==fa) continue; son++; dfs(v,x); } if(son==0) ans.push_back(x); } int main() { int n,u,v; scanf("%d",&n); for(int i=1;i<n;i++){ scanf("%d%d",&u,&v); a[u].push_back(v); a[v].push_back(u); d[u]++,d[v]++; } int rt=1; for(int i=1;i<=n;i++){ if(d[i]>1){ rt=i; } } dfs(rt,0); int num=(ans.size()+1)/2; cout<<num<<endl; for(int i=0;i+num<ans.size();i++){ cout<<ans[i]<<" "<<ans[i+num]<<endl; } if(ans.size()%2) cout<<rt<<" "<<ans[ans.size()/2]<<endl; }
D - Duration（思维）
思路:
将两个时间分别化成秒，答案就为两个时间相减的绝对值
#include"bits/stdc++.h" using namespace std; int main() { int a,b,c,ans1=0,ans2=0; scanf("%d",&a); getchar(); scanf("%d",&b); getchar(); scanf("%d",&c); ans1=c+60*(b+60*a); scanf("%d",&a); getchar(); scanf("%d",&b); getchar(); scanf("%d",&c); ans2=c+60*(b+60*a); printf("%d ",abs(ans1-ans2)); return 0; }
F. - Fake Maxpooling（单调队列）
思路：
先求出$lcm$矩阵，暴力求可能会超时，应该用记忆化方法来求
之后求每个子矩阵最大值用到二维单调队列去求，整个算是时间复杂度为$O(n*m)$
#include<iostream> #include<algorithm> #include<cstring> using namespace std; typedef long long ll; const int maxn=5001; int a[maxn][maxn],mx[maxn][maxn],q[maxn],q2[maxn]; int main() { int n,m,k; cin>>n>>m>>k; for(int i=1;i<=n;i++){ for(int j=1;j<=m;j++){ if(!mx[i][j]) for(int k=1;k*i<=n&&k*j<=m;k++){ mx[i*k][j*k]=k; a[i*k][j*k]=i*j*k; } } } memset(mx,0,sizeof(mx)); int h=1,t=0; for(int i=1;i<=n;i++){ h=1,t=0; for(int j=1;j<=m;j++){ while(h<=t&&q[h]<(j-k+1)) h++; while(h<=t&&a[i][q[t]]<=a[i][j]) t--; q[++t]=j; mx[i][j]=a[i][q[h]]; } } for(int i=k;i<=m;i++){ h=1,t=0; for(int j=1;j<=n;j++){ while(h<=t&&q2[h]<(j-k+1)) h++; while(h<=t&&mx[q2[t]][i]<=mx[j][i]) t--; q2[++t]=j; mx[j][i]=mx[q2[h]][i]; } } ll ans=0; for(int i=k;i<=n;i++) for(int j=k;j<=m;j++) ans+=mx[i][j]; cout<<ans; }
G - Greater and Greater（bitset）
思路：
对于每个$b_{i}$，我们建立一个$bitset$，如果$a_{j}≥b_{i}$，那么$b_{i}$对应的$bitset$的第$j$位就为$1$
如果暴力求出每个$bitset$肯定会超时，所以我们对$a$数组与$b$数组进行从大到小排序，就可以在$O(n+m)$的时间复杂度内求出每个$bitset$（具体实现看代码），并且由于经过排序，我们可以只使用一个$bitset$来存储信心
如果对于第$i$个$bitset$的位置$j$上为1，那么在$j-pos[i]+1$位置上的元素就有可能成为一个可行子数组的开头，我们对没个$biset$的所有可行开头求一个交集，交集中$1$的个数就为答案
#include<iostream> #include<algorithm> #include<bitset> using namespace std; const int maxn=150000+10; int a[maxn],b[maxn],p1[maxn],p2[maxn]; bitset<maxn> ans,now; int main() { int n,m; scanf("%d%d",&n,&m); for(int i=1;i<=n;i++) scanf("%d",&a[i]); for(int i=1;i<=m;i++) scanf("%d",&b[i]); iota(p1+1,p1+n+1,1); iota(p2+1,p2+m+1,1); sort(p1+1,p1+n+1,[&](int i,int j){ return a[i]>a[j]; }); sort(p2+1,p2+m+1,[&](int i,int j){ return b[i]>b[j]; }); ans.set(); int pos=1; for(int i=1;i<=m;i++){ while(pos<=n&&a[p1[pos]]>=b[p2[i]]){ now.set(p1[pos]); pos++; } ans&=(now>>(p2[i]-1)); } cout<<ans.count(); }
H - Happy Triangle
思路：
我们先分析操作三，对于$x$我们可以将其分为两种情况讨论
如果$x$是三角形的最长边，我们我们肯定希望在小于$x$的数中找到最大的两个观察是否可行，这个操作可以用$map$与$set$完成
如果不是最长边，我们假设最长边为$b$，另外一条边为$a$，那么我们必须满足$x+a>b$这个不等式，移项一下$x>b-a$
要想使$b-a$尽可能的小，我们自然是希望$b$跟$a$在排序过集合中是相邻的两项
所以我们先将所有数读入，之后进行离散化建立线段树，线段树的维护的是集合中元素$i$与比左边元素的差值，如果集合中不存在比其小的值，则设置为$inf$
#include<iostream> #include<algorithm> #include<set> #include<map> #define inf 0x3f3f3f3f #define ls rt<<1 #define rs rt<<1|1 using namespace std; typedef long long ll; const int maxn=2e5+10; ll sum[maxn<<2]; //sum为线段树区间最小值数组 int op[maxn],x[maxn],y[maxn];//离线存储每次操作的数组，y数组为离散化后的数组 set<int> s; map<int,int> m,m1;//m1为存储离散化后的位置 void push_up(int rt) { sum[rt]=min(sum[ls],sum[rs]); } void build(int l,int r,int rt) { if(l==r){ sum[rt]=inf; return; } int mid=(l+r)>>1; build(l,mid,ls); build(mid+1,r,rs); push_up(rt); return; } void update(int l,int r,int rt,int pos,ll val) { if(l==r){ sum[rt]=val; return; } int mid=(l+r)>>1; if(pos<=mid) update(l,mid,ls,pos,val); else update(mid+1,r,rs,pos,val); push_up(rt); } ll query(int l,int r,int L,int R,int rt) { if(l>=L&&r<=R) return sum[rt]; int mid=(l+r)>>1; if(R<=mid) return query(l,mid,L,R,ls); if(L>mid) return query(mid+1,r,L,R,rs); return min(query(l,mid,L,R,ls),query(mid+1,r,L,R,rs)); } int main() { int n,tot,q; scanf("%d",&n); for(int i=1;i<=n;i++){ scanf("%lld%lld",&op[i],&x[i]); y[i]=x[i]; } sort(y+1,y+1+n); tot=unique(y+1,y+1+n)-y-1; for(int i=1;i<=tot;i++) m1[y[i]]=i; build(1,tot,1); set<int> ::iterator it,it1,it2; for(int i=1;i<=n;i++){ if(op[i]==1){ m[x[i]]++; if(m[x[i]]==1){ s.insert(x[i]); it=it1=it2=s.find(x[i]); it2++; if(it!=s.begin()){//如果有比x小的数，我们就更新x在线段树中的值为两个数的差值 it1--; update(1,tot,1,m1[x[i]],x[i]-(*it1)); } if(it2!=s.end()&&m[*it2]==1){//如果有比x大的数，并且其个数只能为1，因为如果个数位置，其最小差值就为0 update(1,tot,1,m1[*it2],(*(it2)-x[i])); } } else update(1,tot,1,m1[x[i]],0);//有两个或以上一样的x，差值最小值就为0 } if(op[i]==3){ it1=it2=it=s.lower_bound(x[i]); if(m[x[i]]>=2){ printf("Yes "); continue; } if(m[x[i]]==1&&it!=s.begin()){ printf("Yes "); continue; } if(it!=s.begin()){ it1--; if(m[*it1]>=2){ if((*it1)*2>x[i]){ printf("Yes ");continue; } } int tmp=*it1; if(it1!=s.begin()){ it1--; tmp+=*it1; if(tmp>x[i]){ printf("Yes ");continue; } } } if(query(1,tot,m1[x[i]],tot,1)<x[i]) printf("Yes "); else printf("No "); } if(op[i]==2){ m[x[i]]--; if(m[x[i]]==1){//只剩下一个x it=s.find(x[i]); if(it!=s.begin()){ it--; update(1,tot,1,m1[x[i]],x[i]-(*it));//原先为0，更新为与前面数的差值 } else update(1,tot,1,m1[x[i]],inf);//前面没有数，由于不能删除线段树的点，所以将其值设为无穷 } if(m[x[i]]==0){ it=it1=it2=s.find(x[i]); it2++; it1--; if(it2!=s.end()&&m[*it2]==1){ if(it!=s.begin()){ update(1,tot,1,m1[*it2],(*it2)-(*it1)); } else update(1,tot,1,m1[*it2],inf); } update(1,tot,1,m1[x[i]],inf); s.erase(x[i]); } } } return 0; }
J - Just Shuffle（群论）
思路：
因为$k$为质数，所以在置换时循环大小不会变化，所以给定排列的循环大小就是置换的循环大小
对于每一个循环单独考虑，将$k mod len$当做一次置换（注意给出的是置换完的样子，而不是置换）
那么只要找到$x*k mod len =1$时的$x$，做$x$次置换，就可以得到答案
#include"bits/stdc++.h" #define ll long long using namespace std; int a[100005]; int save[100005]; int ans[100005]; struct _ { int ts; int pos; }; ll mod; int gcd(int a,int b) { if(a==0||b==0)return a+b; return gcd(b,a%b); } ll pows(ll a,ll b) { ll ans=1; for(;b;b>>=1,a=a*a%mod) { if(b%2)ans=ans*a%mod; } return ans%mod; } int eular(int n) { int ans=1,i; for(i=2;i*i<=n;i++) { if(n%i==0) { n/=i,ans*=i-1; while(n%i==0)n/=i,ans*=i; } } if(n>1) ans*=n-1; return ans; } int solve(int a,int b) { a%=b; if(gcd(a,b)>1)return -1; mod=(ll)b; return (int)pows((ll)a,(ll)eular(b)-1); } int main() { int n,k; cin>>n>>k; vector<struct _>v; for(int i=1;i<=n;i++) { scanf("%d",a+i); ans[i]=i; } for(int i=1;i<=n;i++)if(save[i]==0) { int t=0,p=i; while(1) { if(save[p]==1)break; save[p]=1; t++; p=a[p]; } struct _ test; test.ts=t; test.pos=i; if(t>1) v.push_back(test); } for(vector<struct _>::iterator it=v.begin();it!=v.end();it++) { int c=solve(k,it->ts); if(c==-1) { printf("-1 "); v.clear(); return 0; } int t=c,p=(it->pos),p1,p2; p2=p; t--; while(t--) {//cout<<p<<endl; p2=a[p2]; } p1=p; t=(it->ts); while(t--) { ans[p1]=a[p2]; p1=a[p1]; p2=a[p2]; } } v.clear(); for(int i=1;i<=n;i++) { if(i==1)printf("%d",ans[1]); else printf(" %d",ans[i]); } putchar(10); return 0; }