2. 程式人生 > >【點分治】的學習筆記和眾多例題

【點分治】的學習筆記和眾多例題

阿新 • • 發佈：2019-02-06

【前言】

　　最近一段時間變成了通過題目學習演算法，似乎整個人都亂套了（反思ing）

　　不過還好，現在又調整為了學演算法後做題。（唉，最近一段時間有點急躁，要記住萬事不能速成啊）

【正題】點分治

　　一句話：點分治主要用於樹上路徑點權統計問題。

一、【具體流程】

1，選取一個點，將無根樹變成有根樹
　為了使每次的處理最優，我們通常要選取樹的重心。
　何為“重心”，就是要保證與此點連線的子樹的節點數最大值最小，可以防止被卡。
　重心求法：
　　１。dfs一次，算出以每個點為根的子樹大小。
　　２。記錄以每個節點為根的最大子樹大小
　　３。判斷：如果以當前節點為根更優，就更新當前根。

void getroot(int v,int fa)
{
    son[v] = 1; f[v] = 0;//f記錄以v為根的最大子樹的大小 
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to]) {
            getroot(e[i].to,v);//遞迴更新 
            son[v] += son[e[i].to];
            f[v] = max(f[v],son[e[i].to]);//比較每個子樹 
        }
    f[v] = max
 
(f[v],sum-son[v]);//別忘了以v父節點為根的子樹 
    if(f[v] < f[root]) root = v;//更新當前根 
}

2、處理連通塊中通過根節點的路徑。
　　（注意，是通過根節點的路徑，所以後面要去掉同一子樹內部的路徑，即去重）
3、標記根節點（相當於處理後，將根節點從子樹中刪除）。
4、遞迴處理當前點為根的每棵子樹。

int solve(int v)
{
    vis[v] = 1;//標記 
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) {
            root = 0
 
;
            sum = son[e[i].to];
            getroot(e[i].to,v);
            solve(root);//遞迴處理下一個連通塊 
        }
}
int main()
{
    sum = f[0] = n;//初始化 
    root = 0;
    getroot(1,0);//找重心 
    solve(root);//點分治 
}

【註釋】：作者是用 son[] 來表示節點x為根的子樹大小，可能他人更多地是用size[]來表示，二者同意。

二、【POJ 1741 & BZOJ 1468 & BZOJ 3365】

給你一棵TREE,以及這棵樹上邊的距離.問有多少對點它們兩者間的距離小於等於K。
【題解】：
　　我們找到樹的重心，然後dfs，求出每個點到root的距離deep，然後對deep排序，掃描哪些點對是符合的。
　　但是，點分治要求處理的路徑是經過root，所以如果一條路徑是在同一個子樹之內的就不符合要求，所以還要對子樹dfs一下，然後去重。
　　接下來處理好root後，就可以處理其他連通塊了，即遞迴其子樹。
【程式碼】：

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

#define N 10010
#define inf 1e9+10
struct node{int to,c,next;}g[N*2];
int head[N],m;
int son[N],f[N];
bool vis[N];
int d[N],deep[N];
int n,sum,root,k,ans;

void add_edge(int from,int to,int cost)
{
    g[++m].next = head[from];
    head[from] = m;
    g[m].to = to; g[m].c = cost;
}

void getroot(int v,int fa)
{
    son[v] = 1; f[v] = 0;
    for(int i = head[v];i;i=g[i].next)
        if(g[i].to != fa && !vis[g[i].to])
        {
            getroot(g[i].to,v);
            son[v] += son[g[i].to];
            f[v] = max(f[v],son[g[i].to]);
        }
    f[v] = max(f[v],sum - son[v]);
    if(f[v] < f[root]) root = v;
}

void getdeep(int v,int fa)
{
    deep[++deep[0]] = d[v];
    for(int i = head[v];i;i=g[i].next)
        if(g[i].to != fa && !vis[g[i].to])
        {
            d[g[i].to] = d[v] + g[i].c;
            getdeep(g[i].to,v);
        }
}

int cal(int v,int cost)
{
    d[v] = cost; deep[0] = 0;
    getdeep(v,0);
    sort(deep+1,deep+deep[0]+1);
    int l = 1,r = deep[0],sum = 0;
    while(l < r) {
        if(deep[l]+deep[r] <= k) {
            sum += r-l;
            l++;
        } else r--;
    }
    return sum;
}

void solve(int v)
{
    ans += cal(v,0);
    vis[v] = 1;
    for(int i = head[v];i;i=g[i].next)
        if(!vis[g[i].to])
        {
            ans -= cal(g[i].to,g[i].c);
            sum = son[g[i].to];
            root = 0;
            getroot(g[i].to,0);
            solve(root);
        }
}

int main()
{
    int u,v,w;
    while(scanf("%d%d",&n,&k) && n && k)
    {
        ans = root = m = 0;
        memset(vis,0,sizeof(vis));
        memset(head,0,sizeof(head));
        for(int i = 1;i < n;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
        f[0] = inf;
        sum = n;
        getroot(1,0);
        solve(root);
        printf("%d\n",ans);
    }
    return 0;
}

【補】：若是距離等於k，cal可以改成：

int cal(int v,int cost)
{
    d[v] = cost; deep[0] = 0;
    getdeep(v,0);
    sort(deep+1,deep+deep[0]+1);
    int r = deep[0],res = 0;
    for(int l = 1;l < r;l++)
        while(deep[l]+deep[r] >= k) {
            if(deep[l] + deep[r] == k) res++;
            r--;
        }
    return res;
}

三、【BZOJ 2152】

由爸爸在紙上畫n個“點”，並用n-1條“邊”把這n個“點”恰好連通（其實這就是一棵樹）。並且每條“邊”上都有一個數。接下來由聰聰和可可分別隨即選一個點（當然他們選點時是看不到這棵樹的），如果兩個點之間所有邊上數的和加起來恰好是3的倍數，則判聰聰贏，否則可可贏。聰聰非常愛思考問題，在每次遊戲後都會仔細研究這棵樹，希望知道對於這張圖自己的獲勝概率是多少。現請你幫忙求出這個值以驗證聰聰的答案是否正確。
【題解】：
　　感覺這道更好處理，不用快排，也不用去重。我們對於當前的樹，直接找到重心V，然後從V出發，搜尋與V相鄰的點，計算邊長的餘數分別是是0,1,2的情況數，用t[0],t[1],t[2]分別表示。
　　顯然答案就是 t[1]*t[2]*2+t[0]*t[0]。
【程式碼】：

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

#define N 20010
struct node{int to,c,next;}e[N*2];
int head[N],m;
int ans,root,t[4],d[N],son[N],f[N],sum;
bool vis[N];

void add_edge(int from,int to,int cost)
{
    e[++m].next = head[from];
    head[from] = m;
    e[m].to = to; e[m].c = cost;
}

void getroot(int v,int fa)
{
    son[v] = 1;f[v] = 0;
    for(int i = head[v];i;i = e[i].next)
        if(!vis[e[i].to] && e[i].to != fa)
        {
            getroot(e[i].to,v);
            son[v] += son[e[i].to];
            f[v] = max(f[v],son[e[i].to]);
        }
    f[v] = max(f[v],sum-son[v]);
    if(f[v] < f[root]) root = v;
}

void getdeep(int v,int fa)
{
    t[d[v]]++;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to] && e[i].to != fa)
        {
            d[e[i].to] = (d[v] + e[i].c)%3;
            getdeep(e[i].to,v);
        }
}

int cal(int v,int w)
{
    t[0] = t[1] = t[2] = 0;
    d[v] = w;
    getdeep(v,0);
    return t[1]*t[2]*2+t[0]*t[0];
}

void solve(int v)
{
    ans += cal(v,0); vis[v] = 1;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to])
        {
            ans -= cal(e[i].to,e[i].c);
            root = 0; sum = son[e[i].to];
            getroot(e[i].to,0);
            solve(root);
        }
}

inline int gcd(int a,int b){return b == 0 ? a : gcd(b,a%b);}
int main()
{
    int n,u,v,w;
    scanf("%d",&n);
    for(int i = 1;i < n;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        w %= 3;
        add_edge(u,v,w); add_edge(v,u,w);
    }
    sum = n;f[0] = n;
    root = ans = 0;
    getroot(1,0);
    solve(root);
    int x = gcd(ans,n*n);
    printf("%d/%d\n",ans/x,n*n/x);
    return 0;
}

先到這裡，我下去逛逛。未完待續……

好了，我又回來了

四、【BZOJ 2599】

給一棵樹,每條邊有權.求一條簡單路徑,權值和等於K,且邊的數量最小.N <= 200000, K <= 1000000
【題解】：
參考黃學長的題解啊。
　　開一個100W的陣列t,t[i]表示權值為i的路徑最少邊數
　　找到重心分成若干子樹後， 得出一棵子樹的所有點到根的權值和x，到根a條邊，用t[k-x]+a更新答案，全部查詢完後，再用所有a更新t[x]，這樣可以保證不出現點分治中的不合法情況。
　　把一棵樹的所有子樹搞完後再遍歷所有子樹恢復T陣列，如果用memset應該會比較慢
　　
看的稀裡糊塗的，但還是好像懂了一點啊。
　　d陣列 表示已經有幾條邊
　　dis陣列 表示子樹中的點到根的距離
　　add函式用於更新和初始化（好像有這個功能吧）
【程式碼】：

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

#define N 200010
#define inf 1000000000
struct node{int to,c,next;}e[N*2];
int head[N],m,k;
bool vis[N];
int t[1000010];
int sum,f[N],dis[N],d[N],son[N],root,ans;

void add_edge(int from,int to,int cost)
{
    e[++m].next = head[from];
    head[from] = m;
    e[m].to = to;e[m].c = cost;
}

void getroot(int v,int fa)
{
    son[v] = 1;f[v] = 0;
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to]) {
            getroot(e[i].to,v);
            son[v] += son[e[i].to];
            f[v] = max(f[v],son[e[i].to]);
        }
    f[v] = max(f[v],sum-son[v]);
    if(f[v] < f[root]) root = v;
}

void cal(int v,int fa)
{
    if(dis[v] <= k) ans = min(ans,d[v]+t[k-dis[v]]);
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to]) {
            d[e[i].to] = d[v] + 1;
            dis[e[i].to] = dis[v] + e[i].c;
            cal(e[i].to,v);
        }
}

void add(int v,int fa,bool flag)
{
    if(dis[v] <= k) {
        if(flag) t[dis[v]] = min(t[dis[v]],d[v]);
        else t[dis[v]] = inf;
    }
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to])
            add(e[i].to,v,flag);
}

void solve(int v)
{
    vis[v] = 1;t[0] = 0;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) {
            d[e[i].to] = 1;
            dis[e[i].to] = e[i].c;
            cal(e[i].to,0);
            add(e[i].to,0,1);
        }
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) add(e[i].to,0,0);
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) {
            root = 0;
            sum = son[e[i].to];
            getroot(e[i].to,0);
            solve(root);
        }
}

int main()
{
    int n,u,v,w;;
    scanf("%d%d",&n,&k);
    for(int i = 1;i <= k;i++) t[i] = n;
    for(int i = 1;i < n;i++) {
        scanf("%d%d%d",&u,&v,&w);
        u++; v++;
        add_edge(u,v,w); add_edge(v,u,w);
    }
    ans = sum = f[0] = n;
    root = 0;
    getroot(1,0);
    solve(root);
    if(ans != n) printf("%d\n",ans);
        else puts("-1");
    return 0;
}

啊！
今天對點分治的學習差不多就到這裡了。
筆記結束，開始刷水題玩嘍。

補：

五、【BZOJ 1316】

一棵n個點的帶權有根樹，有p個詢問，每次詢問樹中是否存在一條長度為Len的路徑，如果是，輸出Yes否輸出No.
【題解】：
　　運用點分治統計點到重心的距離，再兩次二分查詢距離，判斷有多少條路徑長度為k（這樣為了方便去重）。
　　聽說點分治的常數比較大，所以將所有詢問在一次點分治中一起做。
【程式碼】：

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

#define N 10010
struct node{int to,w,next;}e[N*2];
int head[N],m,p;
int q[110],f[N],son[N],sum,root,d[N],deep[N];
bool vis[N];

void add_edge(int from,int to,int cost)
{
    e[++m].next = head[from];
    head[from] =m;
    e[m].w = cost; e[m].to = to;
}

void getroot(int v,int fa)
{
    son[v] = 1;f[v] = 0;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to] && e[i].to != fa) {
            getroot(e[i].to,v);
            son[v] += son[e[i].to];
            f[v] = max(f[v],son[e[i].to]);
        }
    f[v] = max(f[v],sum-son[v]);
    if(f[v] < f[root]) root = v;
}

void getdeep(int v,int fa)
{
    deep[++deep[0]] = d[v];
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to]) {
            d[e[i].to] = d[v] + e[i].w;
            getdeep(e[i].to,v);
        }
}

int findl(int L,int R,int k)
{
    int ans = 0;
    while(L <= R){
        int mid = (L+R)>>1;
        if(deep[mid] == k){ans = mid;R = mid-1;}
        else if(deep[mid] < k) L = mid + 1;
                else R = mid - 1;
    }
    return ans;
}

int findr(int L,int R,int k)
{
    int ans = -1;
    while(L <= R) {
        int mid = (L+R)>>1;
        if(deep[mid] == k){ans = mid;L = mid+1;}
        else if(deep[mid] < k) L = mid+1;
                else R = mid - 1;
    }
    return ans;
}

int cal(int v,int now,int k)
{
    d[v] = now; deep[0] = 0;
    getdeep(v,0);
    sort(deep+1,deep+deep[0]+1);
    int t = 0;
    for(int i = 1;i <= deep[0];i++) {
        if(deep[i] + deep[i] > k) break;
        int l = findl(i,deep[0],k-deep[i]);
        int r = findr(i,deep[0],k-deep[i]);
        t += r-l+1;
    }
    return t;
}

int ans[110];
void solve(int v)
{
    for(int i = 1;i <= p;i++) ans[i] += cal(v,0,q[i]);
    vis[v] = 1;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) {
            for(int j = 1;j <= p;j++)
                ans[j] -= cal(e[i].to,e[i].w,q[j]);
            sum = son[e[i].to];
            root = 0;
            getroot(e[i].to,0);
            solve(root);
        }
}

int main()
{
    int n,u,v,w;
    scanf("%d%d",&n,&p);
    m = 0;
    for(int i = 1;i < n;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        add_edge(u,v,w); add_edge(v,u,w);
    }
    for(int i = 1;i <= p;i++) scanf("%d",&q[i]);
    sum = f[0] = n;
    root = 0;
    getroot(1,0);
    solve(root);
    for(int i = 1;i <= p;i++)
        if(ans[i]) puts("Yes"); else puts("No");
    return 0;
}

吾 點分治 之道路大概結束於此。

PS：4月3日，第四次更新。

相關推薦

【點分治】的學習筆記和眾多例題

【前言】 　　最近一段時間變成了通過題目學習演算法，似乎整個人都亂套了（反思ing） 　　不過還好，現在又調整為了學演算法後做題。（唉，最近一段時間有點急躁，要記住萬事不能速成啊） 【正題】點分治 　　一句話：點分治主要用於樹上路徑點權統計問題。

【點擊模型學習筆記】Inferring clickthrough rates on ads from click behavior on search results_wsdm2011

rac 嵌入 權重 tps peak ref 細節 文章 搜索結果 概要： 看這篇文章的初衷，是這篇文章回答了問題“在一個query的結果其中，給出

【Unity 3D】學習筆記三十：遊戲元素——遊戲地形

nbsp 3d遊戲 strong 直觀 分辨率 == 摩擦力 fill 世界 遊戲地形 在遊戲的世界中，必然會有非常多豐富多彩的遊戲元素融合當中。它們種類繁多。作用也不大同樣。一般對於遊戲元素可分為兩種：經經常使用。不經經常使用。經常使用的元素是遊戲中比較重要的元素。一

【Unity 3D】學習筆記四十二：粒子特效

空間 獲得 material package 一個 log 創建 spa mpi 粒子特效 粒子特效的原理是將若幹粒子無規則的組合在一起。來模擬火焰，爆炸。水滴，霧氣等效果。要使用粒子特效首先要創建，在hierarchy視圖中點擊create——particle s

BZOJ3697 采藥人的路徑 【點分治】

math ring 有一個 esp 一個數 iostream 數據 整數 不同 題目 采藥人的藥田是一個樹狀結構，每條路徑上都種植著同種藥材。 采藥人以自己對藥材獨到的見解，對每種藥材進行了分類。大致分為兩類，一種是陰性的，一種是陽性的。 采藥人每天都要進行采藥活動。他選擇

1468. Tree【點分治】

clas def 分治 AI struct using tput out led Description 給你一棵TREE,以及這棵樹上邊的距離.問有多少對點它們兩者間的距離小於等於K Input N（n<=40000） 接下來n-1行邊描述管道，按照題目中寫的

UOJ276 [清華集訓2016] 汽水 【二分答案】【點分治】【樹狀數組】

答案 很多 right turn lower pair first upper sizeof 題目分析： 這種亂七八糟的題目一看就是點分治，答案有單調性，所以還可以二分答案。 我們每次二分的時候考慮答案會不會大於等於某個值，註意到系數$k$是無意義的，因為我們可以通過轉化使

【C語言】學習筆記3——字符串

store 寫代碼 inf 變量類型 density scanf() 想要 限定符 tor 1. 字符串（charcacter string）是一個或多個字符的序列 2. C語言沒有專門用於存儲字符串的變量類型。字符串都被存儲在char類型的數組種。 3. 數組由連續的

【C語言】學習筆記7——指針與多維數組

一個 聲明 %d mage 分享圖片 技術分享 pan 最好 include 1. 聲明一個指向多維數組的指針 int (* pz) [2]; //pz指向一個內涵兩個int類型元素的數組 int * pax[2]; //pax 是一個內含兩個指針元素的

【Unity 3D】學習筆記四十三：布料

布料 布料是特殊的元件，它可以變化成任意形狀，比如說：隨風飄的旗子，窗簾等 建立布料的方法有兩種：建立布料物件，在遊戲物件中添加布料元件。前者通過hierarchy檢視中選擇create——cloth即可，建立後，系統會自動將互動布料元件（interactive clot

【Unity 3D】學習筆記三十四：遊戲元素——常用編輯器元件

常用編輯器元件 unity的特色之一就是編輯器視覺化，很多常用的功能都可以在編輯器中完成。常用的編輯器可分為兩種：原有元件和拓展元件。原有元件是編輯器原生的一些功能，拓展元件是編輯器智商通過指令碼拓展的新功能。 攝像機 攝像機是unity最為核心元件之一，遊戲介面中顯示的

BZOJ3672: [Noi2014]購票【CDQ分治】【點分治】【斜率優化DP】

Description 今年夏天，NOI在SZ市迎來了她30週歲的生日。來自全國 n 個城市的OIer們都會從各地出發，到SZ市參加這次盛會。 全國的城市構成了一棵以SZ市為根的有根樹，每個城市與它的父親用道路連線。為了方便起見，我們將全國的 n 個城市用 1 到 n 的整數編號。其中SZ市的編號為 1。

【點分治】【資料結構】Codeforces1019E Raining season

題意： 給出一棵樹，每條邊的距離都是一個一次函式，給出斜率k和截距m。（y=k*x+m） 現在求當x=0,1,2，……，t-1時，整個圖中最遠點的距離。 分析： 這題一股濃郁的OI氣息啊。。。（思路簡單實現複雜的資料結構題） 首先，如果不考慮那

[bzoj3648]寢室管理【環套樹】【點分治】

T64有一個好朋友，叫T128。T128是寄宿生，並且最近被老師叫過去當宿管了。宿管可不是一件很好做的工作，碰巧T128有一個工作上的問題想請T64幫忙解決。T128的寢室條件不是很好，所以沒有很多錢來裝修。禮間寢室僅由n-1條雙向道路連線，而且任意兩間寢室之間都可以互達。最近，T128被要求對一條路徑上的所

【Apache Shiro】學習筆記——Authentication基礎

從Authentication一步步學習。  先從程式碼開始，執行後再慢慢研究。 以下是我新增的dependecies： <!-- shiro --> <dependency> <groupId>org.apache.shir

【TensorFlow-windows】學習筆記六——變分自編碼器

前言 對理論沒興趣的直接看程式碼吧，理論一堆，而且還有點複雜，我自己的描述也不一定準確，但是程式碼就兩三句話搞定了。 國際慣例，參考博文 理論 基礎知識 似然函式(引自百度百科) 似然函式是關於統計模型中的引數的函式，

【Unity 3D】學習筆記四十四：路徑渲染

路徑渲染 路徑渲染屬於特效渲染元件，用於跟隨運動中的遊戲物件。首先在hierarchy檢視中，建立一個球體。然後在選單導航欄中選擇component——effects——trial renderer即可將路徑渲染元件新增至該球體物件中。 cast shadows：顯示陰

【點分治】【FFT】2019雅禮集訓 bracket

題目： 分析： 太過套路這裡就簡單說說 顯然，當詢問數k很小時，就是個裸的點分治題。 現在k變大了。那就FFT算貢獻。 #include<cstdio> #include<cstring> #include<cmath> #in

資料庫【mysql篇】學習筆記

      Windows服務 -- 啟動MySQL    net start mysql-- 建立Windows服務    sc create mysql binPath= mysqld_bin_path(注意：等號

【theano-windows】學習筆記十六——深度信念網路DBN

前言 前面學習了受限玻爾茲曼機(RBM)的理論和搭建方法, 如果稍微瞭解過的人, 肯定知道利用RBM可以堆疊構成深度信念網路(deep belief network, DBN)和深度玻爾茲曼機(deep Boltzmann machine), 這裡就先學習一下