XIX Open Cup named after E.V. Pankratiev. GP of Poland(AMPPZ-2018)
A. Drone With a Camera
三分套三分。
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
typedef long double ld;
const ld K=1e9,inf=1e100,eps=1e-9;
const int T=200;
struct P{
ld x,y;
P(){}
P(ld _x,ld _y){x=_x,y=_y;}
}O;
struct Line{
ld a,b,c;
void init(){
double _a,_b,_c;
scanf("%lf%lf%lf",&_a,&_b,&_c);
a=_a,b=_b,c=_c;
}
P cal(ld x){
if(fabs(b)>fabs(a))return P(x,(c-a*x)/b);
return P((c-b*x)/a,x);
}
}A,B;
inline ld sqr(ld x){return x*x;}
inline ld dis(P a,P b){
return sqrt(sqr(a.x-b.x)+sqr(a.y-b.y));
}
inline ld cal(ld x,ld y){
P u=A.cal(x);
P v=B.cal(y);
return dis(O,u)+dis(u,v)+dis(v,O);
}
inline ld ASK(ld x){
ld l=-K,r=K,ans=inf;
for(int i=T;i--;){
ld len=(r-l)/3;
ld m1=l+len,m2=r-len;
ld f1=cal(x,m1),f2=cal(x,m2);
ans=min(ans,min(f1,f2));
if(f1<f2)r=m2;else l=m1;
}
return ans;
}
ld ask(){
ld l=-K,r=K,ans=inf;
for(int i=T;i--;){
ld len=(r-l)/3;
ld m1=l+len,m2=r-len;
ld f1=ASK(m1),f2=ASK(m2);
ans=min(ans,min(f1,f2));
if(f1<f2)r=m2;else l=m1;
}
return ans;
}
int main(){
A.init();
B.init();
printf("%.15f",(double)ask());
}
B. Fibonaccis’ vouchers
考虑用最少的Fib数表示一个数，只需要从大到小贪心选取每个Fib数。
将一个数写成Fib进制，可以得到一个$01$串，满足没有连续两个$1$。
从高位到低位逐位确定答案的每一位是$0$还是$1$，需要求出在给定前缀的情况下，有多少个$01$字符串满足没有连续两个$1$，且$1$的个数不超过$k$。设$f[i][j][k]$表示考虑了前$i$位，一共$j$个$1$，第$i$位是$k$的字符串的方案数，DP统计即可。
时间复杂度$O(k^3)$。
#include<cstdio>
typedef long long ll;
const ll inf=1000000000000000000LL;
const int N=150;
int cnt,i,j,k,b[N];ll a[N],n,ans;
ll f[N][N][2];
inline ll add(ll a,ll b){
a+=b;
if(a>inf+10)return inf+10;
return a;
}
inline int cal(ll x){
int ret=0;
for(int i=cnt;i;i--)if(x>=a[i])x-=a[i],ret++;
return ret;
}
inline ll solution(int lim){
//[1..lim] are not known
int i,j,x,o;
for(i=0;i<=cnt+10;i++)for(j=0;j<=k;j++)for(o=0;o<2;o++)f[i][j][o]=0;
int _=0;
for(i=lim+1;i<=cnt;i++)if(b[i]&&b[i+1])return 0;
for(i=lim+1;i<=cnt;i++)_+=b[i];
if(_>k)return 0;
f[lim+1][_][b[lim+1]]=1;
for(i=lim+1;i>1;i--)for(j=0;j<=k;j++)for(o=0;o<2;o++)for(x=0;x<2;x++){
if(o&&x)continue;
if(j+x>k)continue;
f[i-1][j+x][x]=add(f[i-1][j+x][x],f[i][j][o]);
}
ll ret=0;
for(j=0;j<=k;j++)for(o=0;o<2;o++)ret=add(ret,f[1][j][o]);
return ret;
}
int main(){
a[1]=1;
a[2]=2;
for(i=3;;i++){
a[i]=a[i-1]+a[i-2];
if(a[i]<=inf)cnt=i;
else break;
}
//it should >= k
scanf("%d%lld",&k,&n);
for(i=0;i<k;i++)if(cal(i)<=k)n++;
for(i=cnt;i;i--){
for(j=0;j<2;j++){
b[i]=j;
ll tmp=solution(i-1);
//printf("%d %d %lld\n",i,j,tmp);
if(n<=tmp)break;
else{
n-=tmp;
}
}
if(j==2)return puts("NIE"),0;
}
for(i=1;i<=cnt;i++)if(b[i])ans=add(ans,a[i]);
if(ans>inf)puts("NIE");else printf("%lld",ans);
}
C. Chinese Remainder Theorem
对于一个式子$a_i\equiv b_i\pmod{m}(a_i\geq b_i)$，$m$需要满足$m|a_i-b_i$，所以$m$的最大值为$\gcd(a_i-b_i)$。
#include<cstdio>
typedef long long ll;
int n,i;ll ans,a[111111],b[111111];
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
int main(){
scanf("%d",&n);
for(i=1;i<=n;i++)scanf("%lld",&a[i]);
for(i=1;i<=n;i++)scanf("%lld",&b[i]);
for(i=1;i<=n;i++)ans=gcd(ans,a[i]-b[i]);
printf("%lld",ans);
}
D. Road
因为下雪操作是全局操作，因此最厚的位置一定是最后一次扫雪时间最早的那一个，线段树维护区间内最后一次扫雪时间的最小值，然后利用二分和前缀和计算雪的厚度即可。
时间复杂度$O(q\log n)$。
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=300010,M=20000000,P=1000000007,inf=~0U>>1,inv2=(P+1)/2;
int cnt,n,m,t,x,y,z,F,G,ST;char op[9];
int T,tot,l[M],r[M],tag[M],val[M];
struct E{
int f,g,sum,st,en;
int at(int x){return (1LL*f*(x-st+1)+g)%P;}
int cal(int l,int r){return 1LL*inv2*(at(l)+at(r))%P*(r-l+1)%P;}
}e[N],now;
inline void tag1(int&x,int p){
if(!x)x=++tot;
tag[x]=max(tag[x],p);
val[x]=max(val[x],p);
}
inline void pb(int x){
if(tag[x]){
tag1(l[x],tag[x]);
tag1(r[x],tag[x]);
tag[x]=0;
}
}
void change(int&x,int a,int b,int c,int d,int p){
if(!x)x=++tot;
if(c<=a&&b<=d){
tag1(x,p);
return;
}
pb(x);
int mid=(a+b)>>1;
if(c<=mid)change(l[x],a,mid,c,d,p);
if(d>mid)change(r[x],mid+1,b,c,d,p);
val[x]=min(val[l[x]],val[r[x]]);
}
int ask(int x,int a,int b,int c,int d){
if(c<=a&&b<=d||!x)return val[x];
pb(x);
int mid=(a+b)>>1,t=inf;
if(c<=mid)t=ask(l[x],a,mid,c,d);
if(d>mid)t=min(t,ask(r[x],mid+1,b,c,d));
return t;
}
inline int query(int L,int R){
if(L>R)return 0;
int l=1,r=cnt,mid,t=0;
now.f=F;
now.g=G;
now.st=ST;
now.en=R;
while(l<=r){
mid=(l+r)>>1;
if(e[mid].st>L)r=mid-1;
else if(e[mid].en<L)l=mid+1;
else{
t=mid;
break;
}
}
if(t==0)return now.cal(L,R);
return ((1LL*now.cal(ST,R)+1LL*e[cnt].sum-1LL*e[t].sum+1LL*e[t].cal(L,e[t].en))%P+P)%P;
}
int main(){
scanf("%d%d",&n,&m);
while(m--){
scanf("%d%s%d%d",&t,op,&x,&y);
if(op[0]=='L'){
change(T,1,n,x,y,t);
}
if(op[0]=='S'){
scanf("%d",&z);
change(T,1,n,x,y,t+z);
}
if(op[0]=='?'){
z=min(ask(T,1,n,x,y),t);
printf("%d\n",query(z+1,t));
}
if(op[0]=='B'){
e[++cnt].f=F;
e[cnt].g=G;
e[cnt].st=ST;
e[cnt].en=t;
e[cnt].sum=(e[cnt-1].sum+e[cnt].cal(e[cnt].st,e[cnt].en))%P;
ST=t+1;
F=x;
G=y;
}
}
}
E. Evaluation
求出任意一棵最小生成树。
对于每条非树边$(u,v)$，答案为这棵生成树上$u$到$v$路径上边权的最大值。
对于每条树边$(u,v)$，答案为所有非树边在树上路径中覆盖了这条边的边权的最小值。
倍增实现快速操作即可。
时间复杂度$O(m\log n)$。
#include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
#define mset(x, y) memset(x, y, sizeof x)
#define mcpy(x, y) memcpy(x, y, sizeof x)
using namespace std;
typedef long long LL;
typedef pair < int, int > pii;
inline int Read()
{
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-')
f = -1;
for (; isdigit(c); c = getchar())
x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
int f[MAXN], u[MAXN], v[MAXN], w[MAXN], p[MAXN], n, m, g[18][MAXN], h[18][MAXN], dep[MAXN], ans[MAXN], e[18][MAXN];
vector < pii > adj[MAXN], a[MAXN];
bool t[MAXN];
inline int Find(int x) { while (x ^ f[x]) x = f[x] = f[f[x]]; return x; }
inline void Dfs(int x)
{
for (auto e : adj[x])
{
int y = e.xx, w = e.yy;
if (y == g[0][x])
continue;
g[0][y] = x; h[0][y] = w;
for (int i = 1; i <= 17; i ++)
g[i][y] = g[i - 1][g[i - 1][y]], h[i][y] = max(h[i - 1][y], h[i - 1][g[i - 1][y]]);
dep[y] = dep[x] + 1;
Dfs(y);
}
}
inline void Build()
{
sort(p + 1, p + m + 1, [&](int x, int y) { return w[x] < w[y]; });
for (int i = 1; i <= n; i ++)
f[i] = i;
for (int i = 1; i <= m; i ++)
{
int x = u[p[i]], y = v[p[i]], z = w[p[i]];
if (Find(x) ^ Find(y))
f[Find(x)] = Find(y), t[p[i]] = 1, adj[x].pb(mp(y, z)), adj[y].pb(mp(x, z));
}
Dfs(1);
}
inline int Query(int x, int y)
{
int ret = 0;
if (dep[x] < dep[y])
swap(x, y);
if (dep[x] ^ dep[y])
for (int i = 17; ~i; i --)
if (dep[x] - dep[y] >> i & 1)
ret = max(ret, h[i][x]), x = g[i][x];
if (x == y)
return ret;
for (int i = 17; ~i; i --)
if (g[i][x] ^ g[i][y])
ret = max(ret, max(h[i][x], h[i][y])), x = g[i][x], y = g[i][y];
return max(ret, max(h[0][x], h[0][y]));
}
inline void Add(int x, int y, int w)
{
if (dep[x] < dep[y])
swap(x, y);
if (dep[x] ^ dep[y])
for (int i = 17; ~i; i --)
if (dep[x] - dep[y] >> i & 1)
e[i][x] = min(e[i][x], w), x = g[i][x];
if (x ^ y)
{
for (int i = 17; ~i; i --)
if (g[i][x] ^ g[i][y])
e[i][x] = min(e[i][x], w), e[i][y] = min(e[i][y], w), x = g[i][x], y = g[i][y];
e[0][x] = min(e[0][x], w);
e[0][y] = min(e[0][y], w);
}
}
int main()
{
#ifdef wxh010910
freopen("data.in", "r", stdin);
#endif
n = Read(), m = Read();
for (int i = 1; i <= m; i ++)
u[i] = Read(), v[i] = Read(), w[i] = Read(), p[i] = i;
Build();
mset(e, INF);
for (int i = 1; i <= m; i ++)
if (!t[i])
ans[i] = Query(u[i], v[i]), Add(u[i], v[i], w[i]);
else if (dep[u[i]] < dep[v[i]])
f[v[i]] = i;
else
f[u[i]] = i;
for (int j = 17; j; j --)
for (int i = 1; i <= n; i ++)
e[j - 1][i] = min(e[j - 1][i], e[j][i]), e[j - 1][g[j - 1][i]] = min(e[j - 1][g[j - 1][i]], e[j][i]);
for (int i = 2; i <= n; i ++)
ans[f[i]] = e[0][i] == INF ? 1e9 : e[0][i];
for (int i = 1; i <= m; i ++)
printf("%d\n", ans[i]);
return 0;
}
F. Baking Pans
即判断$\sqrt{p}+\sqrt{d}<\sqrt{t}$是否成立，特判$p+d>t$的情况后，两边平方得$p+d+2\sqrt{pd}<t$，移项后再两边平方得$4pd<(t-p-d)^2$。
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <string>
#include <bitset>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <sstream>
#include <stack>
#include <iomanip>
using namespace std;
#define pb push_back
#define mp make_pair
typedef pair<int,int> pii;
typedef __int128 ll;
typedef double ld;
typedef vector<int> vi;
#define fi first
#define se second
#define fe first
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}
#define Edg int M=0,fst[SZ],vb[SZ],nxt[SZ];void ad_de(int a,int b){++M;nxt[M]=fst[a];fst[a]=M;vb[M]=b;}void adde(int a,int b){ad_de(a,b);ad_de(b,a);}
#define Edgc int M=0,fst[SZ],vb[SZ],nxt[SZ],vc[SZ];void ad_de(int a,int b,int c){++M;nxt[M]=fst[a];fst[a]=M;vb[M]=b;vc[M]=c;}void adde(int a,int b,int c){ad_de(a,b,c);ad_de(b,a,c);}
#define es(x,e) (int e=fst[x];e;e=nxt[e])
#define esb(x,e,b) (int e=fst[x],b=vb[e];e;e=nxt[e],b=vb[e])
bool sol(ll p,ll d,ll t)
{
if(d+p>=t) return 0;
return p*d*4<(t-d-p)*(t-d-p);
}
int main()
{
int T; ll p,d,t;
cin>>T;
while(T--)
{
long long _,__,___;
cin>>_>>__>>___;
p=_; d=__; t=___;
if(sol(p,d,t))
puts("TAK");
else puts("NIE");
}
}
G. Taste in Art
首先将所有相同的数合并，显然每种数字要么都不选，要么都选。
将每个数看作$2^x3^yz$，对于$z$相同的那些数字，将它们以坐标$(x,y)$放在网格图上，则不能选出一个形状为$L$的$3$个点，轮廓线DP即可。
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=50010,M=19;
int n,m,i,j,a[N],ans,o,f[2][1<<M];
struct E{int v,x,y,z;E(){}E(int _v,int _x,int _y,int _z){v=_v,x=_x,y=_y,z=_z;}}e[N],b[N];
inline bool cmp(const E&a,const E&b){
if(a.v!=b.v)return a.v<b.v;
if(a.x!=b.x)return a.x<b.x;
return a.y<b.y;
}
inline void up(int&a,int b){a<b?(a=b):0;}
inline int solve(int L,int R){
int ret=0,i,j,k,x,y,z,A,B;
if(L+1>=R){
for(i=L;i<=R;i++)ret+=e[i].z;
return ret;
}
int ymin=100;
for(i=L;i<=R;i++){
b[i]=e[i];
ymin=min(ymin,e[i].y);
}
for(i=L;i<=R;i++)b[i].y-=ymin;
o=0;
A=1;
for(j=0;j<1<<A;j++)f[0][j]=f[1][j]=-1;
f[0][0]=0;
int oldy=-1;
//puts("!");
for(i=L;i<=R;i++){
x=b[i].x,y=b[i].y,z=b[i].z;
//printf("x=%d y=%d z=%d\n",x,y,z);
B=max(A,y+1);
if(i>L&&x==b[i-1].x){
int blank=~0U>>1;
for(j=b[i-1].y+1;j<y;j++)blank^=1<<j;
for(j=0;j<1<<B;j++)f[o^1][j]=-1;
for(j=0;j<1<<A;j++)if(~f[o][j]){
k=j␣
int kk=k;
if(kk>>y&1)kk^=1<<y;
//not choose
up(f[o^1][kk],f[o][j]);
//choose
if((k>>y&1)&&(k>>(y+1)&1))continue;
up(f[o^1][kk^(1<<y)],f[o][j]+z);
}
o^=1;
A=B;
oldy=y;
}else{
int blank=~0U>>1;
for(j=oldy+1;j<A;j++)blank^=1<<j;
for(j=0;j<y;j++)blank^=1<<j;
for(j=0;j<1<<B;j++)f[o^1][j]=-1;
for(j=0;j<1<<A;j++)if(~f[o][j]){
k=j␣
int kk=k;
if(kk>>y&1)kk^=1<<y;
//not choose
up(f[o^1][kk],f[o][j]);
//choose
if((k>>y&1)&&(k>>(y+1)&1))continue;
up(f[o^1][kk^(1<<y)],f[o][j]+z);
}
o^=1;
A=B;
oldy=y;
}
}
for(j=0;j<1<<A;j++)up(ret,f[o][j]);
return ret;
}
//[0..18]
int main(){
scanf("%d",&n);
for(i=1;i<=n;i++)scanf("%d",&a[i]);
sort(a+1,a+n+1);
for(i=1;i<=n;i=j){
for(j=i;j<=n&&a[i]==a[j];j++);
int v=a[i],x=0,y=0;
while(v%2==0)v/=2,x++;
while(v%3==0)v/=3,y++;
e[++m]=E(v,x,y,j-i);
}
sort(e+1,e+m+1,cmp);
for(i=1;i<=m;i=j){
for(j=i+1;j<=m;j++){
if(e[j].v!=e[j-1].v)break;
if(e[j-1].x+1<e[j].x)break;
if(e[j-1].x+1==e[j].x&&e[j-1].y<e[j].y)break;
}
ans+=solve(i,j-1);
}
printf("%d",ans);
}
H. Hobby
方案数为$9!$，爆搜即可。
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=111;
int va,vb,vc,v1,v2,v3,v4,i,q[N];
char a[N][N];
int s[N];
bool check(){
if(q[1]+q[2]+q[4]+q[5]!=v1)return 0;
if(q[2]+q[3]+q[5]+q[6]!=v2)return 0;
if(q[4]+q[5]+q[7]+q[8]!=v3)return 0;
if(q[5]+q[6]+q[8]+q[9]!=v4)return 0;
s[0]=s[1]=s[2]=0;
s[a[1][1]-'A']+=q[1];
s[a[1][2]-'A']+=q[2];
s[a[1][3]-'A']+=q[3];
s[a[2][1]-'A']+=q[4];
s[a[2][2]-'A']+=q[5];
s[a[2][3]-'A']+=q[6];
s[a[3][1]-'A']+=q[7];
s[a[3][2]-'A']+=q[8];
s[a[3][3]-'A']+=q[9];
if(s[0]!=va)return 0;
if(s[1]!=vb)return 0;
if(s[2]!=vc)return 0;
return 1;
}
int main(){
scanf("%d%d%d%d%d%d%d",&va,&vb,&vc,&v1,&v2,&v3,&v4);
for(i=1;i<=3;i++)scanf("%s",a[i]+1);
for(i=1;i<=9;i++)q[i]=i;
do{
if(check()){
for(i=1;i<=9;i++){
printf("%d",q[i]);
if(i%3==0)puts("");
}
return 0;
}
}while(next_permutation(q+1,q+10));
puts("NIE");
}
I. Grade Book
对于两份作业$(p_i,t_i),(p_j,t_j)$，其中$t_i\leq t_j$，则交完作业$i$后能赶到$j$当且仅当$t_j-t_i\geq |p_i-p_j|$。
将绝对值拆开，有：
- $t_j-p_j\geq t_i-p_i$
- $t_j+p_j\geq t_i+p_i$
将$(t_i-p_i,t_i+p_i)$作为坐标放在平面上，那么每个点可以走到右上角的区域，根据Dilworth定理，最少所需的天数等于最长反链的大小，也就是最长下降子序列的长度。
时间复杂度$O(n\log n)$。
#include<cstdio>
#include<algorithm>
#include<set>
using namespace std;
int n,i;set<int>T;
struct P{int x,y;}a[2222222];
inline bool cmp(const P&a,const P&b){
if(a.x!=b.x)return a.x<b.x;
return a.y>b.y;
}
int main(){
scanf("%d",&n);
for(i=1;i<=n;i++){
int p,t;
scanf("%d%d",&p,&t);
a[i].x=p+t;
a[i].y=p-t;
}
sort(a+1,a+n+1,cmp);
for(i=1;i<=n;i++){
int x=a[i].y;
set<int>::iterator it=T.lower_bound(x);
if(it!=T.end())T.erase(it);
T.insert(x);
}
printf("%d",(int)T.size());
}
J. Identical Scarves
将所有数排序，显然最优方案是选择一个区间并将它们调整到中位数，双指针枚举区间即可。
时间复杂度$O(n\log n)$。
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=100010;
int n,i,j,a[N],ans;ll lim,s[N];
inline ll cal(int l,int r){
int m=(l+r)/2;
return s[r]-s[m]-1LL*(r-m)*a[m]+1LL*(m-l+1)*a[m]-s[m]+s[l-1];
}
int main(){
scanf("%d%lld",&n,&lim);
for(i=1;i<=n;i++)scanf("%d",&a[i]);
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++){
while(j<n&&cal(i,j+1)<=lim)j++;
ans=max(ans,j-i+1);
}
printf("%d",ans);
}
K. Pocket Money
对于最大可能值，一定是先放$+$，再放$0$，最后放$-$。
对于最小可能值，从$1$开始逐位确定，能放$-$就放$-$。
时间复杂度$O(n\log n)$。
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <string>
#include <bitset>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <sstream>
#include <stack>
#include <iomanip>
using namespace std;
#define pb push_back
#define mp make_pair
typedef pair<int,int> pii;
typedef long long ll;
typedef double ld;
typedef vector<int> vi;
#define fi first
#define se second
#define fe first
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}
#define Edg int M=0,fst[SZ],vb[SZ],nxt[SZ];void ad_de(int a,int b){++M;nxt[M]=fst[a];fst[a]=M;vb[M]=b;}void adde(int a,int b){ad_de(a,b);ad_de(b,a);}
#define Edgc int M=0,fst[SZ],vb[SZ],nxt[SZ],vc[SZ];void ad_de(int a,int b,int c){++M;nxt[M]=fst[a];fst[a]=M;vb[M]=b;vc[M]=c;}void adde(int a,int b,int c){ad_de(a,b,c);ad_de(b,a,c);}
#define es(x,e) (int e=fst[x];e;e=nxt[e])
#define esb(x,e,b) (int e=fst[x],b=vb[e];e;e=nxt[e],b=vb[e])
#define SZ 1234567
char s[SZ],w[SZ]; int n;
vector<int> es;
const int M=1048576;
pii g[3][M+M+3];
pii operator + (pii a,pii b)
{
return mp(min(a.fi,a.se+b.fi),a.se+b.se);
}
pii qry(pii*a,int l,int r)
{
pii L(0,0),R(0,0);
if(l>r) return L;
for(l+=M-1,r+=M+1;l^r^1;l>>=1,r>>=1)
{
if(~l&1) L=L+a[l^1];
if(r&1) R=a[r^1]+R;
}
return L+R;
}
ll chk(int pos,int neg)
{
if(pos+neg>int(es.size()))
return 0;
for(int i=1;i<=n;++i)
w[i]=(s[i]=='_')?'0':s[i];
for(int i=0;i<pos;++i)
w[es[i]]='+';
for(int i=0;i<neg;++i)
w[es[es.size()-i-1]]='-';
int g=0; ll su=1;
for(int i=1;i<=n;++i)
{
if(w[i]=='+') ++g;
else if(w[i]=='-') --g;
if(g<0) return 0; su+=g;
}
return su;
}
void wo(pii*t)
{
for(int i=M-1;i>=1;--i)
t[i]=t[i+i]+t[i+i+1];
}
pii ys[2333];
bool chk(int l,int i,pii cur,int w)
{
// cerr<<l<<','<<i<<":"<<cur.fi<<","<<cur.se<<" "<<w<<"\n";
if(abs(w)+i+1>es.size()) return 0;
int p=abs(w),q=p-w;
int _=(es.size()-i-1-p-q)/2;p+=_;q+=_;
int r=es.size()-i-1-p-q;
// cerr<<p<<","<<q<<" "<<p+q<<" "<<es.size()-i-1<<" "<<i<<"w"<<es.size()<<"G\n";
if(p)
i+=p,cur=cur+qry(g[0],l,es[i]),l=es[i]+1;
if(r)
i+=r,cur=cur+qry(g[1],l,es[i]),l=es[i]+1;
if(q)
i+=q,cur=cur+qry(g[2],l,es[i]),l=es[i]+1;
cur=cur+qry(g[2],es[i]+1,n);
return cur.fi>=0;
}
int main()
{
ys['+']=mp(0,1);
ys['-']=mp(-1,-1);
ys['0']=mp(0,0);
scanf("%s",s+1); n=strlen(s+1);
int t=0,em=0;
for(int i=1;i<=n;++i)
if(s[i]=='+') --t;
else if(s[i]=='-') ++t;
else if(s[i]=='0');
else ++em,es.pb(i);
for(int i=1;i<=n;++i)
g[0][i+M]=ys[(s[i]=='_')?'+':s[i]];
for(int i=1;i<=n;++i)
g[1][i+M]=ys[(s[i]=='_')?'0':s[i]];
for(int i=1;i<=n;++i)
g[2][i+M]=ys[(s[i]=='_')?'-':s[i]];
wo(g[0]);wo(g[1]);wo(g[2]);
//pos-neg=t
if(abs(t)>em)
{
puts("NIE");
return 0;
}
int p=max(t,0),q=p-t;
int w=(em-p-q)/2;
p+=w; q+=w;
ll u=chk(p,q);
if(!u)
{
puts("NIE");
return 0;
}
//cerr<<"++\n";
pii su(0,0);
int r=1,gg=0; ll sb=0;
for(int i=0;i<es.size();++i)
{
int x=es[i];
while(r<x)
su=su+ys[s[r++]],
//cerr<<r-1<<" "<<su.fi<<","<<su.se<<"\n",
sb+=su.se;
r=x+1;
char u[3]={'-','0','+'};
for(auto p:u)
{
pii sw=su+ys[p];
if(chk(x+1,i,sw,t-gg-ys[p].se))
{
s[x]=p; su=sw; gg+=ys[p].se;
sb+=su.se; break;
}
}
//cout<<x<<"!"<<s[x]<<"\n";
if(s[x]=='_') throw "GG";
}
while(r<=n)
su=su+ys[s[r++]],sb+=su.se;
// puts(s+1);
printf("%lld ",sb);
printf("%lld\n",u-1);
}
L. Lines
因为任何一种方案都可以将$01$取反得到另一个方案，因此答案一定是$2$的倍数，所以当$P=2$时直接输出$0$。
否则$P>2$且$P$是质数，所以存在$2$的逆元。
考虑容斥，选择一些行、列和对角线，满足这些行、列、对角线上所有字符都相等，其它的不管，则对答案的贡献为$(-1)^{被打破的限制个数}2^{未被这些行、列、对角线覆盖的格子数}2^{必然相等的连通块个数}$。
对于选择了$0$条对角线的情况：
枚举选择的行数$i$和列数$j$，用组合数算出选法的数量，未被覆盖的格子数为$(n-i)(n-j)$，而连通块个数在$i\times j=0$的时候为$i+j$，否则为$1$，时间复杂度$O(n^2)$。
对于选择了$1$条对角线的情况：
连通块个数必然为$1$。
假设选择了$x$行和$y$列，那么未被覆盖的格子数为$(n-x)(n-y)$减去对角线上未被覆盖的格子数。
设$f[i][j][k]$表示考虑对角线上前$i$个格子，选了$j$行$k$列时，所有方案的容斥系数除以$2^{对角线上未被覆盖的格子数}$的和，枚举下一行下一列的选法进行转移，时间复杂度$O(n^3)$。
对于选择了$2$条对角线的情况：
和上述方法类似，设$f[i][j][k]$表示考虑$i\times i$的棋盘，选了$j$行$k$列时，所有方案的容斥系数除以$2^{对角线上未被覆盖的格子数}$的和，往外扩一圈进行转移，从$f[i][][]$转移到$f[i+2][][]$，时间复杂度$O(n^3)$。
特别要注意这种情况下，连通块个数一般都为$1$，但是当$n$是偶数且$j=k=0$时连通块个数为$2$，需要特判。
#include<cstdio>
const int N=310;
int inv2;
int n,P,i,j,k,x,y,C[N][N],p[N*N],ans;
int f[N][N][N],g[N][N][N],v[3][3];
int pow(int a,int b){int t=1;for(;b;b>>=1,a=1LL*a*a%P)if(b&1)t=1LL*t*a%P;return t;}
inline void up(int&a,int b){a=(a+b)%P;}
int cal1(){
f[0][0][0]=(P-2)%P;
for(i=0;i<n;i++)for(j=0;j<=i;j++)for(k=0;k<=i;k++){
up(f[i+1][j][k],1LL*f[i][j][k]*inv2%P);
up(f[i+1][j+1][k],P-f[i][j][k]);
up(f[i+1][j][k+1],P-f[i][j][k]);
up(f[i+1][j+1][k+1],f[i][j][k]);
}
int ret=0;
for(i=0;i<=n;i++)for(j=0;j<=n;j++)up(ret,1LL*f[n][i][j]*p[(n-i)*(n-j)]%P);
return ret;
}
int cal2(){
g[0][0][0]=2;
g[1][0][0]=1;
g[1][0][1]=g[1][1][0]=(P-2)%P;
g[1][1][1]=2;
//when n is even and i=j=0, it is different
for(x=0;x<3;x++)for(y=0;y<3;y++){
int tmp=C[2][x]*C[2][y]%P;
if((x+y)&1)tmp=(P-tmp)%P;
int cnt=(2-x)*(2-y);
while(cnt--)tmp=1LL*tmp*inv2%P;
v[x][y]=tmp;
}
for(i=0;i<n;i++)for(j=0;j<=i;j++)for(k=0;k<=i;k++)
for(x=0;x<3;x++)for(y=0;y<3;y++)
up(g[i+2][j+x][k+y],1LL*v[x][y]*g[i][j][k]%P);
int ret=0;
if(n&1){
for(i=0;i<=n;i++)for(j=0;j<=n;j++)up(ret,1LL*g[n][i][j]*p[(n-i)*(n-j)]%P);
}else{
for(i=0;i<=n;i++)for(j=0;j<=n;j++)if(i||j)up(ret,1LL*g[n][i][j]*p[(n-i)*(n-j)]%P);
up(ret,p[n*n-n-n+2]);
}
return ret;
}
int main(){
scanf("%d%d",&n,&P);
if(P==2)return puts("0"),0;
inv2=pow(2,P-2);
for(p[0]=i=1;i<=n*n;i++)p[i]=p[i-1]*2%P;
for(C[0][0]=i=1;i<=n||i<=2;i++)for(C[i][0]=j=1;j<=i;j++)C[i][j]=(C[i-1][j-1]+C[i-1][j])%P;
//no diagonals
for(i=0;i<=n;i++)for(j=0;j<=n;j++){
int tmp=1LL*C[n][i]*C[n][j]%P*p[(n-i)*(n-j)]%P;
if(!i||!j)tmp=1LL*tmp*p[i+j]%P;else tmp=tmp*2%P;
if((i+j)&1)tmp=(P-tmp)%P;
up(ans,tmp);
}
up(ans,2LL*cal1()%P);
up(ans,cal2());
printf("%d",(ans%P+P)%P);
}
M. Magical Maze
首先剔除所有不能到达$(1,1)$和$(n,m)$的点，问题转化为对于每个点$x$，统计它能到达多少点。
注意到这是平面图，因此从$x$点出发，左手摸墙走可以走出一条到终点的路径，右手摸墙走也可以走出一条到终点的路径，把这两段路径拼起来可以得到一个简单多边形，多边形内的所有点都是$x$能到达的。
求出每条横边下方的点数，往右走时加上下面的点数，往左走时减去下面的点数，即可算出多边形内的点数。
以左手摸墙为例，设$f(i,j,k=0,1,2,3)$表示人位于$(i,j)$，左手摸着$k$方向这面墙，人位于这面墙的起点(即还没有开始摸这面墙)时，直到终点的贡献和，可以记忆化搜索求出。
对于每个点答案的计算，可以枚举两种初始朝向，取答案较大的那一个作为真正的答案。
时间复杂度$O(nm)$。
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=500010;
char tmp[N];long long ans;
int n,m,i,j,k,x,s[N],fl[N][4],fr[N][4],dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
bool d[N][4],v1[N],v2[N],visl[N][4],visr[N][4];
/*
0
3 1
2
*/
inline int id(int x,int y){
if(x<1||x>n||y<1||y>m)return 0;
return (x-1)*m+y;
}
void dfs1(int x,int y){
int z=id(x,y);
if(v1[z])return;
v1[z]=1;
for(int i=0;i<4;i++)if(d[z][i])dfs1(x+dx[i],y+dy[i]);
}
void dfs2(int x,int y){
int z=id(x,y);
if(v2[z])return;
v2[z]=1;
for(int i=0;i<4;i++)if(d[id(x-dx[i],y-dy[i])][i])dfs2(x-dx[i],y-dy[i]);
}
int dpl(int x,int y,int k){//left hand on the kth wall，后退到不能再后退（即顶点）
int z=id(x,y);
if(visl[z][k])return fl[z][k];
visl[z][k]=1;
int&ret=fl[z][k];
ret=0;
if(x==n&&y==m&&(k==1||k==2))return ret;
if(d[z][k])return ret=dpl(x+dx[k],y+dy[k],(k+3)&3);
if(k==0)ret+=s[id(x,y)];
if(k==2)ret-=s[id(x+1,y)];
return ret+=dpl(x,y,(k+1)&3);
}
int dpr(int x,int y,int k){//right hand on the kth wall，后退到不能再后退（即顶点）
int z=id(x,y);
if(visr[z][k])return fr[z][k];
visr[z][k]=1;
int&ret=fr[z][k];
ret=0;
if(x==n&&y==m&&(k==1||k==2))return ret;
if(d[z][k])return ret=dpr(x+dx[k],y+dy[k],(k+1)&3);
if(k==0)ret+=s[id(x,y)];
if(k==2)ret-=s[id(x+1,y)];
return ret+=dpr(x,y,(k+3)&3);
}
int main(){
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++){
if(m>1)scanf("%s",tmp+1);
for(j=1;j<m;j++){
if(tmp[j]=='>')d[id(i,j)][1]=1;
if(tmp[j]=='<')d[id(i,j+1)][3]=1;
}
if(i==n)continue;
scanf("%s",tmp+1);
for(j=1;j<=m;j++){
if(tmp[j]=='v')d[id(i,j)][2]=1;
if(tmp[j]=='^')d[id(i+1,j)][0]=1;
}
}
dfs1(1,1);
dfs2(n,m);
for(i=1;i<=n;i++)for(j=1;j<=m;j++)v1[id(i,j)]&=v2[id(i,j)];
for(i=1;i<=n;i++)for(j=1;j<=m;j++){
x=id(i,j);
if(!v1[x])for(k=0;k<4;k++)d[x][k]=0;
for(k=0;k<4;k++)if(!v1[id(i+dx[k],j+dy[k])])d[x][k]=0;
}
for(i=n;i;i--)for(j=1;j<=m;j++)s[id(i,j)]=s[id(i+1,j)]+v1[id(i,j)];
for(i=1;i<=n;i++)for(j=1;j<=m;j++){
x=id(i,j);
if(!v1[x])continue;
ans+=max(dpl(i,j,0)+dpr(i,j,3),dpl(i,j,2)+dpr(i,j,1));
}
printf("%lld",ans);
}
