# XVI Open Cup named after E.V. Pankratiev. GP of SPB

A. Bubbles

#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
const double eps=1e-9;
int sgn(double x){
if(x<-eps)return -1;
if(x>eps)return 1;
return 0;
}

struct P{
double x,y;
P(){x=y=0;}
P(double _x,double _y){x=_x,y=_y;}
P operator+(P v){return P(x+v.x,y+v.y);}
P operator-(P v){return P(x-v.x,y-v.y);}
P operator*(double v){return P(x*v,y*v);}
P operator/(double v){return P(x/v,y/v);}
P rot90(){return P(-y,x);}
}a[2000];

double q[1111111];

double cross(P a,P b){return a.x*b.y-a.y*b.x;}

int line_intersection(P a,P b,P p,P q,P&o){
if(!sgn(a.x-b.x)&&!sgn(a.y-b.y))return 0;
if(!sgn(p.x-q.x)&&!sgn(p.y-q.y))return 0;
double U=cross(p-a,q-p),
D=cross(b-a,q-p);
if(sgn(D)==0)return 0;
o=a+(b-a)*(U/D);
return 1;
}

int main () {
freopen ( "bubbles.in" , "r" , stdin ) ;
freopen ( "bubbles.out" , "w" , stdout ) ;
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%lf%lf",&a[i].x,&a[i].y);
}
P A(-100,0),B(100,0);
int cnt=0;
for(int i=1;i<=n;i++)for(int j=1;j<i;j++){
P t=(a[i]+a[j])/2.0;
P v=a[i]-a[j];
v=v.rot90();
P tmp;
if(line_intersection(t,t+v,A,B,tmp)){
q[++cnt]=tmp.x;
}
}
sort(q+1,q+cnt+1);
int ans=1;
for(int i=1;i<=cnt;i++)if(i==1||sgn(q[i]-q[i-1]))ans++;
printf("%d",ans);
return 0;
}


B. Drop7

C. Eulerian Graphs

D. At Least Half

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int>pi;
const int Maxn=1000020;
int a[Maxn];
vector<int>V[Maxn/10];
vector<int>pri;
int n;
bool isp[Maxn];
void getp(){
for(int i=2;i<Maxn;i++){
if(!isp[i]){
pri.push_back(i);
}
for(int j=0;j<pri.size();j++){
if(i*pri[j]>=Maxn)break;
isp[i*pri[j]]=1;
if(i%pri[j]==0)break;
}
}
}
int ans,ansr;
int g[Maxn],gmx[Maxn];
void check(vector<int>&V){
//for(int i=0;i<V.size();i++)printf("%d ",V[i]);puts("");
for(int i=0;i<V.size();i++)g[i]=V[i]-2*(i+1);
for(int i=0;i<V.size();i++)gmx[i]=V[i]-1-2*(i);
for(int i=1;i<V.size();i++)gmx[i]=max(gmx[i],gmx[i-1]);
for(int i=0;i<V.size();i++){
int j=lower_bound(gmx,gmx+V.size(),g[i])-gmx;
int has=i-j+1,haslen=V[i]-V[j]+1;
//printf("val=1%d val2=%d\n",V[i-1],j);
int rr=i==V.size()-1?n:(V[i+1]-1);
int ll=j==0?1:(V[j-1]+1);
int tmpans=min(rr-ll+1,has*2);
int csr=V[i]+min(tmpans-haslen,rr-V[i]);
//printf("%d %d %d %d\n",ll,rr,has,tmpans);
if(tmpans>ans){
ans=tmpans;
ansr=csr;
}
}
}
void solve(vector<int>&V){
check(V);
}
int main()
{
freopen("halfgcd.in","r",stdin);
freopen("halfgcd.out","w",stdout);
getp();
scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%d",a+i);
for(int i=1;i<=n;i++){
int x=a[i];
for(int j=0;j<pri.size();j++){
if(1LL*pri[j]*pri[j]>x)break;
if(x%pri[j])continue;
V[j].push_back(i);
while(x%pri[j]==0)x/=pri[j];
}
if(x>1)V[lower_bound(pri.begin(),pri.end(),x)-pri.begin()].push_back(i);
}
ans=0,ansr=-1;
for(int it=0;it<pri.size();it++){
if(!V[it].size())continue;
solve(V[it]);
}
if(!ans){
puts("0 0");
}
else printf("%d %d\n",ansr-ans+1,ansr);
return 0;
}


E. Next Partition in RLE Notation

#include <bits/stdc++.h>
using namespace std ;

typedef long long LL ;
typedef pair < int , int > pii ;
typedef pair < LL , LL > pll ;

#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 100005 ;

vector < pll > G ;
int n ;

void get ( LL N , LL K , LL val ) {
LL tmp1 = ( N - K ) / ( val - 1 ) ;
LL tmp2 = ( N - K ) % ( val - 1 ) ;
LL tmp3 = K - tmp1 - ( tmp2 > 0 ) ;
if ( tmp1 ) G.push_back ( pll ( tmp1 , val ) ) ;
if ( tmp2 ) G.push_back ( pll ( 1 , tmp2 + 1 ) ) ;
if ( tmp3 ) G.push_back ( pll ( tmp3 , 1 ) ) ;
}

void solve () {
G.clear () ;
for ( int i = 1 ; i <= n ; ++ i ) {
LL x , y ;
scanf ( "%lld%lld" , &x , &y ) ;
G.push_back ( pll ( x , y ) ) ;
}
if ( n == 1 || n == 2 && G[0].second - G[1].second == 1 ) {
printf ( "-1\n" ) ;
return ;
}
pll a = G[n - 1] ;
-- n ;
G.pop_back () ;
pll b = G[n - 1] ;
if ( G[n - 1].second - a.second > 1 ) {
G[n - 1].first -- ;
if ( !G[n - 1].first ) {
G.pop_back () ;
-- n ;
}
//printf ( "%lld %lld %lld %lld\n" , a.first , a.second , b.first , b.second ) ;
get ( a.first * a.second + b.second , a.first + 1 , b.second - 1 ) ;
} else {
G.pop_back () ;
-- n ;
pll c = G[n - 1] ;
G[n - 1].first -- ;
if ( !G[n - 1].first ) {
G.pop_back () ;
-- n ;
}
get ( a.first * a.second + b.first * b.second + c.second , a.first + b.first + 1 , c.second - 1 ) ;
}
printf ( "%d\n" , ( int ) G.size () ) ;
for ( int i = 0 ; i < G.size () ; ++ i ) {
printf ( "%lld %lld\n" , G[i].first , G[i].second ) ;
}
}

int main () {
freopen ( "next-partition-rle.in" , "r" , stdin ) ;
freopen ( "next-partition-rle.out" , "w" , stdout ) ;
while ( ~scanf ( "%d" , &n ) ) solve () ;
return 0 ;
}


F. Equation

G. “Swap-Plus” Puzzle

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<string>
#include<iostream>
using namespace std;

int i,j,a[9][9],b[9],c[9],d[9][9],m,e[100];
int ans=~0U>>1,cnt;

string q[100];

int now;

int cal(int*a,int n){
int t=0;
int i,j;
static int b[100];
for(i=1;i<=n;i++)b[i]=a[i];
for(i=1;i<=n;i++){
for(j=1;j<=n;j++)if(b[j]==i){
if(i!=j)t++;
swap(b[j],b[i]);
break;
}
}
return t;
}

int cal2(int*a,int n){
int t=0;
int i,j;
static int b[100];
for(i=1;i<=n;i++)b[i]=i;
for(i=1;i<=n;i++){
for(j=1;j<=n;j++)if(b[j]==a[i]){
if(i!=j)t++;
swap(b[j],b[i]);
break;
}
}
return t;
}

void conb(int*a,char st){//[1,2,3,4]->a
static int b[10];
int i,j;
for(i=1;i<=4;i++)b[i]=i;
for(i=1;i<=4;i++){
for(j=1;j<=4;j++)if(b[j]==a[i]){
if(i!=j){
string t="";
t.push_back(b[i]+st-1);
t.push_back('-');
t.push_back(b[j]+st-1);
q[++cnt]=t;
}
swap(b[j],b[i]);
break;
}
}
}
void cond(){//a->[1,2,3,4,...,16]
static int a[9][9];
int i,j,x,y;
for(i=1;i<=4;i++)for(j=1;j<=4;j++)a[i][j]=d[i][j];
for(i=1;i<=4;i++)for(j=1;j<=4;j++){
int now=(i-1)*4+j;
if(a[i][j]==now)continue;
bool flag=0;
for(x=1;x<=4;x++){
for(y=1;y<=4;y++)if(a[x][y]==now){
flag=1;
swap(a[x][y],a[i][j]);
string t="";
t.push_back(i+'a'-1);
t.push_back(j+'0');
t.push_back('-');
t.push_back(x+'a'-1);
t.push_back(y+'0');
q[++cnt]=t;
break;
}
if(flag)break;
}
}
}

int main (){
freopen ( "puzzle-swap-plus.in" , "r" , stdin ) ;
freopen ( "puzzle-swap-plus.out" , "w" , stdout ) ;
for(i=1;i<=4;i++)
for(j=1;j<=4;j++)
scanf("%d",&a[i][j]);
for(i=1;i<=4;i++)b[i]=i;

do{
for(i=1;i<=4;i++)c[i]=i;
do{
now=cal2(b,4)+cal2(c,4);
for(i=1;i<=4;i++)for(j=1;j<=4;j++)d[b[i]][c[j]]=a[i][j];
m=0;
for(i=1;i<=4;i++)for(j=1;j<=4;j++)e[++m]=d[i][j];
now+=cal(e,16);
if(now<ans){
ans=now;
cnt=0;
conb(b,'a');
conb(c,'1');
cond();
}
}while(next_permutation(c+1,c+4+1));
}while(next_permutation(b+1,b+4+1));
printf("%d\n",ans);
for(i=1;i<=cnt;i++)cout<<q[i]<<endl;
return 0;
}


H. Wrong Sieve

#include<bits/stdc++.h>
using namespace std;
const int Maxn=105;
typedef long long LL;
typedef pair<int,int>pi;
LL solve(LL x){
for(LL i=1;x>=(i+1);i++){
if(x%(i+1)==0)return -1;
x=x-x/(i+1);
}
return x;
}
int main()
{
freopen("sieve.in","r",stdin);
freopen("sieve.out","w",stdout);
int _;scanf("%d",&_);
while(_--){
LL x;scanf("%lld",&x);
LL ans=solve(x);
printf("%lld\n",ans);
}
return 0;
}


I. Space Cat

DP，$f[i][j]$表示在第$i$条线段，重心方向为$j$的最小代价，注意要特判图不联通的情况。

#include <bits/stdc++.h>
using namespace std ;

typedef pair < int , int > pii ;

#define clr( a , x ) memset ( a , x , sizeof a )

typedef long long ll;
const ll inf=1LL<<60;
const int N=100010;

int n,i,a[N],b[N],c[N];
ll f[N][2];

inline void up(ll&x,ll y){if(x>y)x=y;}

int main () {
int T ;
freopen ( "space-cat.in" , "r" , stdin ) ;
freopen ( "space-cat.out" , "w" , stdout ) ;
scanf("%d",&n);
for(i=1;i<=n;i++)scanf("%d",&a[i]);
for(i=1;i<=n;i++)scanf("%d",&b[i]),c[i]=a[i]-b[i];
for(i=2;i<=n;i++)if(b[i]>=a[i-1]||b[i-1]>=a[i])return puts("-1"),0;
for(i=1;i<=n;i++)f[i][0]=f[i][1]=inf;
f[1][0]=0;
for(i=1;i<=n;i++){
if(i>1){
if(a[i-1]<=a[i])up(f[i][1],f[i-1][1]);
if(b[i-1]>=b[i])up(f[i][0],f[i-1][0]);
}
for(int j=0;j<4;j++){
up(f[i][0],f[i][1]+c[i]);
up(f[i][1],f[i][0]+c[i]);
}
}
if(f[n][0]>=inf)f[n][0]=-1;
printf("%lld\n",f[n][0]);
return 0 ;
}


J. Tic-Tac-Toe Variation

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int>pi;
const int Maxn=1000020;
char Mp[4][4];
bool getMp(){
bool ret=0;
for(int i=0;i<3;i++){
scanf("%s",Mp[i]);
for(int j=0;j<3;j++){
if(Mp[i][j]!='x')ret=1;
}
}
return ret;
}
int idx[3][3]={
{0,1,2},
{7,-1,3},
{6,5,4}
};
int dx[8],dy[8];
int curMp[3][3];
int cg(char c){
if(c=='.')return 0;
if(c=='x')return 1;
return 2;
}
void tran(){
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
curMp[i][j]=cg(Mp[i][j]);
}
}
}
void pt(){
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
int c=curMp[i][j];
if(!c)putchar('.');
if(c==1)putchar('x');
if(c==2)putchar('o');
}
puts("");
}
fflush(stdout);
}
int getst(){
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(curMp[i][j]==2){
return idx[i][j];
}
}
}
}
int main()
{
//freopen("halfgcd.in","r",stdin);
//freopen("halfgcd.out","w",stdout);
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(i==1&&j==1)continue;
dx[idx[i][j]]=i;
dy[idx[i][j]]=j;
}
}
while(getMp()){
int st;
memset(curMp,0,sizeof curMp);
for(int it=0;;it++){
if(it==0){
curMp[1][1]=1;
pt();
continue;
}
if(it==1){
getMp();
tran();
st=getst();
int nst=(st+2)%8;
curMp[dx[nst]][dy[nst]]=1;
pt();
continue;
}
if(it==2){
getMp();
tran();
if(curMp[dx[(st+6)%8]][dy[(st+6)%8]]!=2){
curMp[dx[(st+6)%8]][dy[(st+6)%8]]=1;
pt();
break;
}
else{
curMp[dx[(st+3)%8]][dy[(st+3)%8]]=1;
pt();
}
}
if(it==3){
getMp();
tran();
int nst=st&1?((st+1)%8):((st+4)%8);
if(!curMp[dx[nst]][dy[nst]]){
curMp[dx[nst]][dy[nst]]=1;
pt();
break;
}
else{
nst=(st+7)%8;
curMp[dx[nst]][dy[nst]]=1;
pt();
break;
}
}
}
}
return 0;
}


K. Captain Tarjan

#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 MAXN = 100005 ;

vector < pii > G[MAXN] ;
LL dp[MAXN] , dp2[MAXN] , maxc[MAXN] ;
LL Ldp[MAXN] , Rdp[MAXN] , Lmaxc[MAXN] , Rmaxc[MAXN] ;
int c[MAXN] ;
int siz[MAXN] ;
int son[MAXN] ;
int pre[MAXN] ;
int top[MAXN] ;
int dep[MAXN] ;
int n , m ;
LL ans ;

void predfs ( int u , int f ) {
siz[u] = 1 ;
son[u] = 0 ;
for ( int i = 0 ; i < G[u].size () ; ++ i ) {
int v = G[u][i].first ;
if ( v == f ) continue ;
pre[v] = u ;
dep[v] = dep[u] + 1 ;
predfs ( v , u ) ;
siz[u] += siz[v] ;
if ( siz[v] > siz[son[u]] ) son[u] = v ;
}
}

void rebuild ( int u , int top_element ) {
top[u] = top_element ;
if ( son[u] ) rebuild ( son[u] , top_element ) ;
for ( int i = 0 ; i < G[u].size () ; ++ i ) {
int v = G[u][i].first ;
if ( v != pre[u] && v != son[u] ) rebuild ( v , v ) ;
}
}

int get_lca ( int x , int y ) {
while ( top[x] != top[y] ) {
if ( dep[top[x]] > dep[top[y]] ) x = pre[top[x]] ;
else y = pre[top[y]] ;
}
return dep[x] < dep[y] ? x : y ;
}

void dfs1 ( int u ) {
for ( int i = 0 ; i < G[u].size () ; ++ i ) {
int v = G[u][i].first ;
if ( v == pre[u] ) continue ;
dfs1 ( v ) ;
G[u][i].second = c[v] ;
c[u] += c[v] ;
}
}

void dfs2 ( int u ) {
dp[u] = maxc[u] = 0 ;
for ( int i = 0 ; i < G[u].size () ; ++ i ) {
int v = G[u][i].first ;
if ( v == pre[u] ) continue ;
dfs2 ( v ) ;
dp[u] += dp[v] + G[u][i].second ;
maxc[u] = max ( maxc[u] , G[u][i].second + 0LL ) ;
}
dp[u] -= maxc[u] ;
}

void dfs3 ( int u , int cost ) {
int n = G[u].size () ;
Ldp[0] = 0 ;
Rdp[n - 1] = 0 ;
Lmaxc[0] = 0 ;
Rmaxc[n - 1] = 0 ;
for ( int i = 1 ; i < n ; ++ i ) {
int v = G[u][i - 1].first ;
if ( v == pre[u] ) {
Ldp[i] = Ldp[i - 1] ;
Lmaxc[i] = Lmaxc[i - 1] ;
} else {
Ldp[i] = Ldp[i - 1] + dp[v] + G[u][i - 1].second ;
Lmaxc[i] = max ( Lmaxc[i - 1] , G[u][i - 1].second + 0LL ) ;
}
}
for ( int i = n - 2 ; i >= 0 ; -- i ) {
int v = G[u][i + 1].first ;
if ( v == pre[u] ) {
Rdp[i] = Rdp[i + 1] ;
Rmaxc[i] = Rmaxc[i + 1] ;
} else {
Rdp[i] = Rdp[i + 1] + dp[v] + G[u][i + 1].second ;
Rmaxc[i] = max ( Rmaxc[i + 1] , G[u][i + 1].second + 0LL ) ;
}
}
for ( int i = 0 ; i < n ; ++ i ) {
int v = G[u][i].first ;
if ( v == pre[u] ) continue ;
dp2[v] = dp2[u] + Ldp[i] + Rdp[i] + cost - max ( max ( Lmaxc[i] , Rmaxc[i] ) , cost + 0LL ) ;
ans = min ( ans , dp2[v] + dp[v] + maxc[v] + G[u][i].second - max ( maxc[v] , 0LL + G[u][i].second ) ) ;
}
for ( int i = 0 ; i < n ; ++ i ) {
int v = G[u][i].first ;
if ( v == pre[u] ) continue ;
dfs3 ( v , G[u][i].second ) ;
}
}

void solve () {
for ( int i = 1 ; i <= n ; ++ i ) {
G[i].clear () ;
c[i] = 0 ;
}
for ( int i = 1 ; i < n ; ++ i ) {
int u , v ;
scanf ( "%d%d" , &u , &v ) ;
G[u].push_back ( pii ( v , 0 ) ) ;
G[v].push_back ( pii ( u , 0 ) ) ;
}
predfs ( 1 , 1 ) ;
rebuild ( 1 , 1 ) ;
for ( int i = 0 ; i < m ; ++ i ) {
int u , v ;
scanf ( "%d%d" , &u , &v ) ;
c[u] ++ ;
c[v] ++ ;
int lca = get_lca ( u , v ) ;
c[lca] -= 2 ;
}
dp2[1] = 0 ;
dfs1 ( 1 ) ;
dfs2 ( 1 ) ;
ans = dp[1] ;
dfs3 ( 1 , 0 ) ;
printf ( "%lld\n" , ans ) ;
}

int main () {
freopen ( "treepaths.in" , "r" , stdin ) ;
freopen ( "treepaths.out" , "w" , stdout ) ;
while ( ~scanf ( "%d%d" , &n , &m ) ) solve () ;
return 0 ;
}


L. Gardening Lesson

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int>pi;
const int Maxn = 100005 , x = 123 , M = 998244353 , Left = 23 , Right = 371 ;
const int Hleaf=Left*Right,Inf=1e9;
vector < int > G1[Maxn] , G2[Maxn] ;
int H1[Maxn] , H2[Maxn] ;
int sz[Maxn],sonsz[Maxn],ans ;
void dfs(int u , vector<int>*G,int p){
sz[u]= 1;
sonsz[u]=0;
for(int i=0;i<G[u].size ();++i){
int v =G[u][i];
if(v==p)continue ;
dfs(v,G,u);
sz[u]+=sz[v];
if(sz[v]>sonsz[u])sonsz[u]=sz[v];
}
}
vector<int>getroot(vector<int>*G,int n){
dfs(1,G,0);
vector<int>ret;
for(int i=1;i<=n;++i){
if(max(n-sz[i],sonsz[i])<=n/2){
ret.push_back(i);
}
}
return ret;
}
bool cmp1(int a, int b){return H1[a]<H1[b];}
bool cmp2(int a, int b){return H2[a]<H2[b];}
void dfs2(int u,int p,vector<int>*G,int*H,int ty){
H[u]=Left;
for(int i =0;i<G[u].size();++i){
int v=G[u][i];if(v==p)continue;
dfs2(v,u,G,H,ty);
}
sort(G[u].begin(),G[u].end(),ty==1?cmp1:cmp2);
for(int i=0;i<G[u].size();++i){
int v=G[u][i];if(v==p)continue;
H[u]=((1LL*H[u]*x)^H[v])%M;
}
H[u]=1LL*H[u]*Right%M;
}
void check(int ua,int pa,int ub,int pb){
//printf("%d %d %d %d\n",ua,pa,ub,pb);
set<pi>S;
for(int i=0;i<G2[ub].size();i++){
int v=G2[ub][i];
if(v==pb)continue;
S.insert(pi(H2[v],v));
}
vector<int>rest;
for(int i=0;i<G1[ua].size();i++){
int v=G1[ua][i];
if(v==pa)continue;
set<pi>::iterator it=S.lower_bound(pi(H1[v],-1));
if(it==S.end()||(it->first!=H1[v]))rest.push_back(v);
else S.erase(it);
}
if(rest.size()>1||S.size()>1)return;
if(S.size()==1&&!rest.size()){
if(S.begin()->first!=Hleaf)return;
for(int i=0;i<G2[ub].size();i++){
int v=G2[ub][i];if(v==pb)continue;
if(H2[v]==Hleaf){ans=min(ans,v);}
}
return;
}
if(S.size()==1&&rest.size()==1){
for(int i=0;i<G2[ub].size();i++){
int v=G2[ub][i];if(v==pb)continue;
if(H2[v]==S.begin()->first)check(rest[0],ua,v,ub);
}
}
}
void solve( int rt1 , int rt2){
dfs2(rt1,0,G1,H1,1);
dfs2(rt2,0,G2,H2,2);
check(rt1,0,rt2,0);
}
void pt(vector<int>&v){
for(int i=0;i<v.size();i++)printf("%d ",v[i]);
puts("");
}
int main()
{
freopen("unexpected-leaf.in","r",stdin);
freopen("unexpected-leaf.out","w",stdout);
int n;
while(scanf("%d",&n)!=EOF){
for(int i=1;i<=n+1;i++){
G1[i].clear();
G2[i].clear();
}
for(int i=1;i<n;i++){
int u,v;scanf("%d%d",&u,&v);
G1[u].push_back(v);
G1[v].push_back(u);
}
for(int i=1;i<=n;i++){
int u,v;scanf("%d%d",&u,&v);
G2[u].push_back(v);
G2[v].push_back(u);
}
if(n==1){
printf("1\n");
continue;
}
if(n==2){
if(G2[1].size()==2)printf("2\n");
else printf("1\n");
continue;
}
vector<int>tmp1=getroot(G1,n);
vector<int>tmp2=getroot(G2,n+1);
//pt(tmp1);
//pt(tmp2);
ans=Inf;
//solve(1,3);
for(int i=0;i<tmp1.size();i++){
for(int j=0;j<tmp2.size();j++){
solve(tmp1[i],tmp2[j]);
}
}
printf("%d\n",ans);
}
return 0;
}


• L题发现树同构模板有误。

posted @ 2016-11-04 23:27  Claris  阅读(469)  评论(0编辑  收藏