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

A. Associated Vertices

首先求出SCC然后缩点，第一次求出每个点能到的点集，第二次收集这些点集即可，用bitset加速，时间复杂度$O(\frac{nm}{64})$。

#include<cstdio>
#include<bitset>
using namespace std;
const int N=10010;
int n,m,x,y,i,j,g[N],G[N],v[N*3],V[N*3],nxt[N*3],NXT[N*3],ed;
int vis[N],q[N],h,t;
int f[N],size[N],d[N],ans;
bitset<N>dp[N];
inline void add(int x,int y){
  v[++ed]=y;nxt[ed]=g[x];g[x]=ed;
  V[++ed]=x;NXT[ed]=G[y];G[y]=ed;
}
inline void ADD(int x,int y){
  if(x==y)return;
  V[++ed]=y;NXT[ed]=G[x];G[x]=ed;
  d[y]++;
}
void dfs1(int x){
  vis[x]=1;
  for(int i=g[x];i;i=nxt[i])if(!vis[v[i]])dfs1(v[i]);
  q[++t]=x;
}
void dfs2(int x,int y){
  vis[x]=0;
  f[x]=y;
  size[y]++;
  for(int i=G[x];i;i=NXT[i])if(vis[V[i]])dfs2(V[i],y);
}
int main(){
  scanf("%d%d",&n,&m);
  while(m--){
    scanf("%d%d",&x,&y);
    add(x,y);
  }
  for(i=1;i<=n;i++)if(!vis[i])dfs1(i);
  for(i=n;i;i--)if(vis[q[i]])dfs2(q[i],q[i]);
  for(i=1;i<=n;i++)G[i]=0;
  for(i=1;i<=n;i++)for(j=g[i];j;j=nxt[j])ADD(f[i],f[v[j]]);
  for(h=i=1,t=0;i<=n;i++)if(f[i]==i&&!d[i])q[++t]=i;
  while(h<=t){
    x=q[h++];
    for(i=G[x];i;i=NXT[i])if(!(--d[V[i]]))q[++t]=V[i];
  }
  for(i=1;i<=n;i++)dp[f[i]][i]=1;
  for(i=t;i;i--){
    x=q[i];
    for(j=G[x];j;j=NXT[j])dp[x]|=dp[V[j]];
  }
  for(i=1;i<=t;i++){
    x=q[i];
    ans+=size[x]*dp[x].count();
    for(j=G[x];j;j=NXT[j])dp[V[j]]|=dp[x];
  }
  printf("%d",ans);
}

B. Bishops

容斥。

#include<bits/stdc++.h>
const int N=1000010;
typedef long long LL;
const int Maxn=1000020;
LL a[Maxn*2];
int ok1[Maxn*2];
int ok2[Maxn*2];
int n,m;
int get1(int x){
if(x>n+1){
return n-(x-n-1);
}
return x-1;
}
int get2(int x){
if(x<0)return n-(-x);
return n-x;
}
LL  ask(int l,int r){LL ret=a[r];if(l>=2)ret-=a[l-2];return ret;}
int main(){
while(scanf("%d%d",&n,&m)!=EOF){
LL ans=0;
memset(ok1,0,sizeof ok1);
memset(ok2,0,sizeof ok2);
memset(a,0,sizeof a);
for(int i=0;i<m;i++){
int x,y;scanf("%d%d",&x,&y);
if(!ok1[x+y]){
ans+=get1(x+y);
ok1[x+y]=1;
a[x+y]=1;
}
if(!ok2[x-y+n]){
ans+=get2(x-y);
ok2[x-y+n]=1;
}
//printf("%lld\n",ans);
}
for(int i=2;i<=n+n;i++)a[i]+=a[i-2];
for(int i=n;i>=1;i--){
if(!ok2[i-1+n])continue;
ans-=ask(i+1,2*n-(i-1));
}
for(int i=2;i<=n;i++){
if(!ok2[1-i+n])continue;
ans-=ask(i+1,2*n-(i-1));
}
printf("%lld\n",1LL*n*n-ans);
}
}

C. Cool Numbers

暴力枚举答案即可。

#include<cstdio>
const int N=1000010;
int i,j,k,cnt,q[N],v[N],is[N],ans;
int rev(int x){
  int t=0;
  while(x)t=t*10+x%10,x/=10;
  return t;
}
int main(){
  for(i=2;i<=1000000;i++)if(!v[i]){
    is[i]=1;
    for(j=i+i;j<=1000000;j+=i)v[j]=1;
  }
  for(i=10;i<=1000000;i++)if(is[i]){
    j=rev(i);
    if(i==j)continue;
    if(is[j]){
      q[++cnt]=i;
      //if(cnt<=30)printf("%d %d\n",i,j);
    }
  }
  scanf("%d",&k);
  if(k>cnt)ans=-1;else ans=q[k];
  printf("%d",ans);
}

D. Diagram

判断是否存在$K$个数满足坐标模$\frac{N}{K}$的值相同即可。

#include <bits/stdc++.h>
using namespace std ;const int MAXN = 100005 ;map < int , int > mp ;int a[MAXN] , n , k , l ;void solve () {
mp.clear () ;
for ( int i = 0 ; i < n ; ++ i ) {
scanf ( "%d" , &a[i] ) ;
}
scanf ( "%d" , &l ) ;
l /= k ;
for ( int i = 0 ; i < n ; ++ i ) {
mp[a[i] % l] ++ ;
if ( mp[a[i] % l] == k ) {
printf ( "1\n" ) ;
return ;
}
}
printf ( "0\n" ) ;
}int main () {
while ( ~scanf ( "%d%d" , &n , &k ) ) solve () ;
return 0 ;
}

E. Effective Hiring

考虑将所有人按能力从小到大排序，能力相同的按$2,3,1$的优先级排序，那么问题等价于在这个序列中选择$K$对左右括号，使得选出来的是个合法括号序列，dp即可，时间复杂度$O(NK\sqrt{NK})$。

#include<bits/stdc++.h>
using namespace std;
const int N=1000010;
typedef long long LL;
const int Maxn=100020;
const LL Inf=1LL<<60;
LL dp[2][334][334];
int n,k;
int a[Maxn],c[Maxn],w[Maxn],id[Maxn];//2->3,3->2
bool cmp(int x,int y){
if(c[x]!=c[y])return c[x]<c[y];
return a[x]>a[y];
}
void init(int cs){
for(int i=0;i<=k;i++)for(int j=0;j<=k;j++)dp[cs][i][j]=Inf;
}
void up(LL &x,LL y){
if(x>y)x=y;
}
int main(){
while(scanf("%d%d",&n,&k)!=EOF){
for(int i=1;i<=n;i++){
id[i]=i;
scanf("%d%d%d",a+i,c+i,w+i);
if(a[i]==3)a[i]=2;
else if(a[i]==2)a[i]=3;
}
sort(id+1,id+1+n,cmp);
int cs=0;
init(cs);dp[cs][0][0]=0;
for(int i=1;i<=n;i++,cs^=1){
int idx=id[i];
//printf("idx=%d\n",idx);
init(cs^1);
for(int has=0;has<=k;has++){
for(int j=0;j<=k;j++){
if(dp[cs][has][j]==Inf)continue;
//if(i==2&&has==0&&j==1)printf("val=%lld\n",dp[cs][has][j]);
for(int it=1;it<=3;it+=2){
if(a[idx]!=2&&a[idx]!=it)continue;
int nhas=has+(it==1?1:0);
int nj=j+(it==3?1:-1);
if(nhas>k||nj>k||nj<0)continue;//if(i==2&&has==0&&j==1)printf("nhas=%d nj=%d\n",nhas,nj);
up(dp[cs^1][nhas][nj],dp[cs][has][j]+w[idx]);
}
up(dp[cs^1][has][j],dp[cs][has][j]);
}
}
}
printf("%lld\n",dp[cs][k][0]);
}
}

F. First And Last

高精度打表。

import java.io.*;
import java.math.*;
import java.util.*;public class Main {
static int [][]res=new int[11][11];
public static void main(String[] args) {
for(int i=0;i<10;i++)for(int j=0;j<10;j++)res[i][j]=-1;
BigInteger o=BigInteger.ONE;
for(int i=0;i<500;i++){
int lst=o.mod(BigInteger.valueOf(10)).intValue();
int fst=lst;
BigInteger x=o;
while(x.compareTo(BigInteger.ZERO)>0){
fst=(x.mod(BigInteger.valueOf(10))).intValue();
x=x.divide(BigInteger.TEN);
}
if(res[fst][lst]<0)res[fst][lst]=i;
o=o.multiply(BigInteger.valueOf(2));
}
Scanner cin=new Scanner(System.in);
while(cin.hasNext()){
int a=cin.nextInt();
int b=cin.nextInt();
System.out.println(res[a][b]);
}
cin.close();
}
}

G. Game of Solitaire

$ans=\gcd(n,k)$。

#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
typedef pair<ll,P>PI;
int n,K,i,j,a[30010][8];ll ans,lim=1e18;
priority_queue<PI,vector<PI>,greater<PI> >q;
inline void ext(int o,int x){
  ll t=0;
  for(int i=7;~i;i--){
    if(t>lim/x)return;
    t=t*x+a[o][i];
    if(t>lim)return;
  }
  q.push(PI(t,P(o,x)));
}
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int main(){
  scanf("%d%d",&n,&K);
  printf("%d",gcd(n,K));
}

H. Hero’s Quest

留坑。

I. Important Or Not?

首先将串翻转，并用Hash值对操作串进行去重，求出后缀数组，用线段树套set维护区间内重要的子串集合。

对于每个询问，在线段树上找到$O(\log n)$个set，在里面首先lower_bound出最短的满足条件的串，然后往后选取$k$个，最后nth_element即可。

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

#include <bits/stdc++.h>
using namespace std ;typedef pair < int , int > pii ;#define clr( a , x ) memset ( a , x , sizeof a )
#define root 1 , 1 , n
#define ls o << 1
#define rs o << 1 | 1
#define lson ls , l , m
#define rson rs , m + 1 , rconst int MAXN = 200005 ;
const int seed = 233 ;
const int P1 = 1e9 + 7 , P2 = 998244353 ;
const int LOGF = 20 ;char s[MAXN] ;
int sa[MAXN] , rnk[MAXN] , height[MAXN] ;
int t1[MAXN] , t2[MAXN] , xy[MAXN] , c[MAXN] ;
int dp[MAXN][LOGF] , logn[MAXN] ;
set < pii > T[MAXN << 2] ;
set < pii > :: iterator it ;
map < pii , int > mp1 ;
map < pii , int > mp2 ;
map < pii , int > mp3 ;
int a[MAXN] , cnt ;
int p1[MAXN] , p2[MAXN] ;
int h1[MAXN] , h2[MAXN] ;
int n , q ;int cmp ( int* r , int a , int b , int d ) {
return r[a] == r[b] && r[a + d] == r[b + d] ;
}void get_height ( int n , int k = 0 ) {
for ( int i = 0 ; i <= n ; ++ i ) rnk[sa[i]] = i ;
for ( int i = 0 ; i < n ; ++ i ) {
if ( k ) -- k ;
int j = sa[rnk[i] - 1] ;
while ( s[i + k] == s[j + k] ) ++ k ;
height[rnk[i]] = k ;
}
}void da ( int n , int m ) {
int *x = t1 , *y = t2 ;
for ( int i = 0 ; i < m ; ++ i ) c[i] = 0 ;
for ( int i = 0 ; i < n ; ++ i ) c[x[i] = s[i]] ++ ;
for ( int i = 1 ; i < m ; ++ i ) c[i] += c[i - 1] ;
for ( int i = n - 1 ; i >= 0 ; -- i ) sa[-- c[x[i]]] = i ;
for ( int d = 1 , p = 0 ; p < n ; d <<= 1 , m = p ) {
p = 0 ;
for ( int i = n - d ; i < n ; ++ i ) y[p ++] = i ;
for ( int i = 0 ; i < n ; ++ i ) if ( sa[i] >= d ) y[p ++] = sa[i] - d ;
for ( int i = 0 ; i < m ; ++ i ) c[i] = 0 ;
for ( int i = 0 ; i < n ; ++ i ) c[xy[i] = x[y[i]]] ++ ;
for ( int i = 1 ; i < m ; ++ i ) c[i] += c[i - 1] ;
for ( int i = n - 1 ; i >= 0 ; -- i ) sa[-- c[xy[i]]] = y[i] ;
swap ( x , y ) ;
p = 0 ;
x[sa[0]] = p ++ ;
for ( int i = 1 ; i < n ; ++ i ) x[sa[i]] = cmp ( y , sa[i - 1] , sa[i] , d ) ? p - 1 : p ++ ;
}
get_height ( n - 1 ) ;
}int rmq ( int L , int R ) {
int k = logn[R - L + 1] ;
return min ( dp[L][k] , dp[R - ( 1 << k ) + 1][k] ) ;
}void init_rmq ( int n ) {
for ( int i = 1 ; i <= n ; ++ i ) dp[i][0] = height[i] ;
logn[1] = 0 ;
for ( int i = 2 ; i <= n ; ++ i ) logn[i] = logn[i - 1] + ( i == ( i & -i ) ) ;
for ( int j = 1 ; ( 1 << j ) < n ; ++ j ) {
for ( int i = 1 ; i + ( 1 << j ) - 1 <= n ; ++ i ) {
dp[i][j] = min ( dp[i][j - 1] , dp[i + ( 1 << ( j - 1 ) )][j - 1] ) ;
}
}
}int get_L ( int x , int l , int r ) {
int R = r ;
while ( l < r ) {
int m = l + r >> 1 ;
if ( rmq ( m + 1 , R ) >= x ) r = m ;
else l = m + 1 ;
}
return l ;
}int get_R ( int x , int l , int r ) {
int L = l ;
while ( l < r ) {
int m = l + r + 1 >> 1 ;
if ( rmq ( L + 1 , m ) >= x ) l = m ;
else r = m - 1 ;
}
return r ;
}void build ( int o , int l , int r ) {
T[o].clear () ;
if ( l == r ) return ;
int m = l + r >> 1 ;
build ( lson ) ;
build ( rson ) ;
}void update ( int x , int p , int v , int o , int l , int r ) {
pii tmp ( x , p ) ;
if ( v ) T[o].insert ( pii ( x , p ) ) ;
else if ( T[o].find ( tmp ) != T[o].end () ) T[o].erase ( tmp ) ;
if ( l == r ) return ;
int m = l + r >> 1 ;
if ( p <= m ) update ( x , p , v , lson ) ;
else update ( x , p , v , rson ) ;
}void query ( int L , int R , int h , int k , int o , int l , int r ) {
if ( L <= l && r <= R ) {
it = T[o].lower_bound ( pii ( h , -1 ) ) ;
for ( int i = 0 ; i < k && it != T[o].end () ; ++ it , ++ i ) {
a[++ cnt] = it->first ;
}
return ;
}
int m = l + r >> 1 ;
if ( L <= m ) query ( L , R , h , k , lson ) ;
if ( m <  R ) query ( L , R , h , k , rson ) ;
}pii get_Hash ( int L , int R ) {
if ( L == 0 ) return pii ( h1[R] , h2[R] ) ;
int v = R - L + 1 ;
int v1 = ( h1[R] - 1LL * h1[L - 1] * p1[v] % P1 + P1 ) % P1 ;
int v2 = ( h2[R] - 1LL * h2[L - 1] * p2[v] % P2 + P2 ) % P2 ;
return pii ( v1 , v2 ) ;
}void solve () {
mp1.clear () ;
mp2.clear () ;
mp3.clear () ;
n = strlen ( s ) ;
reverse ( s , s + n ) ;
h1[0] = s[0] ;
h2[0] = s[0] ;
for ( int i = 1 ; i < n ; ++ i ) {
h1[i] = ( 1LL * h1[i - 1] * seed + s[i] ) % P1 ;
h2[i] = ( 1LL * h2[i - 1] * seed + s[i] ) % P2 ;
}
da ( n + 1 , 128 ) ;
init_rmq ( n ) ;
build ( root ) ;
//for ( int i = 1 ; i <= n ; ++ i ) {
//printf ( "%d " , sa[i] ) ;
//}
for ( int i = 0 ; i < q ; ++ i ) {
int op , x , p , k ;
scanf ( "%d%d%d" , &op , &x , &p ) ;
pii tmp ( x , p ) ;
p = n - p - 1 ;
pii val = get_Hash ( p , p + x - 1 ) ;
p = rnk[p] ;
//printf ( "%d %d %d\n" , op , x , p ) ;
if ( op == 1 ) {
//if ( mp3[tmp] ) continue ;
//mp3[tmp] = 1 ;
if(mp1[val])continue;
mp1[val] ++ ;
if ( mp1[val] == 1 ) {
        //puts("A");
mp2[val] = p ;
update ( x , p , 1 , root ) ;
}
} else if ( op == 2 ) {
//if ( mp3[tmp] == 0 ) continue ;
//mp3[tmp] = 0 ;
if ( mp1[val] == 0 ) continue ;
mp1[val] -- ;
if ( mp1[val] == 0 ) {
        //puts("B");
update ( x , mp2[val] , 0 , root ) ;
}
} else {
scanf ( "%d" , &k ) ;
int L = get_L ( x , 1 , p ) ;
int R = get_R ( x , p , n ) ;
cnt = 0 ;
query ( L , R , x , k , root ) ;
nth_element ( a + 1 , a + k , a + cnt + 1 ) ;
if ( cnt < k ) printf ( "-1\n" ) ;
else printf ( "%d\n" , a[k] ) ;
}
}
}int main () {
p1[0] = p2[0] = 1 ;
for ( int i = 1 ; i < MAXN ; ++ i ) {
p1[i] = 1LL * p1[i - 1] * seed % P1 ;
p2[i] = 1LL * p2[i - 1] * seed % P2 ;
}
while ( ~scanf ( "%s%d" , s , &q ) ) solve () ;
return 0 ;
}

J. Joining Powers

二分答案，计数则考虑容斥，因为只关心选取集合的$lcm$以及奇偶性，而且$lcm>64$时与$64$无异，所以设$dp[i][j]$表示考虑了前$i$个集合，准备容斥的部分的$lcm$为$j$的容斥系数，求出系数之后开根号统计即可。

#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll inf=1e18;
const int MAGIC=7;
int n,m,cnt,i,j,a[55],b[55];
int lc[90][90];
ll f[20010][60];
ll l,r,mid,ans;
ll q[3000000];
int cur;
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int lcm(int a,int b){return a*b/gcd(a,b);}
inline ll cal2(ll a,int b){
  ll t=1;
  while(b--){
    if(t>inf/a)return inf;
    t*=a;
  }
  return t;
}
inline ll cal(ll a,int b){
  ll t=1;
  bool flag=0;
  while(b){
    if(b&1){
      if(flag)return inf;
      if(t>inf/a)return inf;
      t*=a;
    }
    b>>=1;
    if(a>inf/a)flag=1;
    if(!flag)a*=a;
  }
  return t;
}
inline ull ask(int k,ll lim){
  ll l=1,r=lim,mid,t=0;
  while(l<=r){
    mid=(l+r)>>1;
    if(cal(mid,k)<=lim)l=(t=mid)+1;else r=mid-1;
  }
  return t;
}
inline ull askfast(int k,ll lim){
  double t=pow(lim,1.0/k);
  ll x=(ll)(t);
  x=max(0LL,x);
  while(cal(x+1,k)<=lim)x++;
  while(x>0&&cal(x,k)>lim)x--;
  return 1ULL*x;
}
inline bool ispower(ll x,int k){
  ll l=1,r=x,mid;
  while(l<=r){
    mid=(l+r)>>1;
    ll t=cal(mid,k);
    if(t==x)return 1;
    if(t<x)l=mid+1;else r=mid-1;
  }
  return 0;
}
ull dp[55][70];
ull check(ll mid){
  int i,j,k;
  for(i=0;i<=m;i++)for(j=1;j<64;j++)dp[i][j]=0;
  dp[0][1]-=1;
  for(i=0;i<m;i++)for(j=1;j<64;j++)if(dp[i][j]){
    dp[i+1][j]+=dp[i][j];
    dp[i+1][min(63,lc[j][a[i+1]])]-=dp[i][j];
  }
  ull ret=0;
  for(i=2;i<64;i++)if(dp[m][i]){
    //printf("%d %llu\n",i,dp[m][i]);
    ret+=dp[m][i]*askfast(i,mid);
  }
  /*cur=0;
  for(i=0;i<m;i++)if(a[i]>MAGIC){
    for(j=1;;j++){
      ll t=f[j][a[i]];
      if(t>mid)break;
      q[++cur]=t;
    }
  }
  sort(q+1,q+cur+1);
  ull ret=0;
  for(i=1;i<=cur;i++)if(i==1||q[i]!=q[i-1]){
    for(k=0;k<cnt;k++)if(ispower(q[i],b[k]))break;
    if(k==cnt)ret++;
  }
  int S;
  for(S=1;S<1<<cnt;S++){
    int o=1;
    for(i=0;i<cnt;i++)if(S>>i&1)o=lcm(o,b[i]);
    if(__builtin_popcount(S)&1)ret+=ask(o,mid);else ret-=ask(o,mid);
  }*/
  return ret;
}
ll solve(){
  scanf("%d%d",&n,&m);
  cnt=0;
  for(i=1;i<=m;i++){
    scanf("%d",&a[i]);
    //if(a[i]<=MAGIC)b[cnt++]=a[i];
  }
  for(i=1;i<=m;i++)if(a[i]==1)return n;
  l=1,r=100000000000000009LL;
  while(l<r){
    mid=(l+r)>>1;
    if(check(mid)>=n)r=mid;else l=mid+1;
  }
  return l;
}
int main(){
  int T;
  for(i=1;i<90;i++)for(j=1;j<90;j++)lc[i][j]=lcm(i,j);
  //for(i=1;i<=20000;i++)for(j=1;j<=50;j++)f[i][j]=cal(i,j);
  for(scanf("%d",&T);T--;printf("%lld\n",solve()));
  return 0;
}

K. Keyboard Map

$f[i][j]$表示前$j$个数划分成$i$段的最小花费，转移显然具有决策单调性，分治求解即可。时间复杂度$O(nm\log n)$。

#include<bits/stdc++.h>
using namespace std;
const int N=1000010;
typedef long long LL;
const int Maxn=1000020;
const LL Inf=1LL<<60;
LL sum1[5050],sum2[5050];
LL a[5050];
int n,k;
LL f[3030][5050];
int O;
LL cal(int l,int r){
return sum1[r]-sum1[l]-(sum2[r]-sum2[l])*l;
}
void solve(int l,int r,int dl,int dr){
  int m=(l+r)>>1,dm=dl;
  LL&t=f[O][m];
  t=Inf;
  for(int i=dl;i<=dr&&i<m;i++){
    LL now=f[O-1][i]+cal(i,m);
    if(now<t)t=now,dm=i;
  }
  if(l<m)solve(l,m-1,dl,dm);
  if(r>m)solve(m+1,r,dm,dr);
}
int main(){
while(scanf("%d%d",&n,&k)!=EOF){
for(int i=1;i<=n;i++){
scanf("%lld",a+i);
sum1[i]=sum1[i-1]+i*a[i];
sum2[i]=sum2[i-1]+a[i];
}
//printf("cal33=%lld\n",cal(2,3));
for(int j=0;j<=n;j++)
f[1][j]=sum1[j];
for(O=2;O<=k;O++){
  solve(O,n,O-1,n);
                }
/*else{
f[i][j]=Inf;
for(int bef=0;bef<j;bef++){
f[i][j]=min(f[i][j],f[i-1][bef]+cal(bef,j));
}
}
}
}*/
//printf("f23=%lld\n",f[2][3]);
printf("%lld\n",f[k][n]);
}
}

L. Light Sources

显然当选出来的多边形是个凸包时，周长最小。

枚举起点，然后极角排序，设$dp[i][j]$表示选取的最后一个点是$i$，选中的颜色集合为$j$的最小周长，然后枚举下一个凸包上的点转移即可。

时间复杂度$O(m^32^k)$。

#include<bits/stdc++.h>
using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 305 ;struct P {
LL x , y ;
P () {}
P ( LL x , LL y ) : x ( x ) , y ( y ) {}
LL operator * ( const P& p ) const {
return x * p.y - y * p.x ;
}
P operator + ( const P& p ) const {
return P ( x + p.x , y + p.y ) ;
}
P operator - ( const P& p ) const {
return P ( x - p.x , y - p.y ) ;
}
bool operator < ( const P& p ) const {
return x != p.x ? x < p.x : y < p.y ;
}
double len () {
return sqrt ( x * x + y * y ) ;
}
double angle () {
return atan2 ( y , x ) ;
}
} ;struct Node {
double r ;
int idx ;
bool operator < ( const Node& a ) const {
return r < a.r ;
}
} ;P p[MAXN] , q[MAXN] ;
double len[MAXN][MAXN] ;
double dp[MAXN][1 << 7] ;
int val[MAXN][MAXN] ;
Node a[MAXN] ;
int c[MAXN] ;
double ans ;
int n , m , K ;int dcmp ( LL x ) {
if ( x ) return x > 0 ? 1 : -1 ;
return 0 ;
}bool PointInTri ( P& i , P& j , P& k , P& l ) {
int a = dcmp ( ( i - l ) * ( j - l ) ) ;
int b = dcmp ( ( j - l ) * ( k - l ) ) ;
int c = dcmp ( ( k - l ) * ( i - l ) ) ;
return a * b > 0 && b * c > 0 && c * a > 0 ;
}void calc ( int m ) {
int tot = 1 << K ;
for ( int i = 0 ; i <= m ; ++ i ) {
for ( int j = 0 ; j < tot ; ++ j ) {
dp[i][j] = 1e60 ;
}
for ( int j = 0 ; j <= m ; ++ j ) {
len[i][j] = ( p[a[i].idx] - p[a[j].idx] ).len () ;
}
}
for ( int i = 1 ; i <= m ; ++ i ) {
for ( int j = i + 1 ; j <= m ; ++ j ) {
val[i][j] = 0 ;
for ( int l = 0 ; l < n ; ++ l ) {
if ( PointInTri ( p[a[0].idx] , p[a[i].idx] , p[a[j].idx] , q[l] ) ) {
val[i][j] |= 1 << c[l] ;
}
}
}
}
for ( int i = 1 ; i <= m ; ++ i ) {
dp[i][0] = len[0][i] * 2 ;
for ( int s = 0 ; s < tot ; ++ s ) {
for ( int k = 1 ; k < i ; ++ k ) if ( dp[k][s] < 1e50 ) {
int nxt = s | val[k][i] ;
dp[i][nxt] = min ( dp[i][nxt] , dp[k][s] + len[0][i] + len[k][i] - len[0][k] ) ;
}
}
ans = min ( ans , dp[i][tot - 1] ) ;
}
}void solve () {
for ( int i = 0 ; i < n ; ++ i ) {
scanf ( "%lld%lld" , &q[i].x , &q[i].y ) ;
}
for ( int i = 0 ; i < n ; ++ i ) {
scanf ( "%d" , &c[i] ) ;
c[i] -- ;
}
for ( int i = 1 ; i <= m ; ++ i ) {
scanf ( "%lld%lld" , &p[i].x , &p[i].y ) ;
}
ans = 1e60 ;
sort ( p + 1 , p + m + 1 ) ;
for ( int i = 1 ; i <= m ; ++ i ) {
int cnt = 0 ;
for ( int j = i + 1 ; j <= m ; ++ j ) {
++ cnt ;
a[cnt].idx = j ;
a[cnt].r = ( p[j] - p[i] ).angle () ;
}
a[0].idx = i ;
sort ( a + 1 , a + cnt + 1 ) ;
calc ( cnt ) ;
}
if ( ans < 1e50 ) printf ( "%.12f\n" , ans ) ;
else printf ( "-1\n" ) ;
}int main () {
while ( ~scanf ( "%d%d%d" , &n , &m , &K ) ) solve () ;
return 0 ;
}

M. Merging

不断用堆取出最小的$k$项即可。

#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
typedef pair<ll,P>PI;
int n,K,i,j,a[30010][8];ll ans,lim=1e18;
priority_queue<PI,vector<PI>,greater<PI> >q;
inline void ext(int o,int x){
  ll t=0;
  for(int i=7;~i;i--){
    if(t>lim/x)return;
    t=t*x+a[o][i];
    if(t>lim)return;
  }
  q.push(PI(t,P(o,x)));
}
int main(){
  scanf("%d",&n);
  for(i=1;i<=n;i++)for(j=7;~j;j--)scanf("%d",&a[i][j]);
  scanf("%d",&K);
  for(i=1;i<=n;i++)ext(i,1);
  while(K--){
    PI t=q.top();q.pop();
    ans=t.first;
    ext(t.second.first,t.second.second+1);
  }
  printf("%lld",ans);
}

总结：

• J题对一开始的算法时间复杂度分析错误，致使4次TLE。
• F题偷懒用__int128结果WA，下次要注意。