DFS序

最新推荐文章于 2024-04-06 01:17:07 发布
最新推荐文章于 2024-04-06 01:17:07 发布
阅读量221 收藏
点赞数
原文链接：https://www.cnblogs.com/weeping/p/6847112.html
版权

作者：weeping
出处：https://www.cnblogs.com/weeping/p/6847112.html
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

注：由于未找到相关题目，我自己敲的代码不确定正确性，我只自己测了自己小样例。（事后加上）

定义：dfs序：每个节点在dfs深度优先遍历中的进出栈的时间序列

定义两个数组，in[x]，ou[x]。dfs从根结点开始，每个结点分别记录两个信息：in[x]，ou[x]，in[x]为dfs进入结点x时的时间戳，ou[x]为dfs离开结点x时的时间戳 ，这样子  in[x] --- ou[x] 区间表示以 x 为根的子树

void dfs(int u,int fa){
    in[u]=++time;
    num[time]=u;
    dep[u]=dep[fa]+1;
    for(int i=0;i<E[u].size();i++){
        int v=E[u][i];
        if(v==fa)continue;
        dfs(v,u);
    }
    ou[u]=time;
}

性质：dfs序可以把一棵树区间化，即可以求出每个节点的管辖区间。

对于一棵树的dfs序而言，同一棵子树所对应的一定是dfs序中连续的一段。

dfs序的七个基本问题：

1.点修改，子树和查询

在dfs序中，子树处于一个连续区间中。所以这题可以转化为：点修改，区间查询。用树状数组或线段树即可。

例题：poj3321 Apple Tree

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
const int INF=1e9;
const int mod=1e9+7;
const int N=1e5+5;
#define LL long long
int in[N],ou[N],num[N],time;
vector<vector<int> >E(N);//POJ直接用vector超时
void dfs(int u,int fa){
    in[u]=++time;
    num[time]=u;
    int v;
    for(int i=0;i<E[u].size();i++)
        if((v=E[u][i])!=fa)
            dfs(v,u);
    ou[u]=time;
}
int val[N],n;
inline int lowbit(int x){
    return x&(-x);
}
void add(int x,int v){
    for(int i=x;i<=n;i+=lowbit(i))
        val[i]+=v;
}
int sum(int x){
    int ans=0;
    for(int i=x;i;i-=lowbit(i))
        ans+=val[i];
    return ans;
}
bool vis[N];
int main(){
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        E[u].push_back(v);
        E[v].push_back(u);
    }
    dfs(1,0);
    for(int i=1;i<=n;i++)
        add(i,1),vis[i]=1;
    int q;cin>>q;
    while(q--){
        char ch;
        int x;
        getchar();
        scanf("%c %d",&ch,&x);
        if(ch=='Q')
            printf("%d\n",sum(ou[x])-sum(in[x]-1));
        else{
            if(vis[x]==1)
                add(in[x],-1);
            else
                add(in[x],1);
            vis[x]=!vis[x];
        }
    }
    return 0;
}

2.树链修改，单点查询

将一条树链x,y上的所有点的权值加v。这个问题可以等价为：

1）.x到根节点的链上所有节点权值加v。

2）.y到根节点的链上所有节点权值加v。

3）.lca（x,y）到根节点的链上所有节点权值和减v。

4）.fa(lca(x,y))到根节点的链上所有节点权值和减v。

上面四个操作可以归结为：节点x到根节点链上所有节点的权值加减v。修改节点x权值，当且仅当y是x的祖先节点时，x对y的值有贡献。

所以节点y的权值可以转化为节点y的子树节点贡献和。从贡献和的角度想：这就是点修改，区间和查询问题。

修改树链x,y等价于add(l[x],v),add(l[y],v),add(l[lca(x,y)],-v),add(l[fa(lca(x,y))],-v)。

查询：get_sum(r[x])-get_sum(l[x]-1)

用树状数组或线段树即可。
 

#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int N=1e5+5;
//树状数组部分
int val[N],n;
inline int lowbit(int x){
    return x&(-x);
}
void add(int x,int v){
    if(x==0)return;
    for(int i=x;i<=n;i+=lowbit(i))
        val[i]+=v;
}
int sum(int x){
    int ans=0;
    for(int i=x;i;i-=lowbit(i))
        ans+=val[i];
    return ans;
}

//DFS序部分 + LCA
int in[N],ou[N],num[N],tim;
int dep[N],f[N][22];
vector<vector<int>>E(N);
void dfs(int u,int fa){
    in[u]=++tim;
    num[tim]=u;
    //初始化f数组
    dep[u]=dep[fa]+1;
    f[u][0]=fa;
    for(int i=1;i<=20;i++)
        f[u][i]=f[f[u][i-1]][i-1];

    for(int i=0;i<E[u].size();i++){
        int v=E[u][i];
        if(v==fa)continue;
        dfs(v,u);
    }
    ou[u]=tim;
}

int lca(int x,int y){
    if(dep[x]<dep[y])swap(x,y);
    int d=dep[x]-dep[y];
    for(int i=0;i<20;i++)
        if((1<<i)&d)
            x=f[x][i];
    if(x==y)return x;
    for(int i=20;i>=0;i--)
        if(f[x][i]!=f[y][i]){
            x=f[x][i];
            y=f[y][i];
        }
    return f[x][0];
}

int main(){
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        E[u].push_back(v);
        E[v].push_back(u);
    }
    dfs(1,0);       //假设以1为根
    int q;cin>>q;
    while(q--){     //树链修改，单点求值
        char ch;
        int x,y,v;
        getchar();
        scanf("%c%d",&ch,&x);
        if(ch=='Q')
            printf("%d\n",sum(ou[x])-sum(in[x]-1));
        else if(ch=='C'){
            scanf("%d%d",&y,&v);
            add(in[x],v);
            add(in[y],v);
            int fxy=lca(x,y);
            add(in[fxy],-v);
            add(in[f[fxy][0]],-v);
        }
    }
    return 0;
}
/*给出一组数据
7
1 3
1 4
3 5
3 7
4 6
4 2
7
C 5 7 2
Q 3
C 5 2 3
Q 3
Q 4
Q 5
Q 1
*/

3.树链修改，子树和查询

树链修改部分同上一问题。下面考虑子树和查询问题：前一问是从贡献的角度想，子树和同理。

对于节点y其到根节点的权值和，考虑其子节点x的贡献：w[x]*(deep[x]-deep[y]+1) = w[x]*(deep[x]+1)-w[x]*deep[y]

所以节点y的子树和为：
 

       ps:公式中的v[i]为手误，应为w[i]。

　　所以用两个树状数组或线段树即可：

　　　　第一个维护∑w[i]*(deep[i]+1):支持操作单点修改，区间和查询。（这也就是问题2）

　　　　第二个维护∑ w[i]：支持操作单点修改，区间查询。（这其实也是问题2）

#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int N=1e5+5;
//树状数组部分
int val1[N],val2[N],n;
inline int lowbit(int x){
    return x&(-x);
}
void add(int x,int v,int *val){
    if(x==0)return;
    for(int i=x;i<=n;i+=lowbit(i))
        val[i]+=v;
}
int sum(int x,int *val){
    int ans=0;
    for(int i=x;i;i-=lowbit(i))
        ans+=val[i];
    return ans;
}

//DFS序部分 + LCA
int in[N],ou[N],num[N],tim;
int dep[N],f[N][22];
vector<vector<int>>E(N);
void dfs(int u,int fa){
    in[u]=++tim;
    num[tim]=u;
    //初始化f数组
    dep[u]=dep[fa]+1;
    f[u][0]=fa;
    for(int i=1;i<=20;i++)
        f[u][i]=f[f[u][i-1]][i-1];

    for(int i=0;i<E[u].size();i++){
        int v=E[u][i];
        if(v==fa)continue;
        dfs(v,u);
    }
    ou[u]=tim;
}

int lca(int x,int y){
    if(dep[x]<dep[y])swap(x,y);
    int d=dep[x]-dep[y];
    for(int i=0;i<20;i++)
        if((1<<i)&d)
            x=f[x][i];
    if(x==y)return x;
    for(int i=20;i>=0;i--)
        if(f[x][i]!=f[y][i]){
            x=f[x][i];
            y=f[y][i];
        }
    return f[x][0];
}

int main(){
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        E[u].push_back(v);
        E[v].push_back(u);
    }
    dfs(1,0);       //假设以1为根
    int q;cin>>q;
    while(q--){     //树链修改，单点求值
        char ch;
        int x,y,v;
        getchar();
        scanf("%c%d",&ch,&x);
        if(ch=='Q'){
            LL ans=sum(ou[x],val1)-sum(in[x]-1,val1);
            ans-=dep[x]*(sum(ou[x],val2)-sum(in[x]-1,val2));
            printf("%lld\n",ans);
        }
        else if(ch=='C'){
            scanf("%d%d",&y,&v);
            int fxy=lca(x,y);
            //Val1
            add(in[x],v*(dep[x]+1),val1);
            add(in[y],v*(dep[y]+1),val1);
            add(in[fxy],-v*(dep[fxy]+1),val1);
            add(in[f[fxy][0]],-v*(dep[f[fxy][0]]+1),val1);
            //Val2
            add(in[x],v,val2);
            add(in[y],v,val2);
            add(in[fxy],-v,val2);
            add(in[f[fxy][0]],-v,val2);
        }
    }
    return 0;
}
/*给出一组数据
7
1 3
1 4
3 5
3 7
4 6
4 2
7
C 5 7 2
Q 3
C 5 2 3
Q 3
Q 4
Q 5
Q 1
*/

4.单点更新，树链和查询

树链和查询与树链修改类似，树链和(x,y)等于下面四个部分和相加：

1）.x到根节点的链上所有节点权值加。

2）.y到根节点的链上所有节点权值加。

3）.lca（x,y）到根节点的链上所有节点权值和的-1倍。

4）.fa(lca(x,y))到根节点的链上所有节点权值和的-1倍。

所以问题转化为：查询点x到根节点的链上的所有节点权值和。

修改节点x权值，当且仅当y是x的子孙节点时，x对y的值有贡献。

差分前缀和，y的权值等于dfs中[1,l[y]]的区间和。（不会树状数组进行该操作的可以参考：https://www.cnblogs.com/kickit/p/9172189.html

单点修改：add(l[x],v),add(r[x]+1,-v);
 

#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int N=1e5+5;
//树状数组部分
int val[N],n;
inline int lowbit(int x){
    return x&(-x);
}
void add(int x,int v,int *val){
    if(x==0)return;
    for(int i=x;i<=n;i+=lowbit(i))
        val[i]+=v;
}
int sum(int x,int *val){
    int ans=0;
    for(int i=x;i;i-=lowbit(i))
        ans+=val[i];
    return ans;
}

//DFS序部分 + LCA
int in[N],ou[N],num[N],tim;
int dep[N],f[N][22];
vector<vector<int>>E(N);
void dfs(int u,int fa){
    in[u]=++tim;
    num[tim]=u;
    //初始化f数组
    dep[u]=dep[fa]+1;
    f[u][0]=fa;
    for(int i=1;i<=20;i++)
        f[u][i]=f[f[u][i-1]][i-1];

    for(int i=0;i<E[u].size();i++){
        int v=E[u][i];
        if(v==fa)continue;
        dfs(v,u);
    }
    ou[u]=tim;
}

int lca(int x,int y){
    if(dep[x]<dep[y])swap(x,y);
    int d=dep[x]-dep[y];
    for(int i=0;i<20;i++)
        if((1<<i)&d)
            x=f[x][i];
    if(x==y)return x;
    for(int i=20;i>=0;i--)
        if(f[x][i]!=f[y][i]){
            x=f[x][i];
            y=f[y][i];
        }
    return f[x][0];
}

int main(){
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        E[u].push_back(v);
        E[v].push_back(u);
    }
    dfs(1,0);       //假设以1为根
    int q;cin>>q;
    while(q--){     //树链修改，单点求值
        char ch;
        int x,y,v;
        getchar();
        scanf("%c%d",&ch,&x);
        if(ch=='Q'){
            scanf("%d",&y);
            LL ans =sum(in[x],val);
               ans+=sum(in[y],val);
               int fxy=lca(x,y);
               ans-=sum(in[fxy],val);
               ans-=sum(in[f[fxy][0]],val);
            printf("%lld\n",ans);
        }
        else if(ch=='C'){
            scanf("%d",&v);
            add(in[x],v,val);
            add(ou[x]+1,-v,val);
        }
    }
    return 0;
}
/**给出一组数据
7
1 3
1 4
3 5
3 7
4 6
4 2
8
Q 1 2
C 3 2
Q 5 7
C 4 1
Q 5 2
C 1 1
Q 7 2
Q 1 1
*/

5.子树修改，单点查询

　　修改节点x的子树权值，在dfs序上就是区间修改，单点权值查询就是单点查询。

　　区间修改，单点查询问题：树状数组或线段树即可;

　（不会树状数组进行该操作的可以参考：https://www.cnblogs.com/kickit/p/9172189.html

#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int N=1e5+5;
//树状数组部分
int val[N],n;
inline int lowbit(int x){
    return x&(-x);
}
void add(int x,int v,int *val){
    if(x==0)return;
    for(int i=x;i<=n;i+=lowbit(i))
        val[i]+=v;
}
int sum(int x,int *val){
    int ans=0;
    for(int i=x;i;i-=lowbit(i))
        ans+=val[i];
    return ans;
}

//DFS序部分 + LCA
int in[N],ou[N],num[N],tim;
int dep[N],f[N][22];
vector<vector<int>>E(N);
void dfs(int u,int fa){
    in[u]=++tim;
    num[tim]=u;
    //初始化f数组
    dep[u]=dep[fa]+1;
    f[u][0]=fa;
    for(int i=1;i<=20;i++)
        f[u][i]=f[f[u][i-1]][i-1];

    for(int i=0;i<E[u].size();i++){
        int v=E[u][i];
        if(v==fa)continue;
        dfs(v,u);
    }
    ou[u]=tim;
}

int lca(int x,int y){
    if(dep[x]<dep[y])swap(x,y);
    int d=dep[x]-dep[y];
    for(int i=0;i<20;i++)
        if((1<<i)&d)
            x=f[x][i];
    if(x==y)return x;
    for(int i=20;i>=0;i--)
        if(f[x][i]!=f[y][i]){
            x=f[x][i];
            y=f[y][i];
        }
    return f[x][0];
}

int main(){
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        E[u].push_back(v);
        E[v].push_back(u);
    }
    dfs(1,0);       //假设以1为根
    int q;cin>>q;
    while(q--){     //子树修改，单点求值
        char ch;
        int x,y,v;
        getchar();
        scanf("%c%d",&ch,&x);
        if(ch=='Q'){
            LL ans = sum(in[x],val);
            printf("%lld\n",ans);
        }
        else if(ch=='C'){
            scanf("%d",&v);
            add(in[x],v,val);
            add(ou[x]+1,-v,val);
        }
    }
    return 0;
}
/**给出一组数据
7
1 3
1 4
3 5
3 7
4 6
4 2
8
Q 1
C 3 2
Q 5
C 1 3
Q 7
Q 1
Q 3
Q 4
*/

6.子树修改，子树和查询

　　题目等价与区间修改，区间查询问题。用树状数组或线段树即可。

   （不会树状数组进行该操作的可以参考：https://www.cnblogs.com/kickit/p/9172189.html

#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int N=1e5+5;
//树状数组部分
int val1[N],val2[N],n;
inline int lowbit(int x){
    return x&(-x);
}
void add(int x,int v,int *val){
    if(x==0)return;
    for(int i=x;i<=n;i+=lowbit(i))
        val[i]+=v;
}
int sum(int x,int *val){
    int ans=0;
    for(int i=x;i;i-=lowbit(i))
        ans+=val[i];
    return ans;
}

//DFS序部分 + LCA
int in[N],ou[N],num[N],tim;
int dep[N],f[N][22];
vector<vector<int>>E(N);
void dfs(int u,int fa){
    in[u]=++tim;
    num[tim]=u;
    //初始化f数组
    dep[u]=dep[fa]+1;
    f[u][0]=fa;
    for(int i=1;i<=20;i++)
        f[u][i]=f[f[u][i-1]][i-1];

    for(int i=0;i<E[u].size();i++){
        int v=E[u][i];
        if(v==fa)continue;
        dfs(v,u);
    }
    ou[u]=tim;
}

int lca(int x,int y){
    if(dep[x]<dep[y])swap(x,y);
    int d=dep[x]-dep[y];
    for(int i=0;i<20;i++)
        if((1<<i)&d)
            x=f[x][i];
    if(x==y)return x;
    for(int i=20;i>=0;i--)
        if(f[x][i]!=f[y][i]){
            x=f[x][i];
            y=f[y][i];
        }
    return f[x][0];
}

int main(){
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        E[u].push_back(v);
        E[v].push_back(u);
    }
    dfs(1,0);       //假设以1为根
    int q;cin>>q;
    while(q--){     //子树修改，子树和查询
        char ch;
        int x,y,v;
        getchar();
        scanf("%c%d",&ch,&x);
        if(ch=='Q'){
            LL ans = (ou[x]+1)*sum(ou[x],val1) - sum(ou[x],val2);
               ans-= (in[x])*sum(in[x]-1,val1) - sum(in[x]-1,val2);
            printf("%lld\n",ans);
        }
        else if(ch=='C'){
            scanf("%d",&v);
            add(in[x],v,val1);
            add(ou[x]+1,-v,val1);
            add(in[x],v*in[x],val2);
            add(ou[x]+1,-v*(ou[x]+1),val2);
        }
    }
    return 0;
}
/**给出一组数据
7
1 3
1 4
3 5
3 7
4 6
4 2
9
Q 1
C 3 2
Q 3
C 1 3
Q 7
Q 1
Q 3
Q 4
Q 2
*/

7.子树修改，树链查询

树链查询同上，等价为根节点到y节点的链上所有节点和问题。

修改节点x的子树权值，当且仅当y是x的子孙节点时（或y等于x），x对y的值有贡献。

x对根节点到y节点的链上所有节点和的贡献为：w[x]*(deep[y]-deep[x]+1)=w[x]*deep[y]+w[x]*(1-deep[x])

同问题三，用两个树状数组或线段树即可。

（不会树状数组进行该操作的可以参考：https://blog.csdn.net/qq_40695203/article/details/101075768

由于本人数据结构太差，我使用四个树状数组维护，前两个搞w[x]*deep[y]，后两个搞w[x]*(1-deep[x])

 

#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int N=1e5+5;
//树状数组部分
int val1[N],val2[N],val3[N],val4[N],s[N],n;//si是 1--i的dep的和 ,
inline int lowbit(int x){
    return x&(-x);
}
void add(int x,int v,int *val){
    if(x==0)return;
    for(int i=x;i<=n;i+=lowbit(i))
        val[i]+=v;
}
int sum(int x,int *val){
    if(x<=0)return 0;
    int ans=0;
    for(int i=x;i;i-=lowbit(i))
        ans+=val[i];
    return ans;
}

//DFS序部分 + LCA
int in[N],ou[N],num[N],tim;
int dep[N],f[N][22];
vector<vector<int>>E(N);
void dfs(int u,int fa){
    in[u]=++tim;
    num[tim]=u;
    //初始化f数组
    if(u)
    dep[u]=dep[fa]+1;
    f[u][0]=fa;
    for(int i=1;i<=20;i++)
        f[u][i]=f[f[u][i-1]][i-1];

    for(int i=0;i<E[u].size();i++){
        int v=E[u][i];
        if(v==fa)continue;
        dfs(v,u);
    }
    ou[u]=tim;
}

int lca(int x,int y){
    if(dep[x]<dep[y])swap(x,y);
    int d=dep[x]-dep[y];
    for(int i=0;i<20;i++)
        if((1<<i)&d)
            x=f[x][i];
    if(x==y)return x;
    for(int i=20;i>=0;i--)
        if(f[x][i]!=f[y][i]){
            x=f[x][i];
            y=f[y][i];
        }
    return f[x][0];
}

inline int get(int id){
    if(id<=0)return 0;
    return s[id]*sum(id,val1) - sum(id,val2) + (id*sum(id,val3) - sum(id,val4));
}
int main(){
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        E[u].push_back(v);
        E[v].push_back(u);
    }
    dfs(1,0);       //假设以1为根
    for(int i=1;i<=n;i++)   //处理前缀和s数组
        s[i]=dep[num[i]]+s[i-1];
    for(int i=1;i<=n;i++)
        printf("%d ",dep[num[i]]);puts("");
    for(int i=1;i<=n;i++)
        printf("%d ",s[i]);puts("");
    int q;cin>>q;
    while(q--){     //
        int x,y,v;
        getchar();
        scanf("%c%d",&ch,&x);
        if(ch=='Q'){
            scanf("%d",&y);
            LL ans = get(in[x])-get(in[x]-1);
               ans+= get(in[y])-get(in[y]-1);
            int fxy= lca(x,y);
               ans-= get(in[fxy])-get(in[fxy]-1);
               ans-= get(in[f[fxy][0]])-get(in[f[fxy][0]]-1);
            printf("%lld\n",ans);
        }
        else if(ch=='C'){
            scanf("%d",&v);
            add(in[x],v,val1);
            add(ou[x]+1,-v,val1);
            add(in[x],v*s[in[x]-1],val2);
            add(ou[x]+1,-v*s[ou[x]],val2);

            int v1=v*(1-dep[x]);
            add(in[x],v1,val3);
            add(ou[x]+1,-v1,val3);
            add(in[x],v1*(in[x]-1),val4);
            add(ou[x]+1,-v1*ou[x], val4);
        }
    }
    return 0;
}
/**给出一组数据
7
1 3
1 4
3 5
3 7
4 6
4 2
9
C 3 2
Q 5 3
Q 7 5
C 1 3
Q 3 1
Q 1 1
Q 4 5
Q 5 7
Q 5 2
*/

 

谁抢了我的happypeople
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LibreOJ-dfs序2 (dfs序，线段树）
01-03
LibreOJ-dfs序2 (dfs序，线段树） 题目描述 给一棵有根树，这棵树由编号为1~N 的 N个结点组成。根结点的编号为R。每个结点都有一个权值，结点 的权值为 。 接下来有 M组操作，操作分为两类： 1 a x，表示将结点 的子...
树的DFS序及其应用
10-20
适用于正在搞OI的选手学习和提高，一种很不错的思想，近年来NOIP考察树上的东西渐多，值得好好学习
DFS算法（深度优先搜索）
Sydyyy的博客
12-25 163
a. 判孩子（当根节点是虚空的时候，比如子集树，排列树，拆分树，组合树）c. 子集树：左孩子为0，右孩子为1。b. 判父亲（当根节点不是虚空的时候，比如搜索树）a. 排序树：孩子不与祖先重复。e. 搜索树：孩子不与祖先重复。b. 组合树：孩子大于父亲。d. 拆分树：孩子>=父亲。e. 搜索树（找起点到终点的所有路径）注：黄色点是返回时的标注。2. 判答案的两种方法。
dfs序（基础讲解）
LJR的博客
08-27 5736
dfs序简介 dfs序一般用于树状结构中，如图： 图中红色序号为每个点对应的dfs序序号，黑色序号为每个点默认的序号，我称之为节点序序号（下文同） 可见，dfs序如其名，dfs序序号是按照dfs顺序标记的，所以说给每个节点安排上dfs序序号也很简单，只要dfs的时候顺便标上就行了，dfs第多少次就给dfs到的点标为多少。 代码模板 代码如下： //vector<int> node[N]; //int in[N],out[N]; //int Time = 0; //时间戳 void dfs(in
DFS序列
最新发布
weixin_62944148的博客
04-06 573
DFS序是指对一棵树进行DFS时，每个节点被访问到的顺序。DFS序分成两个部分：进入该节点的顺序和退出该节点的顺序。
DFS--基本入门模板 和 例题 （绝对入门） (最全)
热门推荐
Romantic Chopin in C Sharp Minor
08-13 4万+
以下是全网收集整理的和自己写的部分，绝对保证dfs轻松入门。 核心代码： 关于dfs参数问题，什么在变化，就把什么设置成参数。 void dfs()//参数用来表示状态 { if(到达终点状态) { ...//根据题意添加 return; } if(越界或者是不合法状态) ...
DFS算法
GINA102504_的博客
02-19 192
蓝桥练习
dfs序
A_Pathfinder的博客
03-18 695
dfs序就是指一棵树被dfs时所经过的节点的顺序。 dfs是深度优先的，所以对于一个点，它会先遍历完它的所有子节点，再去遍历他的兄弟节点以及其他 所以对于一棵树的dfs序来说，这个点和他所有的子节点会被存储在连续的区间之中。 //图片来源：http://www.cnblogs.com/stxy-ferryman/p/7741970.html 我们都知道它的dfs序是：A-B-D-E-G-C...
dfs序的常见用法整理.docx
10-02
DFS序是一种在图论和算法竞赛中常用的工具，特别是在处理树结构的问题时。DFS（深度优先搜索）遍历一棵树时，按照一定的顺序访问每个节点，这个顺序就被称为DFS序。DFS序的一个重要特性是，一棵子树在DFS序中的表示...
Codeforces Round #629 (Div. 3) E – Tree Queries dfs序判祖先关系
01-20
惭愧，前几天刚学的dfs序判祖先关系都忘了用。。 这题我们先把所有点都变成父亲节点（根节点不变），这样只需要判所有节点是否在一条链上。 由于判断x是y的祖先：需要满足：st[x]<=st[y]<=ed[y]<=ed[x]. 即...
排列（DFS）
01-08
排列（DFS） 题目描述 给定一个整数n，将数字1~n排成一排，将会有很多种排列方法。 现在，请你按照字典序将所有的排列方法输出。 输入格式 共一行，包含一个整数n。 输出格式 按字典序输出所有排列方案，每个方案占...
dfs序（树形结构线性化）
hwdn3000的博客
12-09 1686
通过观察可以发现，以x 为根的子树在一个连续的区间，即在x 入栈和出栈之间，因此，如果要对子树进行操作，可以看作对一个区间进行操作，且这个区间对应新的线性序列中的in[x] out[x]。如对结点B根的子树进行操作，则对应线性序列区间in[B] out[B]，即区间[2,5]进行操作。id[x]：表示结点x在新的线性序列中的下标， id[x]=in[x]。对单个结点x进行修改，则对应新的线性序列对id[x]进行修改。out[x]：表示结点x出栈的时间戳，特殊的，出栈不算时间。
浅谈DFS序
Jr1preg的博客
03-06 1266
DFS序是什么 定义：树的dfs序是一个序列(可以类比前序序列等)，顾名思义，就是在按照dfs时搜到的顺序得到的序列 比如说，来张图 上面这棵树的dfs序为：1 3 2 4 6 7 5 8 10 9 为什么是DFS序 大家可能在想把一棵树转化成一个序列有什么用，在回答这一问题之前，我们先看看dfs序它有什么有用的性质。可以发现，节点uuu的子树在dfs序中为一段连续的区间，那利用dfs序就可以把...
【详解】dfs序
_BOSS_的博客
02-15 593
dfsdfsdfs序是将树形结构转换为线性结构的一种方式。 dfs序 dfsdfsdfs序： 指每个节点在dfs深度优先遍历中的进出栈的时间序列。 定义三个数组： inn[x]inn[x]inn[x]：表示结点xxx入栈的时间戳。 outt[x]outt[x]outt[x]：表示结点xxx出栈的时间戳，特殊的，出栈不算时间。 id[x]id[x]id[x]：表示结点x在新的线性序列中的下标，id[...
DFS序讲解
qq_35975367的博客
04-07 556
我们经常会遇到树的问题，但树是非线性的结构，操作起来始终还是麻烦，如果我们能把树改造成线性结构，有什么方法？对，就是今天要讲的DSF序； dfs序呢，就是把一棵树区间化，我们用dfs的方式将它区间化。 如图： dfs序就是：ABDDEEBCFHHFG 其实就是用dfs全部遍历一遍，不过我们不能光遍历还有动些小手脚，我们要在遍历的同时记录每个节点进栈与出栈的时间序列。 介绍两个基本函数：in[x],...
dfs序+树链剖分,超详细讲解+原理分析+模板(看不懂来打我)
TheWayForDream
07-07 908
dfs序+树链剖分,超详细讲解+原理分析+模板(看不懂来打我dfs序+树链剖分一. 树链剖分能解决什么问题？二.树链剖分前置知识1.dfs序2. 时间戳3.dfs序和时间戳有什么用处线段树的区间修改和查询，对链进行操作三.树链剖分模板四.视频资源讲解 dfs序+树链剖分 一. 树链剖分能解决什么问题？ 二.树链剖分前置知识 1.dfs序 2. 时间戳 按照dfs第一次访问的顺序，给每一个节点标记上时间戳 3.dfs序和时间戳有什么用处 开始剖分，跑第二次dfs的作用,也即dfs1和dfs2
理解递归函数/DFS函数的方法
sinat_38972110的博客
09-01 9916
对于递归函数或者深搜函数，有时候因为其调用本身的性质所以会难以理解。以如下dfs函数为例： void dfs(...){ //外部dfs if(...) {...} for(...){ ...; dfs(...); //内部dfs ...; } } 要想在遇到深搜问题时很快写出dfs(),只记模板是不行的，需要理...
dfs详解————by ly，cx
qq_42701791的博客
09-19 1527
• DFS: • 全名:Depth-First-Search,中文名:深度优先搜索。 • 算法简要过程:对每一个可能的分支路径深入到不能再深入为止,而且每个节 点只能访问一次。以上均为百度百科以及强大怪的的che dan 首先先讲思想（口胡） 图的dfs 当然树形结构也一样。   简单的就不说了，给出一种模板 void dfs(答案,搜索层数,其他参数){ if(层数...
dfs 返回值用bool相对void会快一点
dotJunz的博客
12-16 384
力扣 剑指 Offer 12. 矩阵中的路径 超时代码 dfs返回值是void，用类内的全局变量flag表示找到或没找到。 class Solution { public: bool flag; int vis[210][210]; int dir[4][2] = { {1,0},{0,1},{-1,0},{0,-1} }; int m, n; void dfs(int x, int y, int count, string& word, vector<
树形背包dfs序优化
08-08
DFS序优化是一种常用的解法，它通过遍历树的方式来处理背包问题。 具体步骤如下： 1. 对树进行深度优先搜索（DFS），遍历每个节点。 2. 在DFS的过程中，记录每个节点的DFS序号。可以使用一个数组来存储每个节点的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值