XIII Open Cup named after E.V. Pankratiev. GP of Ukraine

A. Automaton

后缀自动机可以得到$O(2n+1)$个状态，但是后缀自动机会拒绝接收所有不是$S$的子串的串，所以在建立后缀自动机的时候不复制节点即可得到$n+1$个状态的DFA。

#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<time.h>
#include<assert.h>
#include<iostream>
using namespace std;
typedef long long LL;
typedef pair<int,int>pi;
 
const int Maxn=200020;
int n,q,sz,last,len;
int ml[Maxn],f[Maxn],ch[Maxn][26];
vector<int>G[Maxn];
string ss[Maxn];
string s;
void add(int c)
{
	int p=last;
	if(ch[p][c])
	{
		int q=ch[p][c];
		if(ml[q]==ml[p]+1)last=q;
		else
		{
			int nq=++sz;
			memcpy(ch[nq],ch[q],sizeof(ch[q]));
			ml[nq]=ml[p]+1;
			last=nq;
			f[nq]=f[q];
			f[q]=nq;
			for(;p&&ch[p][c]==q;p=f[p])ch[p][c]=nq;
		}
	}
	else
	{
		int np=++sz;last=np;
		memset(ch[np],0,sizeof ch[np]);
		ml[np]=ml[p]+1;
		for(;p&&!ch[p][c];p=f[p])ch[p][c]=np;
		if(!p){f[np]=1;return;}
		int q=ch[p][c];
		f[np]=q;return;//
		if(ml[q]==ml[p]+1){f[np]=q;return;}
		int nq=++sz;
		memcpy(ch[nq],ch[q],sizeof(ch[q]));
		ml[nq]=ml[p]+1;
		f[nq]=f[q];
		f[q]=f[np]=nq;
		for(;p&&ch[p][c]==q;p=f[p])ch[p][c]=nq;
	}
}
void init(){
  sz=1;memset(ch[sz],0,sizeof ch[sz]);
}
void insert(string &s)
{
	last=1;
	for(int i=0;i<s.size();i++)
	{
		add(s[i]-'a');
	}
}
struct Node{
	int u,v;
	char c;
	Node(){}
	Node(int u,int v,char c):u(u),v(v),c(c){}
};
bool check(int st){
	int cur=1;
	for(int i=st;i<s.size();i++){
		if(!ch[cur][s[i]-'a'])return 0;
		cur=ch[cur][s[i]-'a'];
	}
	return 1;
}
int main(){
	while(cin>>s){
		//s.assign(20,'a');
		//for(int i=0;i<20;i++)s[i]=rand()%5+s[i];
		memset(ch,0,sizeof ch);
		init();
		insert(s);
		vector<Node>rep;
		for(int i=1;i<=sz;i++){
			for(int j=0;j<26;j++){
				if(ch[i][j])rep.push_back(Node(i,ch[i][j],j+'a'));
			}
		}
		/*
		for(int i=0;i<s.size();i++){
			if(!check(i)){
				puts("wa");
				cout<<s<<endl;
				printf("%d\n",i);
				while(1);
			}
		}
		*/
		printf("%d %d\n",sz,(int)rep.size());
		for(int i=0;i<rep.size();i++)printf("%d %d %c\n",rep[i].u,rep[i].v,rep[i].c);
	}
	return 0;
}

　　

B. Beinz

用Lucas定理计算组合数即可，时间复杂度$O(p+t\log n)$。

#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<time.h>
#include<assert.h>
#include<iostream>
using namespace std;
typedef long long LL;
typedef pair<int,int>pi;
const int mod=1e9+7;
const int Maxn=1002000;
int fac[Maxn],rev[Maxn];
int C(int x,int y){
	if(x<y||y<0)return 0;
	return 1LL*fac[x]*rev[y]%mod*rev[x-y]%mod;
}
int main(){
	int k,p,t;
	LL n;
	fac[0]=fac[1]=rev[0]=rev[1]=1;
	for(int i=2;i<Maxn;i++)fac[i]=1LL*i*fac[i-1]%mod;
	for(int i=2;i<Maxn;i++)rev[i]=1LL*(mod-mod/i)*rev[mod%i]%mod;
	for(int i=2;i<Maxn;i++)rev[i]=1LL*rev[i-1]*rev[i]%mod;
	while(scanf("%d%d%d",&k,&p,&t)!=EOF){
		while(t--){
			scanf("%lld",&n);
			LL ans=1;
			while(n){
				ans=1LL*ans*C(n%p+k-1,k-1)%mod;
				n/=p;
			}
			printf("%lld\n",ans);
		}
	}
	return 0;
}

　　

C. Cutting

首先将串插入Trie中，可以去掉一些冗余状态。

设$dp[l][r][x][y]$表示$[l,r]$这个区间切成串$x$的前缀$y$的最少步数，可以枚举下一个匹配点转移。

设$f[l][r]$表示$[l,r]$消完的最小步数，可以暴力转移求解。

在计算$dp$的时候加上可行性剪枝即可，复杂度达不到理论上界$O(n^5)$。

#include <bits/stdc++.h>
using namespace std ;
 
typedef long long LL ;
typedef pair < int , int > pii ;
 
#define clr( a , x ) memset ( a , x , sizeof a )
 
const int N = 105 ;
const int MAXN = 10005 ;
const int INF = 0x3f3f3f3f ;
 
int node[MAXN][26] ;
int word[MAXN] ;
char s[N] , p[N] ;
int dp[N][MAXN] ;
int jump[N][26] , pre[26] ;
int f[N][N] ;
int n , m , cur ;
 
int newnode () {
	clr ( node[cur] , 0 ) ;
	word[cur] = 0 ;
	return cur ++ ;
}
 
void insert ( char s[] ) {
	int now = 0 ;
	for ( int i = 0 ; s[i] ; ++ i ) {
		int x = s[i] - 'a' ;
		if ( !node[now][x] ) node[now][x] = newnode () ;
		now = node[now][x] ;
	}
	word[now] = 1 ;
}
 
void solve () {
	n = strlen ( s + 1 ) ;
	for ( int i = 0 ; i < 26 ; ++ i ) {
		pre[i] = n + 1 ;
	}
	for ( int i = n ; i >= 0 ; -- i ) {
		for ( int j = 0 ; j < 26 ; ++ j ) {
			jump[i][j] = pre[j] ;
		}
		pre[s[i] - 'a'] = i ;
	}
	cur = 0 ;
	newnode () ;
	for ( int i = 0 ; i < m ; ++ i ) {
		scanf ( "%s" , p ) ;
		insert ( p ) ;
	}
	clr ( f , INF ) ;
	for ( int l = n ; l >= 1 ; -- l ) {
		clr ( dp , INF ) ;
		dp[l - 1][0] = 0 ;
		for ( int r = l ; r <= n ; ++ r ) {
			for ( int now = 0 ; now < cur ; ++ now ) if ( dp[r - 1][now] < INF ) {
				for ( int i = 0 ; i < 26 ; ++ i ) if ( node[now][i] ) {
					int nxt = node[now][i] ;
					int x = jump[r - 1][i] ;
					while ( x <= n ) {
						int tmp = r <= x - 1 ? f[r][x - 1] : 0 ;
						dp[x][nxt] = min ( dp[x][nxt] , dp[r - 1][now] + tmp ) ;
						if ( word[nxt] ) f[l][x] = min ( f[l][x] , dp[x][nxt] + 1 ) ;
						x = jump[x][i] ;
					}
				}
			}
		}
		for ( int r = l ; r <= n ; ++ r ) {
			for ( int i = l ; i < r ; ++ i ) {
				f[l][r] = min ( f[l][r] , f[l][i] + f[i + 1][r] ) ;
			}
		}
	}
	printf ( "%d\n" , f[1][n] ) ;
}
 
int main () {
	while ( ~scanf ( "%s%d" , s + 1 , &m ) ) solve () ;
	return 0 ;
}

　　

D. Disclosure

对于一条边$x->y$，若去掉之后$x$不能到达$y$，那么它是必需的。

首先拓扑排序求出拓扑序，然后按照终点拓扑序为第一关键字，起点拓扑序为第二关键字从小到大加边。

对于每个点，维护一个bitset，表示当前从哪些点可以到达自己。

时间复杂度$O(\frac{nm}{32})$。

#include<cstdio>
#include<bitset>
#include<algorithm>
using namespace std;
typedef pair<int,int>P;
const int N=50002,M=50002;
int n,m,i,j,x,y,d[N],g[N],g2[N],v[M],v2[M],nxt[M],nxt2[M],ed,h,t,q[N],ans;bitset<N>f[N];P b[M];
inline void add(int x,int y){d[y]++;v[++ed]=y;nxt[ed]=g[x];g[x]=ed;}
inline void add2(int x,int y){v2[++ed]=y;nxt2[ed]=g2[x];g2[x]=ed;}
int main(){
  scanf("%d%d",&n,&m);
  for(i=1;i<=n;i++)f[i][i]=1;
  while(m--)scanf("%d%d",&x,&y),add(x,y);
  for(ed=0,i=h=1;i<=n;i++)if(!d[i])q[++t]=i;
  while(h<=t)for(i=g[x=q[h++]];i;add2(v[i],x),i=nxt[i])if(!(--d[v[i]]))q[++t]=v[i];
  for(i=1;i<=n;i++)for(j=g2[x=q[i]];j;f[x]|=f[v2[j]],j=nxt2[j])if(!f[x][v2[j]])b[++ans]=P(v2[j],x);
  sort(b+1,b+ans+1);
  for(i=1;i<=ans;i++)printf("%d %d\n",b[i].first,b[i].second);
  return 0;
}

　　

E. Embedded circles

如果询问$i$的范围完全包含询问$j$，那么$i$向$j$连边，这样可以得到一棵树。

因为题目的限制，所以它给出的是这棵树的dfs序列。

维护一个栈，按深度维护当前询问到根的路径，每次读入一个新的询问，如果它的圆心不被栈顶询问包含，那么弹栈，这样就可以找到当前询问的父亲。

每次弹栈的时候计算被弹询问的答案，为了保证复杂度均摊线性，需要找到若干个属于它的且不属于它任何孩子的一个起点，然后从这些起点开始BFS染色。

每次BFS染色出界的时候，在栈中二分查找出深度最大的包含了这个位置的询问，那么这个点就是那个询问的一个可能的起点。

时间复杂度$O(RC+Q\log Q)$。

#include<cstdio>
const int N=2010,M=1000010,E=N*N*4;
int dx[4]={-1,1,0,0},dy[4]={0,0,-1,1};
int n,m,i,j,cq,e[M][3],q[M],t,ans[M];char a[N][N];
int que[N*N],head,tail;bool vis[N][N];
int g[M],v[E],nxt[E],ed;
long long all;
inline void read(int&a){char c;while(!(((c=getchar())>='0')&&(c<='9')));a=c-'0';while(((c=getchar())>='0')&&(c<='9'))(a*=10)+=c-'0';}
inline int sqr(int x){return x*x;}
inline bool check(int x,int y,int p){
  return sqr(x-e[p][0])+sqr(y-e[p][1])<=e[p][2];
}
inline void add(int x,int y){
  int l=1,r=t-1,mid,o=0;
  while(l<=r)if(check(x,y,q[mid=(l+r)>>1]))l=(o=mid)+1;else r=mid-1;
  if(o)v[++ed]=x<<11|y,nxt[ed]=g[q[o]],g[q[o]]=ed;
}
inline void bfs(int o,int x,int y){
  if(vis[x][y])return;
  que[head=tail=1]=x<<11|y;
  vis[x][y]=1;
  while(head<=tail){
    x=que[head++];
    y=x&2047;x>>=11;
    ans[o]+=a[x][y];
    for(int d=0;d<4;d++){
      int nx=x+dx[d],ny=y+dy[d];
      if(nx<1||nx>n||ny<1||ny>m||vis[nx][ny])continue;
      if(check(nx,ny,o)){
        que[++tail]=nx<<11|ny;
        vis[nx][ny]=1;
      }else{
        add(nx,ny);
      }
    }
  }
}
inline void pop(){
  int o=q[t];
  bfs(o,e[o][0],e[o][1]);
  for(int i=g[o];i;i=nxt[i])bfs(o,v[i]>>11,v[i]&2047);
  ans[q[--t]]+=ans[o];
}
int main(){
  read(n),read(m);
  for(i=1;i<=n;i++){
    scanf("%s",a[i]+1);
    for(j=1;j<=m;j++)a[i][j]-='0';
  }
  read(cq);
  for(i=1;i<=cq;q[++t]=i++){
    read(e[i][0]),read(e[i][1]),read(e[i][2]);e[i][2]*=e[i][2];
    while(t&&!check(e[i][0],e[i][1],q[t]))pop();
  }
  while(t)pop();
  for(i=1;i<=cq;i++)all+=ans[i];
  printf("%lld",all);
  return 0;
}

　　

F. False figures

留坑。

G. Grouping

首先将$a$从小到大排序，那么相当于要求把$a$分成$k$段，每段计算所有数到区间中位数的差的绝对值之和，要求最小化这个和。

因为$a$有序，所以计算一段的代价可以用前缀和做到$O(1)$。

设$f[i][j]$表示前$j$个数分成$i$段的最小代价，那么$f[i][j]=\min(f[i-1][k]+cost(k+1,j))$，$(0\leq k<j)$。

转移具有决策单调性，所以可以分治求解。

时间复杂度$O(nk\log n)$。

#include<cstdio>
#include<algorithm>
const int N=5005,inf=2100000000;
typedef unsigned int U;
int n,m,i,o,a[N],s[N];U f[2][N];
inline U cal(int l,int r){
  int m=(l+r)>>1;
  return (m+m-l-r)*a[m]-s[m]+s[l-1]+s[r]-s[m-1];
}
void dp(int l,int r,int dl,int dr){
  int m=(l+r)>>1,dm=dl;
  U tmp=inf;
  for(int i=dl;i<=dr&&i<m;i++){
    U now=f[o^1][i]+cal(i+1,m);
    if(now<tmp)tmp=now,dm=i;
  }
  f[o][m]=tmp;
  if(l<m)dp(l,m-1,dl,dm);
  if(r>m)dp(m+1,r,dm,dr);
}
int main(){
  scanf("%d%d",&n,&m);
  for(i=1;i<=n;i++)scanf("%d",&a[i]);
  std::sort(a+1,a+n+1);
  for(i=1;i<=n;i++)s[i]=s[i-1]+a[i];
  for(i=1;i<=n;i++)f[0][i]=inf;
  while(m--){
    o^=1;
    for(i=0;i<=n;i++)f[o][i]=inf;
    dp(1,n,0,n);
  }
  printf("%u",f[o][n]);
  return 0;
}

　　

H. Hidden triangles

留坑。

I. Interactive

用FFT加速多项式乘法即可，注意需要开long double。

时间复杂度$O(n\log n)$。

#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
const int N=131100;
int n,i,j,k,pos[N],a[N],b[N];long long c[N];
namespace FFT{
struct comp{
  long double r,i;comp(long double _r=0,long double _i=0){r=_r,i=_i;}
  comp operator+(const comp&x){return comp(r+x.r,i+x.i);}
  comp operator-(const comp&x){return comp(r-x.r,i-x.i);}
  comp operator*(const comp&x){return comp(r*x.r-i*x.i,r*x.i+i*x.r);}
  comp conj(){return comp(r,-i);}
}A[N],B[N];
const long double pi=acos(-1.0);
void FFT(comp a[],int n,int t){
  for(int i=1;i<n;i++)if(i<pos[i])swap(a[i],a[pos[i]]);
  for(int d=0;(1<<d)<n;d++){
    int m=1<<d,m2=m<<1;
    long double o=pi*2/m2*t;comp _w(cos(o),sin(o));
    for(int i=0;i<n;i+=m2){
      comp w(1,0);
      for(int j=0;j<m;j++){
        comp&A=a[i+j+m],&B=a[i+j],t=w*A;
        A=B-t;B=B+t;w=w*_w;
      }
    }
  }
  if(t==-1)for(int i=0;i<n;i++)a[i].r/=n;
}
void mul(int*a,int*b,long long*c){
  int i,j;
  for(i=0;i<k;i++)A[i]=comp(a[i],b[i]);
  FFT(A,k,1);
  for(i=0;i<k;i++){
    j=(k-i)&(k-1);
    B[i]=(A[i]*A[i]-(A[j]*A[j]).conj())*comp(0,-0.25);
  }
  FFT(B,k,-1);
  for(i=0;i<k;i++)c[i]=(long long)(B[i].r+0.5);
}
}
int main(){
  scanf("%d",&n);
  for(k=1;k<n;k<<=1);k<<=1;
  j=__builtin_ctz(k)-1;
  for(i=0;i<k;i++)pos[i]=pos[i>>1]>>1|((i&1)<<j);
  for(i=0;i<n;i++)scanf("%d",&a[i]);
  for(i=0;i<n;i++)scanf("%d",&b[i]);
  FFT::mul(a,b,c);
  for(i=0;i<n+n-1;i++)printf("%lld%c",c[i],i<n+n-2?' ':'\n');
  return 0;
}

　　

J. Joinery

枚举长方体的$8$个端点，然后枚举$6$个面，在每个面上三分套三分查找表面距离最远的点即可。

#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
double ans,r;
const double eps=1e-8;
double LL,WW,HH;
struct P{
  double x,y,z;
  P(){}
  P(double _x,double _y,double _z){x=_x,y=_y,z=_z;}
}a[8];
void turn(int i,int j,double x,double y,double z,double x0,double y0,double L,double W,double H){
  if(z==0){
    double R=x*x+y*y;
    if(R<r)r=R;
  }else{
    if(i>=0&&i<2)turn(i+1,j,x0+L+z,y,x0+L-x,x0+L,y0,H,W,L);
    if(j>=0&&j<2)turn(i,j+1,x,y0+W+z,y0+W-y,x0,y0+W,L,H,W);
    if(i<=0&&i>-2)turn(i-1,j,x0-z,y,x-x0,x0-H,y0,H,W,L);
    if(j<=0&&j>-2)turn(i,j-1,x,y0-z,y-y0,x0,y0-H,L,H,W);
  }
}
double cal(double x1,double y1,double z1,double x2,double y2,double z2){
  double L=LL,W=WW,H=HH;
  if(fabs(z1)>eps&&fabs(z1-H)>eps)if(fabs(y1)<eps||fabs(y1-W)<eps)
    swap(y1,z1),swap(y2,z2),swap(W,H);
  else
    swap(x1,z1),swap(x2,z2),swap(L,H);
  if(fabs(z1-H)<eps)z1=0,z2=H-z2;
  r=1e20;
  turn(0,0,x2-x1,y2-y1,z2,-x1,-y1,L,W,H);
  return r;
}
double solvexy(double x,double y,double z,double A,double B,double C){
  double l=0,r=C,m1,m2,s1,s2;
  double ret=0;
  while(l+eps<r){
    double len=(r-l)/3.0;
    m1=l+len;
    m2=r-len;
    s1=cal(x,y,z,A,B,m1);
    s2=cal(x,y,z,A,B,m2);
    ret=max(ret,max(s1,s2));
    if(s1>s2)r=m2;else l=m1;
  }
  return ret;
}
double solvexz(double x,double y,double z,double A,double B,double C){
  double l=0,r=B,m1,m2,s1,s2;
  double ret=0;
  while(l+eps<r){
    double len=(r-l)/3.0;
    m1=l+len;
    m2=r-len;
    s1=cal(x,y,z,A,m1,C);
    s2=cal(x,y,z,A,m2,C);
    ret=max(ret,max(s1,s2));
    if(s1>s2)r=m2;else l=m1;
  }
  return ret;
}
double solvex(double x,double y,double z,double A,double B,double C){
  double l=0,r=B,m1,m2,s1,s2;
  double ret=0;
  while(l+eps<r){
    double len=(r-l)/3.0;
    m1=l+len;
    m2=r-len;
    s1=solvexy(x,y,z,A,m1,C);
    s2=solvexy(x,y,z,A,m2,C);
    ret=max(ret,max(s1,s2));
    if(s1>s2)r=m2;else l=m1;
  }
  return ret;
}
double solvey(double x,double y,double z,double A,double B,double C){
  double l=0,r=A,m1,m2,s1,s2;
  double ret=0;
  while(l+eps<r){
    double len=(r-l)/3.0;
    m1=l+len;
    m2=r-len;
    s1=solvexy(x,y,z,m1,B,C);
    s2=solvexy(x,y,z,m2,B,C);
    ret=max(ret,max(s1,s2));
    if(s1>s2)r=m2;else l=m1;
  }
  return ret;
}
double solvez(double x,double y,double z,double A,double B,double C){
  double l=0,r=A,m1,m2,s1,s2;
  double ret=0;
  while(l+eps<r){
    double len=(r-l)/3.0;
    m1=l+len;
    m2=r-len;
    s1=solvexz(x,y,z,m1,B,C);
    s2=solvexz(x,y,z,m2,B,C);
    ret=max(ret,max(s1,s2));
    if(s1>s2)r=m2;else l=m1;
  }
  return ret;
}
int main(){
  int i,j;
  double L,H,W;
  scanf("%lf%lf%lf",&L,&W,&H);
  a[0]=P(0,0,0);
  a[1]=P(0,0,H);
  a[2]=P(0,W,0);
  a[3]=P(0,W,H);
  a[4]=P(L,0,0);
  a[5]=P(L,0,H);
  a[6]=P(L,W,0);
  a[7]=P(L,W,H);
  LL=L;
  WW=W;
  HH=H;
  for(i=0;i<8;i++)for(j=0;j<8;j++)
    ans=max(ans,cal(a[i].x,a[i].y,a[i].z,a[j].x,a[j].y,a[j].z));
  for(i=0;i<8;i++){
    ans=max(ans,solvex(a[i].x,a[i].y,a[i].z,0,W,H));
    ans=max(ans,solvex(a[i].x,a[i].y,a[i].z,L,W,H));
    ans=max(ans,solvey(a[i].x,a[i].y,a[i].z,L,0,H));
    ans=max(ans,solvey(a[i].x,a[i].y,a[i].z,L,W,H));
    ans=max(ans,solvez(a[i].x,a[i].y,a[i].z,L,W,0));
    ans=max(ans,solvez(a[i].x,a[i].y,a[i].z,L,W,H));
  }
  double ret=sqrt(ans);
  printf("%.13f",ret);
  return 0;
}