[學習筆記]虛樹

阿新 • • 發佈：2018-11-15

模板：（樹剖$LCA$+建虛樹）

#include <bits/stdc++.h>
using namespace std;
const int maxn=100000+10;
int n,m,dp[maxn],vis[maxn],h[maxn],sta[maxn],Top;
int fir[maxn],head[maxn],to[maxn<<1],nxt[maxn<<1],tot,cnt;
int top[maxn],dep[maxn],id[maxn],siz[maxn],son[maxn],fa[maxn],tim;

struct node{
    int to,next;
}e[maxn<<1];

inline int read(){
    register int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return (f==1)?x:-x;
}
inline void add(int x,int y){
    e[++tot].to=y;
    e[tot].next=head[x];
    head[x]=tot;
}
inline void addedge(int x,int y){
    to[++cnt]=y;
    nxt[cnt]=fir[x];
    fir[x]=cnt;
}

void dfs1(int x,int f){
    siz[x]=1;fa[x]=f;
    dep[x]=dep[f]+1;
    int maxson=-1;
    for(int i=head[x],y;i;i=e[i].next){
        y=e[i].to;
        if(y==f) continue;
        dfs1(y,x);
        siz[x]+=siz[y];
        if(maxson<siz[y]){
            maxson=siz[y];
            son[x]=y;
        }
    }
}

void dfs2(int x,int topf){
    id[x]=++tim;
    top[x]=topf;
    if(son[x]) dfs2(son[x],topf);
    for(int i=head[x],y;i;i=e[i].next){
        y=e[i].to;
        if(y==fa[x]||y==son[x]) continue;
        dfs2(y,y);
    }
}

int LCA(int x,int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    return x;
}

bool cmp(int a,int b){
    return id[a]<id[b];
}

int main()
{
    n=read();
    int x,y,w,k,lca;
    for(int i=1;i<n;i++){
        x=read(),y=read();
        add(x,y);add(y,x);
    }
    dfs1(1,0);dfs2(1,1);
    m=read();
    for(int t=1;t<=m;t++){
        k=read();
        for(int i=1;i<=k;i++){
            h[i]=read();
            vis[h[i]]=1;
        }
        sort(h+1,h+k+1,cmp);
        cnt=0;sta[Top=1]=1;
        for(int i=1;i<=k;i++){
            lca=LCA(sta[Top],h[i]);
            while(dep[lca]<dep[sta[Top]]){
                if(dep[sta[Top-1]]<=dep[lca]){
                    addedge(lca,sta[Top--]);
                    if(sta[Top]!=lca) sta[++Top]=lca;
                    break;
                }
                addedge(sta[Top-1],sta[Top]);
                Top--;
            }
            if(sta[Top]!=h[i]) sta[++Top]=h[i];
        }
        while(--Top) addedge(sta[Top],sta[Top+1]);
        for(int i=1;i<=k;i++) vis[h[i]]=0;
    }
    return 0;
}

具體建虛樹怎麼建可以看別人的部落格……我講的肯定沒有它們好

1、[SDOI2011]消耗戰

分析：人生第一道虛樹題。

難的就是建一棵虛樹，然後在虛樹上樹形 $dp$

首先，打出一個樹上字首最小值。因為無論怎樣，選一條最小的邊斷掉一定是最優的。建一棵虛樹，若遍歷到選定的點 $x$，那麼 $dp[x]=min(dis[x],\sum_{son\in x}val_{x->son})$，其中 $val$ 為邊權。

$Code\ Below:$

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn=250000+10;
const int inf=1e18;
int n,m,dp[maxn],dis[maxn],vis[maxn],h[maxn],sta[maxn],Top;
int fir[maxn],head[maxn],to[maxn<<1],nxt[maxn<<1],tot,cnt;
int top[maxn],dep[maxn],id[maxn],siz[maxn],son[maxn],fa[maxn],tim;

struct node{
    int to,next,val;
}e[maxn<<1];

inline int read(){
    register int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return (f==1)?x:-x;
}
inline void add(int x,int y,int w){
    e[++tot].to=y;
    e[tot].val=w;
    e[tot].next=head[x];
    head[x]=tot;
}
inline void addedge(int x,int y){
    to[++cnt]=y;
    nxt[cnt]=fir[x];
    fir[x]=cnt;
}

void dfs1(int x,int f){
    siz[x]=1;fa[x]=f;
    dep[x]=dep[f]+1;
    int maxson=-1;
    for(int i=head[x],y;i;i=e[i].next){
        y=e[i].to;
        if(y==f) continue;
        dis[y]=min(dis[x],e[i].val);
        dfs1(y,x);
        siz[x]+=siz[y];
        if(maxson<siz[y]){
            maxson=siz[y];
            son[x]=y;
        }
    }
}

void dfs2(int x,int topf){
    id[x]=++tim;
    top[x]=topf;
    if(son[x]) dfs2(son[x],topf);
    for(int i=head[x],y;i;i=e[i].next){
        y=e[i].to;
        if(y==fa[x]||y==son[x]) continue;
        dfs2(y,y);
    }
}

int LCA(int x,int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    return x;
}

bool cmp(int a,int b){
    return id[a]<id[b];
}

void dfs(int x,int flag){
    dp[x]=dis[x];
    if(flag){
        for(int i=fir[x];i;i=nxt[i])
            dfs(to[i],flag);
        fir[x]=vis[x]=0;
        return ;
    }
    int val=0;
    for(int i=fir[x],y;i;i=nxt[i]){
        y=to[i];
        dfs(y,vis[y]);
        val+=dp[y];
    }
    if(!fir[x]||vis[x]) val=inf;
    dp[x]=min(dp[x],val);
    fir[x]=vis[x]=0;
}

signed main()
{
    n=read();
    int x,y,w,k,lca;
    for(int i=1;i<n;i++){
        x=read(),y=read(),w=read();
        add(x,y,w);add(y,x,w);
    }
    dis[1]=inf;
    dfs1(1,0);dfs2(1,1);
    m=read();
    for(int t=1;t<=m;t++){
        k=read();
        for(int i=1;i<=k;i++){
            h[i]=read();
            vis[h[i]]=1;
        }
        sort(h+1,h+k+1,cmp);
        cnt=0;
        sta[Top=1]=1;
        for(int i=1;i<=k;i++){
            lca=LCA(sta[Top],h[i]);
            while(dep[lca]<dep[sta[Top]]){
                if(dep[sta[Top-1]]<=dep[lca]){
                    addedge(lca,sta[Top]);
                    if(lca!=sta[--Top]) sta[++Top]=lca;
                    break;
                }
                addedge(sta[Top-1],sta[Top]);
                Top--;
            }
            if(sta[Top]!=h[i]) sta[++Top]=h[i];
        }
        while(--Top) addedge(sta[Top],sta[Top+1]);
        dfs(1,0);
        printf("%lld\n",dp[1]);
    }
    return 0;
}

2、[HEOI2014]大工程

分析：這道題自己推的，很有成就感哈哈哈

方法與上題一樣，不過多一點細節

$sub[x]$ 表示在虛樹上 $x$ 的子樹內有多少個選定點

這些點對 $(x,y)$ 對答案的貢獻要分兩類討論：

1、$x=lca(x,y)$ ，那麼直接在 $vis[x]=1$ 的時候算掉

2、$x,y$ 在兩棵不同的子樹內，那就一邊更新 $sub[x]$ 一邊算

void dfs(int x){
    int now=0;
    for(int i=fir[x];i;i=nxt[i]){
        dfs(to[i]);
        now+=sub[x]*sub[to[i]];
        sub[x]+=sub[to[i]];
        sub[to[i]]=0;
    }
    ans-=2*now*dep[x];
    if(vis[x]) ans-=2*sub[x]*dep[x],sub[x]++;
}

找最小邊權就是記錄一下最小值和次小值，然後更新 $ans$

找最大邊權同個道理

int dfs_min(int x){
    int Min=inf,sec=inf;
    for(int i=fir[x];i;i=nxt[i]){
        sec=min(sec,dfs_min(to[i]));
        if(Min>sec) swap(Min,sec);
    }
    if(vis[x]&&Min!=inf) ans=min(ans,Min-dep[x]);
    if(Min!=inf&&sec!=inf) ans=min(ans,Min+sec-2*dep[x]);
    if(vis[x]) Min=dep[x];
    return Min;
}

int dfs_max(int x){
    int Max=-inf,sec=-inf;
    for(int i=fir[x];i;i=nxt[i]){
        sec=max(sec,dfs_max(to[i]));
        if(Max<sec) swap(Max,sec);
    }
    if(vis[x]&&Max!=-inf) ans=max(ans,Max-dep[x]);
    if(Max!=-inf&&sec!=-inf) ans=max(ans,Max+sec-2*dep[x]);
    if(vis[x]&&Max==-inf) Max=dep[x];
    fir[x]=0;
    return Max;
}

那個前式鏈向星陣列 $fir[x]$ 一定要在 $dfsmax()$ 的時候清空！！！

$Code\ Below:$

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn=1000000+10;
const int inf=1e18;
int n,m,dp[maxn],vis[maxn],h[maxn],sub[maxn],sta[maxn],Top;
int fir[maxn],head[maxn],to[maxn<<1],nxt[maxn<<1],tot,cnt;
int top[maxn],dep[maxn],id[maxn],siz[maxn],son[maxn],fa[maxn],tim,ans;

struct node{
    int to,next;
}e[maxn<<1];

inline int read(){
    register int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return (f==1)?x:-x;
}
inline void add(int x,int y){
    e[++tot].to=y;
    e[tot].next=head[x];
    head[x]=tot;
}
inline void addedge(int x,int y){
    to[++cnt]=y;
    nxt[cnt]=fir[x];
    fir[x]=cnt;
}

void dfs1(int x,int f){
    siz[x]=1;fa[x]=f;
    dep[x]=dep[f]+1;
    int maxson=-1;
    for(int i=head[x],y;i;i=e[i].next){
        y=e[i].to;
        if(y==f) continue;
        dfs1(y,x);
        siz[x]+=siz[y];
        if(maxson<siz[y]){
            maxson=siz[y];
            son[x]=y;
        }
    }
}

void dfs2(int x,int topf){
    id[x]=++tim;
    top[x]=topf;
    if(son[x]) dfs2(son[x],topf);
    for(int i=head[x],y;i;i=e[i].next){
        y=e[i].to;
        if(y==fa[x]||y==son[x]) continue;
        dfs2(y,y);
    }
}

int LCA(int x,int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    return x;
}

bool cmp(int a,int b){
    return id[a]<id[b];
}

void dfs(int x){
    int now=0;
    for(int i=fir[x];i;i=nxt[i]){
        dfs(to[i]);
        now+=sub[x]*sub[to[i]];
        sub[x]+=sub[to[i]];
        sub[to[i]]=0;
    }
    ans-=2*now*dep[x];
    if(vis[x]) ans-=2*sub[x]*dep[x],sub[x]++;
    //printf("x=%lld,now=%lld,ans=%lld,sub[x]=%lld,dep[x]=%lld\n",x,now,ans,sub[x],dep[x]);
}

int dfs_min(int x){
    int Min=inf,sec=inf;
    for(int i=fir[x];i;i=nxt[i]){
        sec=min(sec,dfs_min(to[i]));
        if(Min>sec) swap(Min,sec);
    }
    if(vis[x]&&Min!=inf) ans=min(ans,Min-dep[x]);
    if(Min!=inf&&sec!=inf) ans=min(ans,Min+sec-2*dep[x]);
    if(vis[x]) Min=dep[x];
    return Min;
}

int dfs_max(int x){
    int Max=-inf,sec=-inf;
    for(int i=fir[x];i;i=nxt[i]){
        sec=max(sec,dfs_max(to[i]));
        if(Max<sec) swap(Max,sec);
    }
    if(vis[x]&&Max!=-inf) ans=max(ans,Max-dep[x]);
    if(Max!=-inf&&sec!=-inf) ans=max(ans,Max+sec-2*dep[x]);
    if(vis[x]&&Max==-inf) Max=dep[x];
    fir[x]=0;
    return Max;
}

signed main()
{
    n=read();
    int x,y,w,k,lca;
    for(int i=1;i<n;i++){
        x=read(),y=read();
        add(x,y);add(y,x);
    }
    dfs1(1,0);dfs2(1,1);
    m=read();
    for(int t=1;t<=m;t++){
        k=read();
        for(int i=1;i<=k;i++){
            h[i]=read();
            vis[h[i]]=1;
        }
        if(k==1){
            printf("0 0 0\n");
            continue;
        }
        sort(h+1,h+k+1,cmp);
        cnt=0;sta[Top=1]=1;
        for(int i=1;i<=k;i++){
            lca=LCA(sta[Top],h[i]);
            while(dep[lca]<dep[sta[Top]]){
                if(dep[sta[Top-1]]<=dep[lca]){
                    addedge(lca,sta[Top--]);
                    if(sta[Top]!=lca) sta[++Top]=lca;
                    break;
                }
                addedge(sta[Top-1],sta[Top]);
                Top--;
            }
            if(sta[Top]!=h[i]) sta[++Top]=h[i];
        }
        while(--Top) addedge(sta[Top],sta[Top+1]);
        ans=0;
        for(int i=1;i<=k;i++) ans+=(k-1)*dep[h[i]];
        dfs(1);sub[1]=0;
        printf("%lld ",ans);
        ans=inf;dfs_min(1);
        printf("%lld ",ans);
        ans=-inf;dfs_max(1);
        printf("%lld\n",ans);
        for(int i=1;i<=k;i++) vis[h[i]]=0;
    }
    return 0;
}

3、CF613D Kingdom and its Cities

分析：在虛樹上樹形 $dp$ 的時候分三種情況：

$P.S:sum$ 表示有多少個兒子已經選了

1、$vis[x]=1$，那麼不能選 $x$ 來斷掉兒子的退路，那麼 $dp[x]=\sum_{son\in x} dp[son]$

2、$vis[x]=0,sum>1$，那就直接選 $x$，$x$ 的子樹已經被 $x$ 封死了

3、$vis[x]=0,sum\leq 1$，那就傳到 $x$ 的父親上，讓 $x$ 的父親解決好了

$Code\ Below:$

#include <bits/stdc++.h>
using namespace std;
const int maxn=100000+10;
int n,m,dp[maxn],vis[maxn],h[maxn],sta[maxn],Top;
int fir[maxn],head[maxn],to[maxn<<1],nxt[maxn<<1],tot,cnt;
int top[maxn],dep[maxn],id[maxn],siz[maxn],son[maxn],fa[maxn],tim;

struct node{
    int to,next;
}e[maxn<<1];

inline int read(){
    register int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return (f==1)?x:-x;
}
inline void add(int x,int y){
    e[++tot].to=y;
    e[tot].next=head[x];
    head[x]=tot;
}
inline void addedge(int x,int y){
    to[++cnt]=y;
    nxt[cnt]=fir[x];
    fir[x]=cnt;
}

void dfs1(int x,int f){
    siz[x]=1;fa[x]=f;
    dep[x]=dep[f]+1;
    int maxson=-1;
    for(int i=head[x],y;i;i=e[i].next){
        y=e[i].to;
        if(y==f) continue;
        dfs1(y,x);
        siz[x]+=siz[y];
        if(maxson<siz[y]){
            maxson=siz[y];
            son[x]=y;
        }
    }
}

void dfs2(int x,int topf){
    id[x]=++tim;
    top[x]=topf;
    if(son[x]) dfs2(son[x],topf);
    for(int i=head[x],y;i;i=e[i].next){
        y=e[i].to;
        if(y==fa[x]||y==son[x]) continue;
        dfs2(y,y);
    }
}

int LCA(int x,int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    return x;
}

bool cmp(int a,int b){
    return id[a]<id[b];
}

int dfs(int x){
    int ans=0,sum=0;
    for(int i=fir[x];i;i=nxt[i])
        ans+=dfs(to[i]),sum+=dp[to[i]];
    if(vis[x]) dp[x]=1,ans+=sum;
    else if(sum>1) dp[x]=0,ans++;
    else dp[x]=sum;
    fir[x]=0;
    return ans;
}

int main()
{
    n=read();
    int x,y,w,k,lca,flag;
    for(int i=1;i<n;i++){
        x=read(),y=read();
        add(x,y);add(y,x);
    }
    dfs1(1,0);dfs2(1,1);
    m=read();
    for(int t=1;t<=m;t++){
        k=read();
        for(int i=1;i<=k;i++){
            h[i]=read();
            vis[h[i]]=1;
        }
        flag=0;
        for(int i=1;i<=k;i++)
            flag|=vis[fa[h[i]]];
        if(flag){
            printf("-1\n");
            for(int i=1;i<=k;i++) vis[h[i]]=0;
            continue;
        }
        sort(h+1,h+k+1,cmp);
        cnt=0;sta[Top=1]=1;
        for(int i=1;i<=k;i++){
            lca=LCA(sta[Top],h[i]);
            while(dep[lca]<dep[sta[Top]]){
                if(dep[sta[Top-1]]<=dep[lca]){
                    addedge(lca,sta[Top--]);
                    if(sta[Top]!=lca) sta[++Top]=lca;
                    break;
                }
                addedge(sta[Top-1],sta[Top]);
                Top--;
            }
            if(sta[Top]!=h[i]) sta[++Top]=h[i];
        }
        while(--Top) addedge(sta[Top],sta[Top+1]);
        printf("%d\n",dfs(1));
        for(int i=1;i<=k;i++) vis[h[i]]=0;
    }
    return 0;
}

[學習筆記]虛樹

模板：（樹剖$LCA$+建虛樹） #include <bits/stdc++.h> using namespace std; const int maxn=100000+10; int n,m,dp[maxn],vis[maxn],h[maxn],sta[maxn],Top; int fir

學習筆記 - 虛樹

虛樹 - 學習筆記初學的時候整個人是懵的不過總算是弄懂了『演算法概述』對於一類樹上的問題，如果僅有一部分點對答案“有用”（也就是說另一部分“可以不要”），那麼我們考慮只儲存那些有用的點。這就是虛樹的思想。所以為什麼它叫虛樹？我也不知道…… 通常情況下我們把一些點的 LCA 也算作“

學習筆記：樹鏈剖分

ostream head bubuko tdi OS 題目 add uil 如何實現現在的noip好像難度一年比一年高了啊……去年（2016）的noip竟然考了一道鏈剖……如果我當時在考場上怕不是要直接GG&hell

蒟蒻的學習筆記——平衡樹之FHQ_treap

ins oot 返回 tps return 兩個減少 root mar 前言眼看著聯賽將近，周圍的大佬們都開始學起了splay等高級數據結構算法，蒟蒻的我只好學一學treap,咦！？竟然有一種treap可以支持區間操作（splay）還那麽友好碼量適中？！小蒟蒻趕緊來安利

[學習筆記]動態樹Link-Cut-Tree

str 直接不同 html 思想 .cn 學習筆記普通平衡樹參考&&推薦： [Link-Cut-Tree]【學習筆記】一、概括一種支持維護樹的森林的算法。采用實鏈剖分，多棵splay維護每個實鏈，鍵值就是節點的深度。即，中序遍歷就是這個鏈從

[學習筆記]線段樹合併

1、[POI2011]ROT-Tree Rotations 分析：線段樹合併人生第一題。網上的題解我都沒看懂……我自己講一下好了線段樹合併就是把兩棵權值線段樹合併到一棵那怎麼合併呢？假設有這麼兩棵樹：一個結點代表一段值域區間有幾個數，那麼可以看出合併後應該是這樣的然後具體

[學習筆記]線段樹騷操作選講

引入眾所周知，線段樹可以維護序列，進行區間操作單點加 + 區間求和區間加 + 區間求和區間加 + 區間乘 + 區間求和（省略 +

資料探勘學習筆記-決策樹演算法淺析(含Java實現)

目錄一、通俗理解決策樹演算法原理二、舉例說明演算法執行過程三、Java實現本文基於書籍《資料探勘概念與技術》，由於剛接觸Data Mining，所以可能有理解不到位的情況，記錄學習筆記，提升自己對演算法的理解。程式碼下方有，如果有金幣的童鞋可以貢獻一下給無恥的

Algorithm學習筆記 --- 線段樹單點更新

wechat:812716131 ------------------------------------------------------ 技術交流群請聯絡上面wechat ----------------------------------------------

[OI學習筆記]線段樹模板

樹狀數組 lazy 重復優化查詢 amp cor 葉子 scan 背景　　今天課上講了樹狀數組和線段樹，有是一臉懵逼。。。　　於是網上有惡補了一下，　　看了幾個小時blog終於懂了。。。　　由於很難解釋，就只貼兩個模板代碼（一個單點修改+單點和區間查詢，

[學習筆記] 替罪羊樹

好像不重構的替罪羊樹跑得最快…… #include<iostream> #include<cstring> #include<cstdio> #include<algorithm> #include<cli

[學習筆記]替罪羊樹

kth pac 不用 data- enable lin date com names 替罪羊樹——簡單粗暴的數據結構 - a_forever_dream的..._CSDN博客一種簡單粗暴的數據結構（我自認為暴力“不優雅”。。。）和其他“優雅”的splay，fhq-tre

[學習筆記]線段樹分治

維護 gcd 樹分治聯通塊 bsp 插入 dfs lct 學習筆記 https://www.luogu.org/blog/Miracevin/shuo-ju-jie-gou 一種離線處理方法可以處理“具體哪個修改對詢問有影響”、可以貢獻不獨立、可以支持插入刪除例題

虛樹學習筆記

記錄 dfs序 ace inf 簡單 http stdio.h include name 虛樹算法其實原理蠻簡單的就是，從一顆n個結點的原樹上在只取出必要結點成一顆新樹，這顆新樹必包含指定m個結點並保持原樹上的祖孫關系。首先我們來解答一些問題問：什麽樣的結點是必要的呢？

虛樹學習筆記（洛谷2495 消耗戰）

題目連結因為辣雞csdn，導致之前快寫好的部落格沒了 QWQ悲傷逆流成河qwqqq 首先虛樹，這個東西，我感覺是一種思想，或者是方法，而並不是一個數據結構什麼的。他主要是用來解決：給出一棵樹，每次詢問選擇一些關鍵點，求一些資訊。這些資訊的特點是，許多未選擇的點可以通過某種方式剔除而

一篇自己都看不懂的虛樹學習筆記

學習虛樹，你需要的前置芝士：樹形DP、棧、$dfs$序先來一道題練練手：尋寶遊戲當然了，這道題和今天的內容基本上沒什麼關係…… 先從一道題開始引入虛樹消耗戰簡略題意就是給出一棵$N$個點樹，邊有邊權，$M$組詢問，每一次詢問$k_i$個重要點，需要切斷一些路徑使得所有重要點與$1$號點不

Python_sklearn機器學習庫學習筆記（四）decision_tree（決策樹）

min n) 空間 strong output epo from 標簽 ict # 決策樹 import pandas as pd from sklearn.tree import DecisionTreeClassifier from sklearn.

數據結構學習筆記-排序/隊/棧/鏈/堆/查找樹/紅黑樹

算法數據結構排序：插入排序：每次從剩余數據中選取一個最小的，插入已經排序完成的序列中合並排序：將數據分成左右兩組分別排序，然後合並，對每組數據的排序遞歸處理。冒泡排序：重復交換兩個相鄰元素，從a[1]開始向a[0]方向冒泡，然後a[2]...當a[i]無法繼續往前擠的時候說明前面的更小了，而且越往前越小(擠

數據結構學習筆記（五）樹的創建和遍歷

一個後序遍歷 for -1 堆棧 nor ext cnblogs 復制創建（先序創建和根據先序和中序進行創建）和遍歷（先序遍歷、中序遍歷、後序遍歷、非遞歸堆棧遍歷、層次遍歷）：　　 package tree; public class XianCreateTree

《機器學習》第三章決策樹學習筆記加總結

分類問題子集觀察組成 cas 普通重復 1.0 需要《機器學習》第三章決策樹學習決策樹學習方法搜索一個完整表示的假設空間，從而避免了受限假設空間的不足。決策樹學習的歸納偏置是優越選擇較小的樹。 3.1.簡介決策樹學習是一種逼近離散值目標函數的方法，在這種方法

[學習筆記]虛樹

1、[SDOI2011]消耗戰

2、[HEOI2014]大工程

3、CF613D Kingdom and its Cities

相關推薦