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