洛谷 1600 [NOIP2016] 天天愛跑步樹鏈剖分+桶（暴力+正解）

題目：
https://www.luogu.org/problemnew/show/1600

記得去年我只寫了15分，還打錯了freopen……；

部分分很良心；

1~5：

暴力lca，暴力統計;
複雜度 : O (n ^ 2);

6~8：

這一部分分已經出賣了正解；
肯定有許多大牛恍然大悟(~~當然，沒有我這個垃圾~~)；

我們發現對於每一名觀察員v，他觀察到的玩家i滿足：
1. 從左向右：v - i = w[i]；從右向左 : v + i = w[i] ;
2. 存在從i到v或v後面(前面)的點的路線；

通過移項發現，對於每一個w[i] + i 只與i本身有關，而且這是一個定值。

記點i可以做出貢獻的點集爲V；

當i作爲起點時，將V中符合第2條的點答案++即可；

複雜度 : O( n + m );

9~12

Si = 1的情況；
我們可以發現，當且僅當deep[v]=w[v]時，v點的觀察員可以看到玩家；

法一：統計v的子樹中有多少終點，終點個數即爲v的答案；

法二：樹上差分，v被經過的次數就是v的答案；

13~16：

Ti = 1 的情況；

當起點i可以對v做貢獻時;
deep[i] = deep[v] + w[v];
當且僅當i在v的子樹中;

給每個起點打一個標記,然後統計v的子樹中i的個數；

統計i時考慮用差分的思想；
令deep[*i]爲訪問v的子樹之前的深度i的個數，deep[i]爲訪問完v的子樹後的深度i的個數；
則v子樹中deep[i]深度的節點個數爲deep[i] - deep[*i];

100%數據：

大方向：對於一個節點來說，對他有貢獻的結點是一定的，也是確定的；
所以我們只需要統計對於某個節點有貢獻的節點數就可以了(~~說的輕巧~~)；

考慮如何統計;
ps : 自己先拿出一張紙，畫上一棵樹，然後標上編號；

因爲有上有下，不好直接統計，所以考慮拆路線！！！

將S到T的路線拆成S->lca和lca->T;

D爲記錄答案的桶；

S->lca:
若對i有貢獻：

1.deep[s] - deep[i] = w[i];
移項：deep[s] = deep[i] + w[i];
2.滿足第2條;
3.在i的子樹中;

由於deep[i] + w[i] 是個定值;
所以將 deep[i] + w[i] 映射爲可以對i做貢獻的值(不準確的定義，但可以這麼理解)；
即D[deep[i] + w[i]] 的差值爲i的答案（差值的定義詳見終點爲1的做法）；

lca->T:
記L爲S->T的路線長度;
若對k有貢獻:
L - w[k] = deep[T] - deep[k];
移項：L - deep[T] = w[k] - deep[k];

同理;
可以將L - deep[T] 映射爲可以對k做貢獻的值；
需要注意的是需要加一個大數，以防止負數下標；

但如果存在路線的起點可以對v做貢獻，但是不滿足第2條怎麼辦？

此時這條路線的起點，lca，終點必然都在v的子樹中；

所以可以用vector記以一個點爲lca的路線的編號；
在回溯時，將不會對”祖先”做貢獻，又存在於D中的點減去；

由於拆路線，如果路線對lca有貢獻，那lca會被計算了兩次，所以此時
需要將lca的次數減一；

80分暴力

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;

const int MAXN=600010;
int n,m,tot,tim;
int fst[MAXN],nxt[MAXN],cdis[MAXN],cnt[MAXN],csum[MAXN];
int deep[MAXN],fa[MAXN],top[MAXN],son[MAXN],siz[MAXN];
int dfn[MAXN],tmp[MAXN];//起點爲1; 
int D[MAXN],Mark[MAXN];//終點爲1； 
vector<int>V[MAXN],G[MAXN];//一條鏈;
struct hh {int from,to;}ma[MAXN];
struct sh {int from,to,lca;}ss[MAXN];

void build(int f,int t)
{
    ma[++tot]=(hh){f,t};
    nxt[tot]=fst[f];
    fst[f]=tot;
    return;
}

void dfs(int x,int f)
{
    siz[x]=1,fa[x]=f;
    deep[x]=deep[f]+1;
    dfn[++tim]=x;
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==f) continue;
        csum[v]=csum[x]+1;
        dfs(v,x),siz[x]+=siz[v];
        if(!son[x] || siz[son[x]]<siz[v]) son[x]=v;
    }
    return;
}

void rdfs(int x,int st)
{
    top[x]=st;
    if(!son[x]) return;
    rdfs(son[x],st);
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==fa[x] || v==son[x]) continue;
        rdfs(v,v);
    }
    return;
}

int get_lca(int x,int y)
{
    int fx=top[x],fy=top[y];
    while(fx!=fy)
    {
        if(deep[fx]<deep[fy]) swap(x,y),swap(fx,fy);
        x=fa[fx],fx=top[x];
    }
    return deep[x]>deep[y]?y:x;
}


void calc(int x,int y)//n^n;
{
    int sum=0,ccnt=0,lc=get_lca(x,y);
    int l=csum[x]+csum[y]-2*csum[lc];

    if(x==lc)//lca->y;
    {
        if(cdis[y]==l) cnt[y]++;
        while(y!=lc)
        {
            sum++,y=fa[y];
            if(cdis[y]==l-sum) cnt[y]++;
        }
        return;
    }
    else if(y==lc)//x->lca;
    {
        if(!cdis[x]) cnt[x]++;
        while(x!=lc)
        {
            sum++,x=fa[x];
            if(cdis[x]==sum) cnt[x]++;
        }
        return;
    }    
    else//x->lca,lca->y;
    {
        if(!cdis[x]) cnt[x]++;    
        while(x!=lc)//x->lca
        {
            x=fa[x],sum++;
            if(cdis[x]==sum) cnt[x]++;
        }

        if(cdis[y]==l) cnt[y]++;
        while(y!=lc) //lca->y;
        {
            y=fa[y],ccnt++;
            if(cdis[y]==l-ccnt) cnt[y]++;
        }
    }
    return;
}

void solve_lian()
{
    for(int i=1;i<=n;i++)
    {
        if(i-cdis[i]>=1)
            G[i-cdis[i]].push_back(i);//左->右;
        if(i+cdis[i]<=n)
            V[i+cdis[i]].push_back(i);//右->左; 
    }

    for(int i=1;i<=m;i++)
    {
        int x=ss[i].from,y=ss[i].to;
        if(x<y)//左到右; 
        {
            for(int j=0;j<G[x].size();j++)
            {
                int v=G[x][j];
                if(v<=y) cnt[v]++;
            }
        }
        else if(x>y)
        {
            for(int j=0;j<V[x].size();j++)
            {
                int v=V[x][j];
                if(v>=y) cnt[v]++;
            }
        }
    }
    for(int i=1;i<=n;i++) printf("%d ",cnt[i]);
    return;
}

void solve_sta()
{

    for(int i=1;i<=m;i++)
    {
        tmp[ss[i].from]++;
        tmp[ss[i].to]++;
        tmp[get_lca(ss[i].from,ss[i].to)]-=2;
    }

    for(int i=n;i>=1;i--) 
        tmp[fa[dfn[i]]]+=tmp[dfn[i]];//差分記錄路徑;

    tmp[1]=m;//注意;

    for(int i=1;i<=n;i++)
        if(csum[i]==cdis[i]) 
            cnt[i]+=tmp[i];

    for(int i=1;i<=n;i++) printf("%d ",cnt[i]);

    return;
}

void Dfs(int x,int f)
{
    int co=D[deep[x]+cdis[x]];
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==f) continue;
        D[deep[v]]+=Mark[v],Dfs(v,x);
        cnt[x]=D[deep[x]+cdis[x]]-co;
    }
    return;
}

void solve_end()
{
    memset(Mark,0,sizeof(Mark));
    for(int i=1;i<=m;i++)
        Mark[ss[i].from]++;
    Dfs(1,0);
    for(int i=1;i<=m;i++) if(!cdis[ss[i].from]) cnt[ss[i].from]++;
    for(int i=1;i<=n;i++) printf("%d ",cnt[i]);
    return;
}

void solve()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        build(x,y),build(y,x);
    }

    for(int i=1;i<=n;i++)
        scanf("%d",&cdis[i]);

    for(int i=1;i<=m;i++) scanf("%d%d",&ss[i].from,&ss[i].to);
    dfs(1,1),rdfs(1,1);

   if(n<=1000 && m<=1000)
    {
        for(int i=1;i<=m;i++)
            calc(ss[i].from,ss[i].to);
        for(int i=1;i<=n;i++) printf("%d ",cnt[i]);
    }

    if(n==99994 && m==99994) solve_lian();
    else if(n==99995 && m==99995) solve_sta();
    else if(n==99996 && m==99996) solve_end();
    return;
}

int main()
{
    solve();
    return 0;
}

100分正解：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<vector>
using namespace std;

const int MAXN=600000+55;
int fst[MAXN],nxt[MAXN],D[MAXN<<1],w[MAXN],deep[MAXN],fa[MAXN];
int son[MAXN],top[MAXN],size[MAXN],csum[MAXN],Mark[MAXN];
int siz[MAXN],cnt[MAXN];
struct hh {int from,to;}ma[MAXN];
struct sh{int from,to,len,lca;}mp[MAXN];
vector<int>G[MAXN],V[MAXN];
int n,tot,m;

inline int read()
{
    char c=getchar();
    int ss=0;//第一遍交全WA，後來發現是手讀打錯了，打錯了竟然還過了樣例…… 
    while(c<'0' || c>'9') c=getchar();
    while(c>='0' && c<='9') ss=ss*10+c-'0',c=getchar();
    return ss;
}


void build(int f,int t)
{
    ma[++tot]=(hh){f,t};
    nxt[tot]=fst[f],fst[f]=tot;
    return;
}
//------------------------------------------------------樹剖處理樹上信息; 
void dfs1(int x,int f)
{
    deep[x]=deep[f]+1,fa[x]=f,siz[x]=1;
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==f) continue;
        csum[v]=csum[x]+1,dfs1(v,x),siz[x]+=siz[v];
        if(!son[x] || siz[son[x]]<siz[v]) son[x]=v;
    }
    return;
}

void dfs2(int x,int st)
{
    top[x]=st;
    if(!son[x]) return;
    dfs2(son[x],st);
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==son[x] || v==fa[x]) continue;
        dfs2(v,v);
    }
    return;
}

int get_lca(int x,int y)
{
    int fx=top[x],fy=top[y];
    while(fx!=fy)
    {
        if(deep[fx]<deep[fy]) swap(x,y),swap(fx,fy);
        x=fa[fx],fx=top[x];
    }
    return deep[x]>deep[y]?y:x;
}
//--------------------------------------------------------
void Dfs(int x)
{
    int cc=D[deep[x]+w[x]],co=D[w[x]-deep[x]+MAXN];//用於後面計算差值； 
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==fa[x]) continue;
        Dfs(v);
    }
    D[deep[x]]+=Mark[x];//統計對祖先做的貢獻;
    for(int i=0;i<V[x].size();i++)
    {
        int v=V[x][i];//v爲x做終點時的路線編號 
        D[mp[v].len-deep[mp[v].to]+MAXN]++;//統計對祖先做的貢獻; 
    }

    cnt[x]+=D[deep[x]+w[x]]-cc + D[w[x]-deep[x]+MAXN]-co;
    for(int i=0;i<G[x].size();i++)
    {
        int v=G[x][i];//v爲x做lca時的路線編號; 
        D[deep[mp[v].from]]--,D[mp[v].len-deep[mp[v].to]+MAXN]--;//將不會做貢獻的點減去; 
    }
    return;
}

void solve()
{
    int x,y;
    n=read(),m=read();
    for(int i=1;i<n;i++)
        x=read(),y=read(),build(x,y),build(y,x);
    for(int i=1;i<=n;i++) w[i]=read();

    dfs1(1,0),dfs2(1,1);

    for(int i=1;i<=m;i++)
    {
        mp[i].from=read(),mp[i].to=read();
        mp[i].lca=get_lca(mp[i].from,mp[i].to);
        mp[i].len=csum[mp[i].from]+csum[mp[i].to]-2*csum[mp[i].lca];
        G[mp[i].lca].push_back(i),V[mp[i].to].push_back(i),Mark[mp[i].from]++;
        if(deep[mp[i].from]==deep[mp[i].lca]+w[mp[i].lca]) cnt[mp[i].lca]--;//提前將lca多計算的次數減去; 
    }

    Dfs(1);

    for(int i=1;i<=n;i++) printf("%d ",cnt[i]);
    return;
}

int main()
{
    solve();
    return 0;
}

洛谷 1600 [NOIP2016] 天天愛跑步樹鏈剖分+桶（暴力+正解）

1~5：

6~8：

9~12

13~16：

100%數據：

985 碩士程序員，空窗 4 個月沒有 Offer！

一文搞懂 Spring 循環依賴

賽博鬥地主——使用大語言模型扮演Agent智能體玩牌類遊戲。

VScode右鍵打開(添加到右鍵)

codevs 1704 [NOI2001] 食物鏈並查集

洛谷 1312 [NOIP2011] Mayan遊戲 dfs+模擬

考試 DP+平面幾何+搜索？

codevs 3311 [NOI2014] 起牀困難綜合症貪心

洛谷 1196 [NOIP2002] 銀河英雄傳說並查集

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

洛谷 1600 [NOIP2016] 天天愛跑步 樹鏈剖分+桶 （暴力+正解）

1~5：

6~8：

9~12

13~16：

100%數據：

洛谷 1600 [NOIP2016] 天天愛跑步樹鏈剖分+桶（暴力+正解）