Board Game
将 \(k\) 个非法状态在棋盘上所有可能的出现位置表示成 \(nm\) 位的二进制数，做高维前缀和来标记非法
之后是一个平凡的 \(\rm SG\) 函数问题，不另赘述，但是复杂度过高
注意到 \(vis,\rm dp\) 数组中的元素的值域是 \(\{0,1\}\) 所以考虑将相邻的 \(64\) 个数压成一个 \(64\) 位 unsigned long long，这样子在高维前缀和的时候做一次 \(\rm OR\) 操作就可以实现 \(64\) 个位的转移
此时仍然需要处理一个数字内部的转移，这里子母集关系只会出现在 \(0\sim 63\) 之间，预处理 \(64\) 个 unsigned long long \(\rm sub_i\) 表示 \(0\sim 63\) 中哪些是 \(i\) 的子集
这样子每次找到 \(\rm sub_j\& vis_i\) 就可以得到数字内部的转移了
而后面 \(\rm DP\) 的部分也是类似的，预处理每个 \(0\sim 63\) 添加一个 \(1\) 能走到内部的哪个元素，转移判定为 \(1\) 的元素个数是不是等于集合大小即可
Code Display
int n,m,lim,k;
ull vis[1<<21],dp[1<<21];
char s[30][30];
inline void Vis_set(int pos) { vis[pos >> 6] |= 1ull << (pos & 63); }
inline ull Vis(int pos) { return vis[pos >> 6] >> (pos & 63) & 1; }
namespace Sub1{
bool vis[1<<22],dp[1<<22];
inline int dfs(int x){
if(vis[x]) return dp[x];
vis[x]=1;
int U=(lim-1)^x;
while(U){
int lb=U&(-U);
if(!dfs(x^lb)) return dp[x]=1;
U-=lb;
} return dp[x];
}
inline void main(){
while(k--){
int h=read(),w=read();
rep(i,1,h) scanf("%s",s[i]+1);
for(int dx=0;dx<=n-h;++dx){
for(int dy=0;dy<=m-w;++dy){
int st=0;
for(int i=1;i<=h;++i){
for(int j=1;j<=w;++j){
if(s[i][j]=='1') st|=1<<((i+dx-1)*m+j+dy-1);
}
}
vis[st]=1;
}
}
}
lim=1<<(n*m);
for(int p=2;p<=lim;p<<=1){
int len=p>>1;
for(int k=0;k<lim;k+=p) for(int l=k;l<k+len;++l) vis[l+len]|=vis[l];
}
puts(dfs(0)?"Alice":"Bob");
exit(0);
}
}
signed main(){
freopen("game.in","r",stdin); freopen("game.out","w",stdout);
n=read(); m=read(); k=read();
if(n*m<=22) Sub1::main();
while(k--){
int h=read(),w=read();
rep(i,1,h) scanf("%s",s[i]+1);
for(int dx=0;dx<=n-h;++dx){
for(int dy=0;dy<=m-w;++dy){
int st=0;
for(int i=1;i<=h;++i){
for(int j=1;j<=w;++j){
if(s[i][j]=='1') st|=1<<((i+dx-1)*m+j+dy-1);
}
}
Vis_set(st);
}
}
}
vector<ull> Sub(64);
for(int i=0;i<64;++i){
Sub[i]|=1;
for(int j=i;j;j=(j-1)&i) Sub[i]|=1ull<<j;
}
lim=1<<(n*m-6);
for(int i=0;i<lim;++i){
for(int j=0;j<64;++j) if(vis[i]&Sub[j]) vis[i]|=1ull<<j;
}
for(int p=2;p<=lim;p<<=1){
int len=p>>1;
for(int k=0;k<lim;k+=p) for(int l=k;l<k+len;++l) vis[l+len]|=vis[l];
}
for(int i=0;i<64;++i){
Sub[i]=0;
rep(j,0,5) if(i>>j&1) Sub[i^(1<<j)]|=1ull<<i;
}
vector<int> bit(64);
rep(i,0,63) bit[i]=__builtin_popcountll(Sub[i]);
for(int i=lim-1;i>=0;--i){
for(int j=0;j<n*m-6;++j) if(!(i>>j&1)) dp[i]|=~dp[i^(1<<j)];
for(int j=63;j>=0;--j) if(!(vis[i]>>j&1)){
if(dp[i]>>j&1) continue;
if(__builtin_popcountll(dp[i]&Sub[j])!=bit[j]) dp[i]|=1ull<<j;
}else if(dp[i]>>j&1) dp[i]^=(1ull<<j);
}
puts((dp[0]&1)?"Alice":"Bob");
return 0;
}
Difference Query
首先注意给定的序列是排列
考察 \(f(x,x)\) 做若干步逆操作得到的形式可以发现 \(\exists p,\frac{x}{\rm gcd(x,y)}+\frac{y}{\rm gcd(x,y)}=2^p\Rightarrow f(x,y)=p\)，否则 \(f(x,y)=0\)
扫描线，对于每个 \(i\) 枚举 \(a_i\) 的因子作为 \(\rm gcd\)，再枚举 \(2^p\) 作为答案，找到所有带来贡献的数字在线段树上执行区间加法即可
回答完询问之后再把每个 \(a_i\) 放到其因子的标号为 \(\frac {a_i}d\) 的桶里面即可，空间复杂度是 \(\Theta(n\ln n)\) 的，加一些剪枝可以获得小常数
Code Display
const int N=1e5+10;
int ans[N],n,a[N],Q,Mx[N];
vector<int> Div[N];
vector<vector<pair<int,int> > > app[N];
struct Seg{
#define ls p<<1
#define rs p<<1|1
#define lson p<<1,l,mid
#define rson p<<1|1,mid+1,r
int fir[N<<2],len[N<<2],delt[N<<2];
inline void build(int p,int l,int r){
len[p]=r-l+1; if(l==r) return ;
int mid=(l+r)>>1; build(lson); build(rson);
return ;
}
inline void upd(int st,int ed,int fr,int d,int p=1,int l=1,int r=n){
if(st<=l&&r<=ed) return fir[p]+=(l-st)*d+fr,delt[p]+=d,void();
int mid=(l+r)>>1;
if(st<=mid) upd(st,ed,fr,d,lson); if(ed>mid) upd(st,ed,fr,d,rson);
return ;
}
inline int Query(int pos,int p=1,int l=1,int r=n){
int res=fir[p]+delt[p]*(pos-l); if(l==r) return res;
int mid=(l+r)>>1;
if(pos<=mid) return res+Query(pos,lson);
else return res+Query(pos,rson);
}
#undef ls
#undef rs
#undef lson
#undef rson
}T;
vector<pair<int,int> >qu[N];
signed main(){
freopen("func.in","r",stdin); freopen("func.out","w",stdout);
n=1e5;
rep(i,1,n){
for(int j=i;j<=n;j+=i) Div[j].emplace_back(i);
app[i].resize(n/i+2);
}
n=read();
rep(i,1,n) a[i]=read();
Q=read();
for(int i=1;i<=Q;++i){
int l=read(),r=read();
qu[r].emplace_back(l,i);
}
for(int i=1;i<=n;++i){
for(auto d:Div[a[i]]) if((a[i]/d)&1){
int quo=a[i]/d,p=1;
while((1<<p)<quo) ++p;
while(Mx[d]>=(1<<p)-quo){
for(auto &rng:app[d][(1<<p)-quo]){
int len=rng.sec-rng.fir+1;
T.upd(rng.fir,rng.sec,len*p,-p);
if(rng.fir!=1) T.upd(1,rng.fir-1,len*p,0);
}
++p;
}
}
for(auto q:qu[i]) ans[q.sec]=T.Query(q.fir);
for(auto d:Div[a[i]]) if((a[i]/d)&1){
int quo=a[i]/d;
if(!app[d][quo].size()||app[d][quo].back().sec<i-1) app[d][quo].emplace_back(i,i);
else app[d][quo].back().sec=i;
ckmax(Mx[d],quo);
}
}
rep(i,1,Q) print(ans[i]);
return 0;
}
Minimal DFA
一个识别 \(\Sigma \in\{0,1\},L\subset \Sigma^n,L\neq \empty\) 的 \(\rm DFA\) 应当有如下几个性质：
- 可以将点分成 \(n+1\) 层，否则能识别的长度不唯一
下设 \(k_i\) 表示 \(\rm DFA\) 的第 \(i\) 层点的数量
-
\(k_i\le k_{i-1}\times |\Sigma|\)
-
\(k_i+1\le (k_i+1)^2\)
这个是因为第 \(i\) 层的每个点有 \((k_{i+1}+1)^2\) 种后继连接方式，\(+1\) 是不选择任何连边，但是不能两个都不连，也不能出现两个相同，所以得到解释
第二条从层数小向层数大限制，第三条从层数大到小限制，那么一个高精度类即可解决
找到第一个 \(k_{i+1}\neq 2k_{i}\) 的 \(i\) 来进行后面两问的计算：
（下简记从某个第 \(i+1\) 层的点走到终点的路径上 \(|\Sigma_E|\) 的乘积为其走法）
如果 \(k_{i+1}\ge k_i\) 那么可以证明 \(k_{i+1}=2k_i-1\)，将 \(i+1\) 层每个点连接出边之后 \(i\) 层的点只剩下 \(1\) 的度，最大就是再连 \(2^{n-i}\) 的走法的点，最小就是不连
否则考虑先给所有第 \(i+1\) 层的点连接出边，根据最大化/最小化需求将余下的出边分配终点，以最大化为例
开始考虑每个 \(i+1\) 层的点分配出边是涉及的 \(i\) 层点的另一个出边都连向 \(2^{n-i}\) 走法的点
从大到小枚举剩下点连出去的两条边的走法之和 \(v\)，这时候使用组合数即可得到方案 \(\binom{2^{n-i+1}}v\)，注意要减去已经走过的方案数 \([v\ge 2^{n-i}]\binom{2^{n-i}}{v-2^{n-i}}\)
最小化同理，一开始强制连出的点不选第二个终点，后面枚举边权从小往大即可
Code Display
const int Bas=1e8;
struct node{
vector<int> a;
inline int size(){return a.size();}
inline void adjust(){
int siz=a.size();
for(int i=0;i<siz-1;++i) a[i+1]+=a[i]/Bas,a[i]%=Bas;
while(a[siz-1]>=Bas){
a.emplace_back(a[siz-1]/Bas);
a[siz-1]%=Bas;
++siz;
}
while(siz>1&&!a[siz-1]) a.pop_back(),--siz;
return ;
}
inline void init(int x){
a.clear();
while(x) a.push_back(x%Bas),x/=Bas;
return ;
}
//Attention: const node b is not available here!
//we Use function size which may change itself though it actually don't
bool operator <(node b)const{
if(a.size()!=b.size()) return a.size()<b.size();
int len=a.size();
for(int i=len-1;~i;--i) if(a[i]^b.a[i]) return a[i]<b.a[i];
return 0;
}
bool operator ==(node b)const{
if(b.size()!=a.size()) return 0;
int len=a.size();
for(int i=0;i<len;++i) if(a[i]!=b.a[i]) return 0;
return 1;
}
bool operator <=(node &b)const{return *this<b||*this==b;}
node operator +(node b)const{
node res;
int s1=a.size(),s2=b.a.size(); res.a.resize(max(s1,s2));
for(int i=0;i<s1;++i) res.a[i]+=a[i];
for(int i=0;i<s2;++i) res.a[i]+=b.a[i];
res.adjust();
return res;
}
node operator -(node b)const{
node res=*this;
int s1=a.size(),s2=b.size();
for(int i=0;i<s2;++i){
res.a[i]-=b.a[i];
if(res.a[i]<0) res.a[i]+=Bas,res.a[i+1]--;
}
for(int i=s2;i<s1;++i) if(res.a[i]<0) res.a[i+1]--,res.a[i]+=Bas;
res.adjust();
return res;
}
node operator *(node b)const{
node res; res.a.resize(a.size()+b.size()-1);
for(int i=0;i<a.size();++i) for(int j=0;j<b.size();++j) res.a[i+j]+=a[i]*b.a[j];
res.adjust();
return res;
}
bool operator !=(node &b){return !(*this==b);}
node operator *(const int &p)const{node t; t.init(p); return *this*t;}
node operator +(const int &p)const{node t; t.init(p); return *this+t;}
node operator -(const int &p)const{node t; t.init(p); return *this-t;}
inline void output(){
int siz=a.size(); printf("%lld",a[siz-1]);
for(int i=siz-2;~i;--i) printf("%08lld",a[i]);
putchar(' ');
return ;
}
};
const int N=1010;
node A[N],pw[1030],C[1030][1030],ans;
int n,Div;
inline void solve_min(int Div){
node sum;
node nds=A[Div]-A[Div+1]; Div=n-Div;
sum=pw[1<<Div]*(1<<(Div-1));
for(int v=1;v<=(1<<(Div+1));++v){
node cur=C[1<<(Div+1)][v];
if(v<=(1<<Div)){
cur=cur-C[1<<Div][v];
}
if(nds<cur) cur=nds;
sum=sum+(cur*v);
nds=nds-cur;
if(nds.size()==1&&nds.a[0]==0) break;
}
sum.output();
}
inline void solve_max(int Div){
node sum;
node nds=A[Div]-A[Div+1]; Div=n-Div;
sum=pw[1<<Div]*(1<<(Div-1))+((pw[1<<Div]-1)*(1<<Div));
for(int v=(1<<(Div+1));v>=1;--v){
node cur=C[1<<(Div+1)][v];
if(v>=(1<<Div)){
cur=cur-C[1<<Div][v-(1<<Div)];
}
if(nds<cur) cur=nds;
sum=sum+(cur*v);
nds=nds-cur;
if(nds.size()==1&&nds.a[0]==0) break;
}
sum.output();
}
signed main(){
freopen("dfa.in","r",stdin); freopen("dfa.out","w",stdout);
n=1024;
C[0][0].init(1); pw[0].init(1);
for(int i=1;i<=n;++i){
C[i][0].init(1); pw[i]=pw[i-1]*2;
for(int j=1;j<=i;++j){
C[i][j]=C[i-1][j]+C[i-1][j-1];
}
}
n=read();
if(n==1) puts("2 1 2"),exit(0);
if(n==2) puts("4 2 3"),exit(0);
A[1].init(1); A[n+1].init(1);
for(int i=2;i<=n;++i) A[i]=A[i-1]*2;
for(int i=n;i>=1;--i){
node tmp=A[i+1]+1; tmp=tmp*tmp-1;
if(A[i]<=tmp) break;
A[i]=tmp;
}
for(int i=1;i<=n+1;++i) ans=ans+A[i];
ans.output();
for(int i=1;i<=n;++i) if(A[i]*2!=A[i+1]){Div=i; break;}
if(A[Div]<A[Div+1]){
(A[Div]*(1<<(n-Div))).output();
((A[Div]+1)*(1<<(n-Div))).output();
}else{
solve_min(Div);
solve_max(Div);
}
return 0;
}