容斥专题总结
A:How many integers can you find
过于水，但是有细节
\[\ \]
\[\ \]
B: Eddy's爱好
枚举k的值，直接开k次方根，为了防止爆精度，我手写了一下
然后就是对于因数容斥，或者是直接套莫比乌斯系数
const int N=4e5+10;
const ll INF=(1ll<<62)-1;
ll n;
ll qsm(ll x,ll k) {
ll res=1;
while(k) {
if(k&1) {
double t=(double)res*x;
if(t>INF) {
res=INF;
break;
}
else res=res*x;
}
double t=(double)x*x;
if(t>INF) x=INF;
else x=x*x;
k>>=1;
}
return res;
}
ll yroot(ll x,ll y){
ll l=1,r=2e9,res=1;
while(l<=r) {
ll mid=(l+r)>>1;
if(qsm(mid,y)<=x) res=mid,l=mid+1;
else r=mid-1;
}
return res;
}
ll dp[100];
int main() {
while(~scanf("%lld",&n)) {
ll res=0;
rep(i,2,60) dp[i]=yroot(n,i)-1;
drep(i,60,2) for(int j=i+i;j<=60;j+=i) dp[i]-=dp[j];//k=i的情况会在j中被多次计算
rep(i,2,60) res+=dp[i];
printf("%lld\n",res+1);
}
}\[ \ \]
\[ \ \]
C: Coprime
提出n，m的质因数，然后二分答案，直接二进制枚举来容斥
const int N=4e5+10;
const ll INF=(1ll<<62)-1;
int k;
int fac[N],n;
void Div(int x) {
for(int i=2;i*i<=x;++i) if(x%i==0) {
fac[n++]=i;
while(x%i==0) x/=i;
}
if(x>1) fac[n++]=x;
}
ll Check(ll mid){
ll res=0;
rep(S,0,(1<<n)-1) {
ll t=1,cnt=0;
rep(i,0,n-1) if(S&(1<<i)) cnt^=1,t=t*fac[i];
if(cnt) res-=mid/t;
else res+=mid/t;
}
return res;
}
int main(){
rep(kase,1,rd()) {
n=0;Div(rd()),Div(rd());
k=rd();
sort(fac,fac+n);
n=unique(fac,fac+n)-fac;
ll l=1,r=1e15,res=-1;
while(l<=r) {
ll mid=(1ll*l+1ll*r)>>1;
if(Check(mid)>=k) res=mid,r=mid-1;
else l=mid+1;
}
printf("Case %d: %lld\n",kase,res);
}
}
\[ \ \]
\[ \ \]
D: GCD
首先外层的区间可以容斥
然后是对于每个\(1 \leq i \leq n\)二进制枚举容斥\(1..m\)中互质的个数
const int N=1e5+10;
const ll INF=(1ll<<62)-1;
int a,b,c,d,k;
vector <int> fac[N];
ll Solve(int n,int m,int k) {
if(!k||!n||!m) return 0;
n/=k,m/=k;
if(n<m) swap(n,m);
ll res=0;
rep(i,1,n) {
int t=min((int)i,m);
int k=fac[i].size();
rep(j,0,(1<<k)-1){
ll x=1,cnt=0;
rep(o,0,k-1) if(j&(1<<o)) x=x*fac[i][o],cnt^=1;
if(cnt) res-=t/x;
else res+=t/x;
}
}
return res;
}
int main(){
rep(i,2,N-1) if(!fac[i].size()) for(int j=i;j<N;j+=i) fac[j].push_back((int)i);
rep(kase,1,rd()) {
a=rd(),b=rd(),c=rd(),d=rd(),k=rd();
ll res=Solve(b,d,k)-Solve(a-1,d,k)-Solve(b,c-1,k)+Solve(a-1,c-1,k);
printf("Case %d: %lld\n",kase,res);
}
}
\[\ \]
\[ \ \]
E: Co-prime
基本思想之前都出现过了，跳过吧
\[ \ \]
\[ \ \]
F: Frogs
这个题还是非常有点东西的对吧
首先你要知道这样一件事
对于任何的\(gcd(n,m)=1\),$\lbrace n*i mod m|i \in Z \rbrace \(=\){0,1,..,m-1}$
然后其实对于任意\(gcd(n,m)=g\),$\lbrace ni mod m|i \in Z \rbrace \(=\){0,g,g2,..,m-1}$
所以每个青蛙能走到的地方就确定了，设这些\(gcd\)的值为\(a[1..n]\)
这时候我们模拟一下二进制枚举的过程,即取出其中的一些数，求出他们的\(lcm(lowest \ common \ multiple)\)，当数的个数为奇数时加，偶数时减
即当你每次多选择一个数时，系数的符号取相反数,而\(lcm\)的情况数并不多，也就是\(m\)的因子个数
所以直接dp转移求系数即可
const int N=1e4+10;
ll gcd(ll a,ll b) {return b==0?a:gcd(b,a%b); }
int n,m;
int a[N];
int fac[N],c;
ll dp[N];
int lcm[2000][2000];
int gcd(int a,int b){ return b==0?a:gcd(b,a%b); }
int main(){
rep(kase,1,rd()) {
n=rd(),m=rd();
rep(i,1,n) a[i]=gcd(rd(),m);
sort(a+1,a+n+1);
n=unique(a+1,a+n+1)-a-1;
c=0;
rep(i,1,sqrt(m+0.5)) if(m%i==0) {
fac[++c]=i;
if(i*i!=m) fac[++c]=m/i;
}
sort(fac+1,fac+c+1);
rep(i,1,c) dp[i]=0;
rep(i,1,n) a[i]=lower_bound(fac+1,fac+c+1,a[i])-fac;
rep(i,1,c) rep(j,1,c) lcm[i][j]=lower_bound(fac+1,fac+c+1,fac[i]/gcd(fac[i],fac[j])*fac[j])-fac;
rep(i,1,n) {
int x=a[i];
drep(j,c,1) {
dp[lcm[x][j]]-=dp[j];
}
dp[a[i]]++;
}
ll ans=0;
rep(i,1,c) ans+=1ll*dp[i]*(m/fac[i])*(m-fac[i])/2;
printf("Case #%d: %lld\n",kase,ans);
}
}\[ \ \]
\[ \ \]
\[ \ \]
\[ \ \]
G: The Monkey King
刚开始做的时候没想到可以\(n\ ln \ n\)写，头都想破了。。。
枚举大猴子拿了\(x\)个，然后容斥其他人拿的比他多的情况
统计时候，枚举有至少\(i\)个人比他多，答案是\(C(n+m-x*(i+1)-1，m-2)\)
其实是插板法求组合，然后就可以顺利的容斥了
int n,m;
ll po[N]={1},Inv[N]={1,1};
ll C(int n,int m){
if(n<0||m<0||n<m) return 0;
return po[n]*Inv[m]%P*Inv[n-m]%P;
}
ll Solve(int x) {
ll ans=C(n+m-x-2,m-2);
rep(i,1,min(m-1,n/x-1)) {
if(i&1) (ans=ans-C(m-1,i)*C(n+m-x*(i+1)-2,m-2))%=P;
else ans=(ans+C(m-1,i)*C(n+m-x*(i+1)-2,m-2))%P;
}
return ans=(ans%P+P)%P;
}
int main(){
rep(i,1,N-1) po[i]=po[i-1]*i%P;
rep(i,2,N-1) Inv[i]=(P-P/i)*Inv[P%i]%P;
rep(i,1,N-1) Inv[i]=Inv[i]*Inv[i-1]%P;
rep(kase,1,rd()) {
n=rd(),m=rd();
if(m==1) {
puts("1");
continue;
}
ll ans=0;
rep(i,(n-1)/m+1,n) ans+=Solve(i);
ans%=P;
ans=(ans%P+P)%P;
printf("%lld\n",ans);
}
}
\[ \ \]
\[ \ \]
H: Y sequence
这个题是真的没有素质
首先它和B题比就多了个二分，但如果真的写二分就TLE了! 必须写迭代
其次是不能手写开次方根了，只能用pow函数，而且还会爆精度
const ll INF=(1ll<<62)-1;
ll k;
int r;
int w[100],notpri[100],pri[100],cp;
int num[100],maxpri[100],nc;
inline ll Solve(ll n) {
ll res=0;
rep(i,1,nc) if(maxpri[i]<=r) res+=1ll*w[i]*((ll)pow(n+0.1,1.0/num[i])-1);
return n-res-1;
}
int main() {
rep(i,2,65) {
if(!notpri[i]) {
pri[++cp]=i;
for(int j=i+i;j<=65;j+=i) notpri[j]=1;
}
}
rep(i,2,65) {
int x=i,t=-1,ma=0;
rep(j,1,cp) {
int cnt=0;
while(x%pri[j]==0) cnt++,x/=pri[j];
if(cnt>1) {
t=0;
break;
}
if(cnt) t=-t,ma=max(ma,pri[j]);
}
if(t) w[++nc]=t,num[nc]=i,maxpri[nc]=ma;
}
rep(kase,1,rd()){
scanf("%lld",&k);r=rd();
ll ans=k;
while(1) {
ll tmp=Solve(ans);
if(k==tmp) break;
ans+=k-tmp;
}
printf("%lld\n",ans);
}
}
\[ \ \]
\[ \ \]
I: MG loves string
目测这题做法也奇多无比，我用了矩阵乘法
首先26个字母组成多个环，环长的种类最多只有6种
所以我直接将这6种环长状压，矩阵快速幂即可
const int N=1e5+10,P=1e9+7;
int n;
int nxt[26],c[26];
char str[30];
int vis[27];
int A,k[N],id[N];
int cnt;
ll gcd(ll a,ll b){ return b==0?a:gcd(b,a%b); }
struct Mat{
int a[1<<6][1<<6];
void init(){ rep(i,0,A) rep(j,0,A) a[i][j]=0; }
void Get1(){ rep(i,0,A) a[i][i]=1; }
Mat operator * (const Mat x) const{
Mat res; res.init();
rep(i,0,A) rep(j,0,A) rep(o,0,A) (res.a[i][o]+=1ll*a[i][j]*x.a[j][o]%P)%=P;
return res;
}
}res,x;
ll f[1][1<<6],ans[1][1<<6];
int main(){
rep(kase,1,rd()) {
n=rd();
scanf("%s",str);
rep(i,0,25) nxt[i]=str[i]-'a';
cnt=0;
memset(vis,0,sizeof vis);
rep(i,0,25) {
int p=i;c[i]=0;
do {
p=nxt[p];
c[i]++;
} while(p!=i);
if(!vis[c[i]]) {
vis[c[i]]=1;
id[c[i]]=cnt;
k[cnt++]=c[i];
}
}
A=(1<<cnt)-1;
x.init(),res.init();res.Get1();
rep(i,0,A) {
rep(j,0,25) {
x.a[i][i|(1<<id[c[j]])]++;
}
}
while(n) {
if(n&1) res=res*x;
x=x*x;
n>>=1;
}
memset(f,0,sizeof f);memset(ans,0,sizeof ans);
f[0][0]=1;
rep(i,0,0) rep(j,0,A) rep(o,0,A) (ans[i][o]+=1ll*f[i][j]*res.a[j][o]%P)%=P;
ll Ans=0;
rep(S,0,A) {
ll t=1;
rep(i,0,cnt-1) if(S&(1<<i)) t=t*k[i]/gcd(t,k[i]);
(Ans+=t*ans[0][S]%P)%=P;
}
printf("%lld\n",Ans);
}
}
\[ \ \]
\[ \ \]
J: Harry And Magic Box
dp容斥就好了，\(dp[i][j]\)表示\(i\)行\(j\)列的都放了的方案数，枚举小于\(i\)或小于\(j\)的方案减掉就好了
int n,m,q;
ll Inv[N*N]={1,1},po[N*N]={1};
ll B[N][N],p2[N*N]={1};
inline ll C(int n,int m){
if(n<0||m<0||n<m) return 0;
return po[n]*Inv[m]%P*Inv[n-m]%P;
}
int main(){
rep(i,1,N*N-1) po[i]=po[i-1]*i%P,p2[i]=p2[i-1]*2%P;
rep(i,2,N*N-1) Inv[i]=(P-P/i)*Inv[P%i]%P;
rep(i,1,N*N-1) Inv[i]=Inv[i]*Inv[i-1]%P;
rep(i,0,50) {
rep(j,0,50) {
B[i][j]=p2[i*j];
rep(a,0,i) {
rep(b,0,j) if(a!=i||b!=j) {
(B[i][j]-=C(i,a)*C(j,b)%P*B[a][b]%P)%=P;
}
}
B[i][j]=(B[i][j]%P+P)%P;
}
}
while(~scanf("%d%d",&n,&m)) printf("%lld\n",B[n][m]);
}\[ \ \]
\[ \ \]
\[ \ \]
K: Count the Grid
看起来非常吓人，但其实还好
总体思想就是给定每个点一个\(lim\)值，求出矩阵在限制条件下的方案数容斥
然后就是二进制枚举，对于每个被枚举到的\(lim\)值要减一
其实就是把选出的数全部在\(lim\)值以下的方案减去，这样得到的就是最大值为\(lim\)的方案了
如何统计矩阵的\(lim\)值，直接离散然后循环赋值就好了，但是由于被卡常了所以我不得不加了一些优化
代码写的比较诡异不建议看，拿去对拍可以
#include<bits/stdc++.h>
using namespace std;
#define reg register
typedef long long ll;
#define rep(i,a,b) for(reg int i=a;i<=b;++i)
#define drep(i,a,b) for(reg int i=a;i>=b;--i)
char IO;
int rd(){
int s=0,f=0;
while(!isdigit(IO=getchar())) if(IO=='-') f=1;
do s=(s<<1)+(s<<3)+(IO^'0');
while(isdigit(IO=getchar()));
return f?-s:s;
}
const int N=110,P=1e9+7;
int n,m,k,q;
int hx[N],cx,hy[N],cy;
struct REC{
int x1,y1,x2,y2,lim;
void Get() {
x1=rd(),y1=rd();
x2=rd(),y2=rd();
hx[++cx]=x1,hx[++cx]=x2;
if(x1>1) hx[++cx]=x1-1;
if(x1<n) hx[++cx]=x1+1;
if(x2>1) hx[++cx]=x2-1;
if(x2<n) hx[++cx]=x2+1;
hy[++cy]=y1,hy[++cy]=y2;
if(y1>1) hy[++cy]=y1-1;
if(y1<m) hy[++cy]=y1+1;
if(y2>1) hy[++cy]=y2-1;
if(y2<m) hy[++cy]=y2+1;
lim=rd();
}
void Hash() {
x1=lower_bound(hx+1,hx+cx+1,x1)-hx;
x2=lower_bound(hx+1,hx+cx+1,x2)-hx;
y1=lower_bound(hy+1,hy+cy+1,y1)-hy;
y2=lower_bound(hy+1,hy+cy+1,y2)-hy;
}
}R[N];
inline ll qsm(reg ll x,reg int k){
reg ll res=1;
for(;k;k>>=1,x=x*x%P) if(k&1) res=res*x%P;
return res;
}
int a[N][N],b[N][N],vis[N][N];
ll c[2][N][N];
ll Solve() {
ll ans=1;
rep(i,1,cx) rep(j,1,cy) a[i][j]=k;
for(reg int i=0; i<q; ++i) rep(x,R[i].x1,R[i].x2) rep(y,R[i].y1,R[i].y2) a[x][y]=min(a[x][y],R[i].lim);
rep(i,1,cx) rep(j,1,cy) ans=ans*qsm(a[i][j],(hx[i]-hx[i-1])*(hy[j]-hy[j-1]))%P;
return ans;
}
int main(){
int T=rd();
rep(kase,1,T){
n=rd(),m=rd(),k=rd(),q=rd();
hx[cx=1]=n,hy[cy=1]=m;
hx[++cx]=1,hy[++cy]=1;
rep(i,0,q-1) R[i].Get();
sort(hx+1,hx+cx+1),sort(hy+1,hy+cy+1);
cx=unique(hx+1,hx+cx+1)-hx-1,cy=unique(hy+1,hy+cy+1)-hy-1;
rep(i,0,q-1) R[i].Hash();
rep(i,1,cx) rep(j,1,cy) b[i][j]=k;
for(reg int i=0; i<q; ++i) rep(x,R[i].x1,R[i].x2) rep(y,R[i].y1,R[i].y2) b[x][y]=min(b[x][y],R[i].lim);
rep(i,1,cx) rep(j,1,cy){
c[0][i][j]=qsm(b[i][j],(hx[i]-hx[i-1])*(hy[j]-hy[j-1]))%P;
c[1][i][j]=qsm(b[i][j]-1,(hx[i]-hx[i-1])*(hy[j]-hy[j-1]))%P;
a[i][j]=b[i][j];
}
int A=(1<<q)-1;
ll ans=0;
rep(S,0,A) {
int cnt=0;
rep(i,0,q-1) if(S&(1<<i)) {
cnt^=1;
rep(x,R[i].x1,R[i].x2) rep(y,R[i].y1,R[i].y2) if(a[x][y]==R[i].lim) a[x][y]=R[i].lim-1,vis[x][y]=R[i].lim;
}
ll res=1;
rep(i,1,cx) rep(j,1,cy) res=res*c[b[i][j]-a[i][j]][i][j]%P;
if(cnt) ans-=res;
else ans+=res;
//cout<<S<<" "<<Solve()<<endl;
rep(i,0,q-1) if(S&(1<<i)) rep(x,R[i].x1,R[i].x2) rep(y,R[i].y1,R[i].y2) if(vis[x][y]) a[x][y]=vis[x][y],vis[x][y]=0;
}
ans=(ans%P+P)%P;
printf("Case #%d: %lld\n",kase,ans);
}
}
\[ \ \]
\[\ \]
L: Visible Trees
和前面的好几道题基本同理
#include<bits/stdc++.h>
using namespace std;
#define reg register
typedef long long ll;
#define rep(i,a,b) for(int i=a,i##end=b;i<=i##end;++i)
#define drep(i,a,b) for(int i=a,i##end=b;i>=i##end;--i)
char IO;
int rd(){
int s=0,f=0;
while(!isdigit(IO=getchar())) if(IO=='-') f=1;
do s=(s<<1)+(s<<3)+(IO^'0');
while(isdigit(IO=getchar()));
return f?-s:s;
}
const int N=1e5+10,P=1e9+7;
int n,m,k,q;
vector <int> fac[N];
ll Solve(int n,int m) {
ll res=0;
rep(i,1,n) {
int k=fac[i].size();
int x=min(i,m);
rep(S,0,(1<<k)-1) {
int cnt=0,t=1;
rep(j,0,k-1) if(S&(1<<j)) t*=fac[i][j],cnt^=1;
if(cnt) res-=x/t;
else res+=x/t;
}
}
//cout<<res<<endl;
return res;
}
int main(){
rep(i,2,N-1) if(!fac[i].size()) for(int j=i;j<N;j+=i) fac[j].push_back((int)i);
rep(kase,1,rd()){
n=rd(),m=rd();
ll ans=Solve(n,m)+Solve(m,n)-1;
printf("%lld\n",ans);
}
}
\[ \ \]
\[ \ \]
M: A Simple Chess
跳马？
首先我们讨论在空的\(n,m\)棋盘上跳的方案数
由于必须是前向跳，所以每次坐标都会增加，设横着跳\(a\)次，纵着跳\(b\)次
则有
\[2*a+b=n\]
\[2*b+a=m\]
解得方程的两根即可得到a，b的值，若不是整数则无解
然后其实方案数就是\(C(a+b,a)\)
容斥的过程依旧是dp转移，每次转移时会多经过一个障碍点，容斥系数取反
但是由于这题范围较大，组合数不好求，鉴于模数只有110119，所以可以用\(Lucas\)定理
即\(C(n,m) mod \ p =C(n \ mod \ p,m \ mod \ p)*(n/p,m/p) mod \ p\)
预处理后直接做
#include<bits/stdc++.h>
using namespace std;
#define reg register
typedef long long ll;
#define rep(i,a,b) for(int i=a,i##end=b;i<=i##end;++i)
#define drep(i,a,b) for(int i=a,i##end=b;i>=i##end;--i)
char IO;
ll rd(){
ll s=0,f=0;
while(!isdigit(IO=getchar())) if(IO=='-') f=1;
do s=(s<<1)+(s<<3)+(IO^'0');
while(isdigit(IO=getchar()));
return f?-s:s;
}
const int N=110,P=110119;
ll n,m;
int r;
struct NODE {
ll x,y;
bool operator < (const NODE __ )const{
return x<__.x;
}
bool operator == (const NODE __) const{
return x==__.x&&y==__.y;
}
}A[N];
int k;
ll po[P]={1},Inv[P]={1,1};
ll C(ll n,ll m){
if(n<0||m<0||n<m) return 0;
if(n<P&&m<P) return po[n]*Inv[m]%P*Inv[n-m]%P;
return C(n%P,m%P)*C(n/P,m/P)%P;
}
ll Calc(ll n,ll m) {
if((n+m-2)%3!=0) return 0;
if((2*n-m-1)%3!=0) return 0;
ll a=(n+m-2)/3,b=(2*n-m-1)/3;
return C(a,b);
}
//(i+j-2)/3
//(2*i-j-1)/3
ll dp[N];
int kase;
int main(){
rep(i,1,P-1) po[i]=po[i-1]*i%P;
rep(i,2,P-1) Inv[i]=(P-P/i)*Inv[P%i]%P;
rep(i,1,P-1) Inv[i]=Inv[i-1]*Inv[i]%P;
while(~scanf("%lld%lld%d",&n,&m,&r)) {
k=0;
A[++k]=(NODE){1ll,1ll};
int f=0;
rep(i,1,r) {
ll x=rd(),y=rd();
A[++k]=(NODE){x,y};
if((x==n&&y==m)||(x==1&&y==1)) f=1;
}
if(f) {
printf("Case #%d: 0\n",++kase);
continue;
}
if(n==1&&m==1) {
printf("Case #%d: 1\n",++kase);
continue;
}
A[++k]=(NODE){n,m};
sort(A+1,A+k+1);
k=unique(A+1,A+k+1)-A-1;
memset(dp,0,sizeof dp);
dp[1]=1;
rep(i,1,k) rep(j,i+1,k) if(A[j].x>A[i].x&&A[j].y>A[i].y) (dp[j]-=dp[i]*Calc(A[j].x-A[i].x+1,A[j].y-A[i].y+1)%P)%=P;
ll ans=dp[k];
ans=(P-ans)%P;
ans=(ans%P+P)%P;
printf("Case #%d: %lld\n",++kase,ans);
}
}
\[ \ \]
\[ \ \]
N: TrickGCD
看到这个题就想到对于整个序列的\(gcd\)的值容斥
如何快速求出某个值限制下的序列方案数呢?
直接前缀和，\(n \ln n\)枚举，快速幂即可，最后乘一个莫比乌斯系数
#include<cstdio>
#include<cctype>
#include<algorithm>
#include<iostream>
using namespace std;
#define reg register
typedef long long ll;
#define rep(i,a,b) for(reg int i=a,i##end=b;i<=i##end;++i)
#define drep(i,a,b) for(reg int i=a,i##end=b;i>=i##end;--i)
char IO;
int rd(){
int s=0,f=0;
while(!isdigit(IO=getchar())) if(IO=='-') f=1;
do s=(s<<1)+(s<<3)+(IO^'0');
while(isdigit(IO=getchar())) ;
return f?-s:s;
}
const int N=2e5+10,P=1e9+7;
int n;
int a[N];
inline ll qsm(reg ll x,reg int k) {
if(x==1||k<=0) return 1;
reg ll res=1;
for(;k;k>>=1,x=x*x%P) ((k&1)&&(res=res*x%P));
return res;
}
int pri[N],cp;
int notpri[N];
int mo[N];
int main(){
rep(i,2,N-1) {
if(!notpri[i]) pri[++cp]=i,mo[i]=1;
rep(j,1,cp){
int t=i*pri[j];
if(t>=N) break;
notpri[t]=1;
if(i%pri[j]==0) {
mo[t]=0;
break;
}
mo[t]=-mo[i];
}
}
int T=rd();
rep(kase,1,T) {
int Up=1e9,ma=0;
scanf("%d",&n);
rep(i,1,n) {
int x; scanf("%d",&x);
a[x]++;
Up=min(Up,x);
ma=max(ma,x);
}
rep(i,Up,N-1) a[i]+=a[i-1];
ll ans=0;
for(reg int i=2;i<=Up;++i) if(mo[i]) {
ll res=1;
rep(j,1,ma/i) {
res=res*qsm(j,a[(j+1)*i-1]-a[j*i-1])%P;
}
ans+=mo[i]*res;
}
rep(i,Up,N-1) a[i]=0;
ans=(ans%P+P)%P;
printf("Case #%d: %lld\n",kase,ans);
}
}\[ \ \]
\[ \ \]
O: Puzzled Elena
大水题
#include<cstdio>
#include<cctype>
#include<algorithm>
#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
#define reg register
typedef long long ll;
#define rep(i,a,b) for(reg int i=a,i##end=b;i<=i##end;++i)
#define drep(i,a,b) for(reg int i=a,i##end=b;i>=i##end;--i)
char IO;
int rd(){
int s=0,f=0;
while(!isdigit(IO=getchar())) if(IO=='-') f=1;
do s=(s<<1)+(s<<3)+(IO^'0');
while(isdigit(IO=getchar())) ;
return f?-s:s;
}
const int N=1e5+10,P=1e9+7;
int n;
struct Edge{
int to,nxt;
}e[N<<1];
int head[N],ecnt;
void AddEdge(int u,int v){
e[++ecnt]=(Edge){v,head[u]};
head[u]=ecnt;
}
vector <int> fac[N];
int a[N],ans[N];
int c[N];
void dfs(int u,int f) {
int n=fac[a[u]].size();
ans[u]=0;
rep(S,0,(1<<n)-1) {
int t=1,cnt=0;
rep(i,0,n-1) if(S&(1<<i)) cnt^=1,t*=fac[a[u]][i];
if(cnt) ans[u]+=c[t];
else ans[u]-=c[t];
}
rep(S,0,(1<<n)-1) {
int t=1;
rep(i,0,n-1) if(S&(1<<i)) t*=fac[a[u]][i];
c[t]++;
}
for(int i=head[u];i;i=e[i].nxt) {
int v=e[i].to;
if(v==f) continue;
dfs(v,u);
}
rep(S,0,(1<<n)-1) {
int t=1,cnt=0;
rep(i,0,n-1) if(S&(1<<i)) cnt^=1,t*=fac[a[u]][i];
if(cnt) ans[u]-=c[t];
else ans[u]+=c[t];
}
}
int kase;
int main(){
rep(i,2,N-1) if(!fac[i].size()) for(int j=i;j<N;j+=i) fac[j].push_back((int)i);
while(~scanf("%d",&n)) {
memset(c,0,sizeof c);memset(head,0,sizeof head);ecnt=0;
rep(i,2,n) {
int u=rd(),v=rd();
AddEdge(u,v);
AddEdge(v,u);
}
rep(i,1,n) a[i]=rd();
dfs(1,0);
printf("Case #%d:",++kase);
rep(i,1,n) printf(" %d",ans[i]);
puts("");
}
}\[ \ \]
\[ \ \]
P: Just Random
\(O(1)\) 的题为甚么在最后一题
对于两个数\(n,m(n \leq m)\),它们累和为\(x\)的方案数其实是有一定规律的
当\(x\leq n\)时，方案数为\(x+1\)
当\(n\leq x \leq m\)时，方案数为\(n+1\)
当\(m\leq x\)时，方案数为\(max\{0,n+m-x+1\}\)
然后就ojbk了
#include<cstdio>
#include<cctype>
#include<algorithm>
#include<iostream>
#include<cstring>
using namespace std;
#define reg register
typedef long long ll;
#define rep(i,a,b) for(reg int i=a,i##end=b;i<=i##end;++i)
#define drep(i,a,b) for(reg int i=a,i##end=b;i>=i##end;--i)
char IO;
int rd(){
int s=0,f=0;
while(!isdigit(IO=getchar())) if(IO=='-') f=1;
do s=(s<<1)+(s<<3)+(IO^'0');
while(isdigit(IO=getchar())) ;
return f?-s:s;
}
const int N=1e5+10;
ll a,b,c,d;
ll p,m;
ll Solve(ll a,ll b) {
if(a<0||b<0) return 0;
if(a>b) swap(a,b);
ll ans=0,t;
if(a>=m) {
t=1ll*(a-m)/p*p+m;
ans+=1ll*(m+t+2)*((t-m)/p+1)/2;
}
t=0;
if(b>=m) t=(b-m)/p+1;
if(a>=m) t-=(a-m)/p+1;
ans+=t*(a+1);
if(b>=m) {
t=1ll*(b-m)/p*p+m;
ans-=1ll*(2*a+2*b-m-t+2)*((t-m)/p+1)/2;
}
if(a+b>=m) {
t=1ll*(a+b-m)/p*p+m;
ans+=1ll*(2*a+2*b-m-t+2)*((t-m)/p+1)/2;
}
return ans;
}
ll gcd(ll a,ll b){ return b==0?a:gcd(b,a%b); }
int main(){
int cnt=0;
rep(i,0,0) rep(j,0,5) if((i+j)%3==2) cnt++;
rep(kase,1,rd()) {
a=rd(),b=rd(),c=rd(),d=rd(),p=rd(),m=rd();
ll ans=Solve(b,d)-Solve(a-1,d)-Solve(b,c-1)+Solve(a-1,c-1);
printf("Case #%d: ",kase);
if(!ans) {
puts("0/1");
continue;
}
ll t=1ll*(b-a+1)*(d-c+1);
ll g=gcd(t,ans);
ans/=g,t/=g;
printf("%lld/%lld\n",ans,t);
}
}