玲珑杯 ACM Round #12

A

=w=

B

占坑

C

题意：有长度为n的序列A和长度为n的序列W，以及一个G，对于Ui,1<=Ui<=Wi，求Σgcd(Ai,Ui)=G的方案数，n<=1e3,Ai<=1e5,Wi<=1e5,G<=1e3

分析：递推

　　　f(i,j)表示前i位，当前和为j的方案数

　　　f(i,j)=Σf(i-1,j-gcd(Ai,k))

　　　这样直接搞是会TLE

　　　注意到我们如果对于一个Ai能预处理求出gcd(Ai,k)的所有种类和个数，那么时间就允许了

　　　考虑Ai、Wi，首先筛出Ai的所有因子，然后use[x]表示gcd为x出现了几次，这个可以根据容斥直接暴力得出

D

占坑

E

题意：有一个n个节点的树(n<=1e5)，每个节点都有颜色，每种颜色最多有20个点。一条可行路径上的点所有颜色都不同，求这样可行路径的条数。

分析：dfs序+线段树+扫描线

　　　注意每种颜色最多有20个点

　　　首先求出dfs序

　　　那么可以枚举两两相同颜色的点，考虑有多少条路径存在这两个点

　　　很明显这是一个容斥问题，但这容斥不好求

　　　有一个很神奇的idea，就是通过dfs序，可以知道这些路径的起点和终点都是dfs序对应的一段区间，可以映射到平面的一块矩形

　　　那么问题就是求这些矩形的面积并！

　　　注意这里其实是求点矩阵的并，可以不用乘上两条边的距离，直接按x方向求出当前y方向的有多少个位置点的覆盖数>=1

　　　至于这个用线段树维护，维护mi[k]和num[k]表示最小值和与最小值相同的位置数量

　　　注意此题刚开始遍历图要写非递归，不然要爆栈

 #include<cstring>
 #include<vector>
 #include<cstdio>
 #include<algorithm>
 #include<stack>
 using namespace std;
 const int maxn=1e5,inf=1e9;
 int n,q,cnt=,t=,MAX=;
 int deep[maxn+],fa[maxn+][],head[maxn+];
 int L[maxn+],R[maxn+];
 int mi[maxn*+],lazy[maxn*+],num[maxn*+];
 vector<int> g[maxn+];
 vector<int> color[maxn+];
 stack<int> s;
 struct wjmzbmr
 {
     int y1,y2;
 };
 vector<wjmzbmr> inc[maxn+],dec[maxn+];
 void dfs(int k,int last)
 {
    /* L[k]=++t;
     deep[k]=deep[last]+1;
     fa[k][0]=last;
     for(int i=0;i<g[k].size();++i)
         if(g[k][i]!=last) dfs(g[k][i],k);
     R[k]=t;*/
     while(!s.empty()) s.pop();
     memset(head,,sizeof(head));//head[i]表示第i个点当前遍历到了第几个相邻点
     s.push();
     s.push();
     while(s.size()>)
     {
         int k=s.top();
         s.pop();
         int last=s.top();
         s.push(k);
         if(!head[k])
         {
             L[k]=++t;
             deep[k]=deep[last]+;
             fa[k][]=last;
         }
         if(head[k]<g[k].size())
             if(g[k][head[k]]==last) ++head[k];
         if(head[k]==g[k].size())
         {
             R[k]=t;
             s.pop();
         }
         else
             s.push(g[k][head[k]++]);
     }
 }
 int lca(int x,int y)
 {
     if(deep[x]<deep[y]) swap(x,y);
     int d=deep[x]-deep[y];
     for(int i=;i>=;i--)
        if((<<i)&d) x=fa[x][i];
     for(int i=;i>=;i--)
         if(fa[x][i]!=fa[y][i])
         {
             x=fa[x][i];
             y=fa[y][i];
         }
     if(x==y)return x;else return fa[x][];
 }
 int low(int u,int v)
 {
     int d=deep[v]-deep[u]-;
     for(int i=;i>=;i--)
        if((<<i)&d) v=fa[v][i];
     return v;
 }
 void insert(int x1,int x2,int y1,int y2)
 {
     if(x1>x2||y1>y2) return;
     //printf("%d %d %d %d\n",x1,x2,y1,y2);
     inc[x1].push_back({y1,y2});
     dec[x2+].push_back({y1,y2});
 }
 void build(int k,int l,int r)
 {
     if(l>r) return;
     if(l==r)
     {
         num[k]=;
         return;
     }
     num[k]=r-l+;
     int mid=(l+r)>>;
     build(k+k,l,mid);
     build(k+k+,mid+,r);
 }
 void pushdown(int k)
 {
     int l=k+k,r=k+k+;
     lazy[l]+=lazy[k],mi[l]+=lazy[k];
     lazy[r]+=lazy[k],mi[r]+=lazy[k];
     lazy[k]=;
 }
 void update(int k)
 {
     int l=k+k,r=k+k+;
     mi[k]=min(mi[r],mi[l]);
     num[k]=;
     if(mi[l]==mi[k]) num[k]+=num[l];
     if(mi[r]==mi[k]) num[k]+=num[r];
 }
 void add(int k,int l,int r,int x,int y,int num)
 {
     if(l>r||r<x||l>y) return;
     if(x<=l&&r<=y)
     {
         lazy[k]+=num;
         mi[k]+=num;
         return;
     }
     if(l==r) return;
     int mid=(l+r)>>;
     pushdown(k);
     add(k+k,l,mid,x,y,num);
     add(k+k+,mid+,r,x,y,num);
     update(k);
 }
 int query()
 {
     if(mi[]) return ;else return num[];
 }
 int main()
 {
     /*int size = 256 << 20; // 256MB
     char *p = (char*)malloc(size) + size;
     __asm__("movl %0, %%esp\n" :: "r"(p));*/
     freopen("ce.in","r",stdin);
     //freopen("ce.out","w",stdout);
     scanf("%d",&n);
    // printf("ok");
     for(int i=;i<n;i++)
     {
         int u,v;
         scanf("%d%d",&u,&v);
         g[u].push_back(v);
         g[v].push_back(u);
     }
     for(int i=;i<=n;++i)
     {
         int x;
         scanf("%d",&x);
         color[x].push_back(i);
         cnt=max(cnt,x);
     }
     dfs(,);
     for(int k=;k<=;++k)
         for(int i=;i<=n;++i)
             fa[i][k]=fa[fa[i][k-]][k-];
     for(int c=;c<=cnt;++c)
     {
         for(int i=;i<color[c].size();++i)
             for(int j=i+;j<color[c].size();++j)
             {
                 int u=color[c][i],v=color[c][j];
                 if(deep[u]>deep[v]) swap(u,v);
                 if(lca(u,v)!=u) insert(L[u],R[u],L[v],R[v]),insert(L[v],R[v],L[u],R[u]);
                 else
                 {
                     int x=low(u,v);
                     insert(,L[x]-,L[v],R[v]);
                     insert(R[x]+,n,L[v],R[v]);
                     insert(L[v],R[v],,L[x]-);
                     insert(L[v],R[v],R[x]+,n);
                 }
             }
     }
     build(,,n);
     long long ans=;
     for(int i=;i<=n;++i)
     {
         for(int j=;j<inc[i].size();++j) add(,,n,inc[i][j].y1,inc[i][j].y2,);
         for(int j=;j<dec[i].size();++j) add(,,n,dec[i][j].y1,dec[i][j].y2,-);
         ans+=1LL*query();
     }
     printf("%lld\n",(ans-n)/);
     return ;
 }