DFS序

最新推荐文章于 2024-04-04 16:02:10 发布
最新推荐文章于 2024-04-04 16:02:10 发布
阅读量474 收藏 3
点赞数 2
分类专栏： 模板

转载自戳
大致看了下dfs序的题型，大致清楚了大致的解题思路。。。但是对于一些题目还是比较无力。。。。
dfs序比较重要的性质：一棵子树的所有节点在dfs序里是连续一段，主要就是利用这个性质来解题

题型一：对某个点X权值加上一个数W，查询某个子树X里所有点权值和。
解：列出dfs序，实现修改一个数，查询一段序列的和，显然这个序列可以用树状数组维护。

/*
poj3321
树状数组直接在第一次出现的位置+1，-1好了，对其他兄弟树没有影响，因为兄弟树是求区间，前面的+1，-1已经抵消掉了
*/

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <string>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
const int maxn = 100005;

struct ppp{
    int v,nex;
}e[maxn * 4] ;
int head[maxn],tole,n;
void make_edge(int u,int v){
    e[tole].v = v;e[tole].nex = head[u];head[u] = tole++;
}
int qian[maxn],hou[maxn],vis[maxn];
int sum[maxn * 2];
int cnt_node;

void init(){
    for(int i = 0;i < 2 * maxn;i++){
        head[i >> 1] = -1;sum[i] = 0;
        vis[i >> 1] = 1;
    }
    tole = 0;
    cnt_node = 0;
}


void dfs(int u,int pre){
    qian[u] = ++cnt_node;
    for(int i = head[u];~i;i = e[i].nex){
        int v = e[i].v;
        if(v == pre)continue;
        dfs(v,u);

    }
    hou[u] = ++cnt_node;
}
int lowbit(int x){
    return x & -x;
}
int query(int x){
    int ret = 0;
    while(x >= 1){
        ret += sum[x];
        x -= lowbit(x);
    }   
    return ret;
}
void add(int x,int v){
    while(x <= cnt_node){
        sum[x] += v;
        x += lowbit(x);
    }
}
int main(){
    while(~scanf("%d",&n)){
        init();
        for(int i = 1,a,b;i <= n - 1;i++){
            scanf("%d%d",&a,&b);
            make_edge(a,b);
            make_edge(b,a);
        }
        dfs(1,-1);
        for(int i = 1;i <= n;i++){
            add(qian[i],1);
        }
        int q;
        scanf("%d",&q);
        char c;int a;
        while(q--){
            scanf(" %c%d",&c,&a);
            if(c == 'Q'){
                int now = query(hou[a]) - query(qian[a] - 1);
                printf("%d\n",now);
            }else {
                if(vis[a] > 0){
                    add(qian[a],-1);
                }else {
                    add(qian[a],1);
                }
                vis[a] = !vis[a];
            }
        }
    }

}

题型二：对X到Y的最短路上所有点权值加上一个数W，查询某个点的权值。
解：并没有找到该类型的题目。。。。假设有这种题目吧。。若X到Y上的点的权值都加上W，那么其实就是X到根的权值加上W，Y到根的点权值加上W，lca（X,Y）到根的权值减去W，parent(lca(X,Y))到根的点权值减去W。

#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define FOR(i,a,b) for(int i = a;i <= b;i++)
using namespace std;
typedef long long ll;
const int maxn = 100005;
const int INF = 0x3f3f3f3f;
struct ppp
{   
    int v,nex;
}e[maxn * 2];
int head[maxn],q,n;
int dp[maxn * 2][19],tole;
int dep[maxn],pos[maxn],last[maxn * 2];
int cnt;
int st[maxn],ed[maxn];
void make_edge(int u,int v)
{
    e[tole].v = v,e[tole].nex = head[u];head[u] = tole++;
}
int sum[maxn * 2],parent[maxn];
inline int lowbit (int x){
    return x & -x;
}
void add(int x,int v){
    while(x <= cnt){
        sum[x] += v;
        x += lowbit(x);
    }
}
int que(int x){
    int ret = 0;
    while(x >= 1){
        ret += sum[x];
        x -= lowbit(x);
    }
    return ret;
}
void dfs(int u,int fa,int deep)
{
    parent[u] = fa;
    dep[u] = deep;
    pos[u] = ++cnt;
    st[u] = cnt;
    last[cnt] = u;
    int v;
    for(int i = head[u];~i;i = e[i].nex)
    {
        v = e[i].v;
        if(v == fa)continue;
        dfs(v,u,deep + 1);
        pos[u] = ++cnt;
        last[cnt] = u;
    }
    ed[u] = cnt;
}
void ST()
{
    for(int i = 1;i <= cnt;i++)
        dp[i][0] = last[i];
    for(int j = 1;(1 << j) <= cnt;j++)
        for(int i = 1;i + (1 << j) - 1 <= cnt;i++)
        {
            dp[i][j] = dp[i][j - 1];
            if(dep[dp[i + (1 << (j - 1))][j - 1]] < dep[dp[i][j - 1]])dp[i][j] = dp[i + (1 << (j - 1))][j - 1];
        }
}
int query(int l,int r)
{
    int k = 0;
    while((1 << (k + 1)) <= r - l + 1)k++;
    if(dep[dp[l][k]] < dep[dp[r - (1 << k) + 1][k]])
        return dp[l][k];
    else return dp[r - (1 << k) + 1][k];
}
void init()
{
    mem(head,-1);
    tole = 0;
    cnt = 0;
    mem(sum,0);
}
int main()
{
    while(~scanf("%d",&n))
    {
        init();
        for(int i = 1,a,b;i <= n - 1;i++){
            scanf("%d%d",&a,&b);
            make_edge(a,b);
            make_edge(b,a);
        }
        dfs(1,-1,1);
        ST();
        scanf("%d",&q);//查询个数
        char c;
        int a,b;
        while(q--){
            scanf(" %c",&c);
            if(c == 'Q'){
                scanf("%d",&a);
                printf("%d\n",que(ed[a]) - que(st[a] - 1));
            }else {
                int v;
                scanf("%d%d%d",&a,&b,&v);
                int aa = pos[a],bb = pos[b];
                if(aa > bb)swap(aa,bb);
                int lca = query(aa,bb);
                add(st[a],v);//这里在树状数组上加加减减感觉挺难理解的，可以写出dfs序画一画
                add(st[b],v);
                add(st[lca],-v);
                if(lca != 1)
                add(st[parent[lca]],-v);
            }
        }
    }
}

题型三：
从X到Y的点加上或者减去一个W，求某个点子树内的所有点的权值和
假设X在Y的子树内，那么对于询问点Y，询问值会加上W * (depth(X) - depth(Y) + 1)。
拆开后为W * (depth(x) + 1) - W * (depth(Y)) 。因为对于询问的是Y，由此可见此式子跟X无关，所以可以开设两个树状数组，一个保存W * (depth(x) + 1)，另一个保存W * depth(Y)，对于每一个部分维护，维护的方式类似题型二。
以下代码非本人写，供参考

#include <bits/stdc++.h>  
#define mem(a,b) memset(a,b,sizeof(a))  
using namespace std;  
typedef long long ll;  
const int MAXN = 1e5+10;  

vector<int> edge[MAXN];  
int s[2*MAXN];  
int s1[2*MAXN];  
int seq[2*MAXN];  
int seq1[2*MAXN];  
int depth[2*MAXN];  
int first[MAXN];  
int dp[2*MAXN][25];  
int st[MAXN];  
int ed[MAXN];  
int parent[MAXN];  
int cnt, num;  

int Lowbit(int x)  
{  
    return x & (-x);  
}  

void Add(int x, int val, int n)  
{  
    if(x <= 0) return;  
    for(int i = x; i <= n; i += Lowbit(i)) {  
        s[i] += val;  
    }  
}  

void Add1(int x, int val, int n)  
{  
    if(x <= 0) return;  
    for(int i = x; i <= n; i += Lowbit(i)) {  
        s1[i] += val;  
    }  
}  

int Sum(int x)  
{  
    int res = 0;  
    for(int i = x; i > 0; i -= Lowbit(i)) {  
        res += s[i];  
    }  
    return res;  
}  

int Sum1(int x)  
{  
    int res = 0;  
    for(int i = x; i > 0; i -= Lowbit(i)) {  
        res += s1[i];  
    }  
    return res;  
}  

void Dfs(int u, int fa, int dep)  
{  
    parent[u] = fa;  
    seq[++cnt] = u;  
    seq1[++num] = u;  
    first[u] = num;  
    depth[num] = dep;  
    st[u] = cnt;  
    int len = edge[u].size();  
    for(int i = 0; i < len; i++) {  
        int v = edge[u][i];  
        if(v != fa) {  
            Dfs(v, u, dep+1);  
            seq1[++num] = u;  
            depth[num] = dep;  
        }  
    }  
    seq[++cnt] = u;  
    ed[u] = cnt;  
}  

void RMQ_Init(int n)  
{  
    for(int i = 1; i <= n; i++) {  
        dp[i][0] = i;  
    }  
    for(int j = 1; (1 << j) <= n; j++) {  
        for(int i = 1; i + (1 << j) - 1 <= n; i++) {  
            int a = dp[i][j-1], b = dp[i + (1 << (j-1))][j-1];  
            dp[i][j] = depth[a] < depth[b] ? a : b;  
        }  
    }  
}  

int RMQ_Query(int l, int r)  
{  
    int k = 0;  
    while((1 << (k + 1)) <= r - l + 1) k++;  
    int a = dp[l][k], b = dp[r-(1<<k)+1][k];  
    return depth[a] < depth[b] ? a : b;  
}  

int LCA(int u, int v)  
{  
    int a = first[u], b = first[v];  
    if(a > b) a ^= b, b ^= a, a ^= b;  
    int res = RMQ_Query(a, b);  
    return seq1[res];  
}  

void Init(int n)  
{  
    for(int i = 0; i <= n; i++) {  
        edge[i].clear();  
    }  
    memset(s, 0, sizeof(s));  
}  

int main()  
{  
    int n, op;  
    int u, v, w;  
    int cmd;  

    while(scanf("%d %d", &n, &op) != EOF) {  
        Init(n);  
        for(int i = 0; i < n-1; i++) {  
            scanf("%d %d", &u, &v);  
            edge[u].push_back(v);  
            edge[v].push_back(u);  
        }  
        cnt = 0, num = 0;  
        Dfs(1, -1, 0);  
        RMQ_Init(num);  
        while(op--) {  
            scanf("%d", &cmd);  
            if(cmd == 0) {  
                scanf("%d %d %d", &u, &v, &w);  
                int lca = LCA(u, v);  
                //以下维护跟求值其实跟题型二是一样的，就是分两个树状数组   
                Add(st[u], w * depth[first[u]] + w, cnt);  
                Add1(st[u], w, cnt);  
                Add(st[v], w * depth[first[v]] + w, cnt);  
                Add1(st[v], w, cnt);  
                Add(lca, -(w * depth[first[lca]] + w), cnt);  
                Add1(lca, -w, cnt);  
                Add(parent[lca], -(w * depth[first[parent[lca]]] + w), cnt);  
                Add1(parent[lca], -w, cnt);  
            }  
            else if(cmd == 1) {  
                scanf("%d", &u);  
                printf("%d\n", Sum(ed[u]) - Sum(st[u] - 1) - depth[first[u]] * (Sum1(ed[u]) - Sum1(st[u] - 1)));  
            }  
        }  
    }  

    return 0;  
}

题型四：对于某个节点X加上一个W，查询X到Y路径上的所有点的权值和。ps：这个感觉比前面的都容易想到啊。。。。
那么加上一个W的维护就跟题型一的维护差不多。
查询的值就等于： X到根的权值和 + Y到跟的权值和 - LCA(X,Y)到根的权值和 - parent(LCA(X,Y))到根的权值和。
思路很简单，贴一下别人的代码：

const int MAXN = 1e5+10;  

vector<int> edge[MAXN];  
int s[2*MAXN];  
int s1[2*MAXN];  
int seq[2*MAXN];  
int seq1[2*MAXN];  
int depth[2*MAXN];  
int first[MAXN];  
int dp[2*MAXN][25];  
int st[MAXN];  
int ed[MAXN];  
int parent[MAXN];  
int cnt, num;  

int Lowbit(int x)  
{  
    return x & (-x);  
}  

void Add(int x, int val, int n)  
{  
    if(x <= 0) return;  
    for(int i = x; i <= n; i += Lowbit(i)) {  
        s[i] += val;  
    }  
}  

int Sum(int x)  
{  
    int res = 0;  
    for(int i = x; i > 0; i -= Lowbit(i)) {  
        res += s[i];  
    }  
    return res;  
}  

void Dfs(int u, int fa, int dep)  
{  
    parent[u] = fa;  
    seq[++cnt] = u;  
    seq1[++num] = u;  
    first[u] = num;  
    depth[num] = dep;  
    st[u] = cnt;  
    int len = edge[u].size();  
    for(int i = 0; i < len; i++) {  
        int v = edge[u][i];  
        if(v != fa) {  
            Dfs(v, u, dep+1);  
            seq1[++num] = u;  
            depth[num] = dep;  
        }  
    }  
    seq[++cnt] = u;  
    ed[u] = cnt;  
}  

void RMQ_Init(int n)  
{  
    for(int i = 1; i <= n; i++) {  
        dp[i][0] = i;  
    }  
    for(int j = 1; (1 << j) <= n; j++) {  
        for(int i = 1; i + (1 << j) - 1 <= n; i++) {  
            int a = dp[i][j-1], b = dp[i + (1 << (j-1))][j-1];  
            dp[i][j] = depth[a] < depth[b] ? a : b;  
        }  
    }  
}  

int RMQ_Query(int l, int r)  
{  
    int k = 0;  
    while((1 << (k + 1)) <= r - l + 1) k++;  
    int a = dp[l][k], b = dp[r-(1<<k)+1][k];  
    return depth[a] < depth[b] ? a : b;  
}  

int LCA(int u, int v)  
{  
    int a = first[u], b = first[v];  
    if(a > b) a ^= b, b ^= a, a ^= b;  
    int res = RMQ_Query(a, b);  
    return seq1[res];  
}  

void Init(int n)  
{  
    for(int i = 0; i <= n; i++) {  
        edge[i].clear();  
    }  
    memset(s, 0, sizeof(s));  
}  

int main()  
{  
    int n, op;  
    int u, v, w;  
    int cmd;  

    while(scanf("%d %d", &n, &op) != EOF) {  
        Init(n);  
        for(int i = 0; i < n-1; i++) {  
            scanf("%d %d", &u, &v);  
            edge[u].push_back(v);  
            edge[v].push_back(u);  
        }  
        cnt = 0, num = 0;  
        Dfs(1, -1, 0);  
        RMQ_Init(num);  
        while(op--) {  
            scanf("%d", &cmd);  
            if(cmd == 0) {  
                scanf("%d %d", &u, &w);  
                Add(st[u], w, cnt);  
                Add(ed[u], -w, cnt);  
            }  
            else if(cmd == 1) {  
                scanf("%d %d", &u, &v);  
                int lca = LCA(u, v);  
                printf("%d\n", Sum(st[u]) + Sum(st[v]) - Sum(st[lca]) - Sum(st[parent[lca]]));  
            }  
        }  
    }  

    return 0;  
}

题型五：对于一个点X的子树内的所有点加上一个值W，查询某个点的值。
那么只要在子树总都+w就好了，就是维护区间就是st[X] + w,ed[X] - w。
查询只要找que(X)就好了，注意如果点有原值的话要加上原值。

#include<bits/stdc++.h>  
#define mem(a,b) memset(a,b,sizeof(a))  
#define FOR(i,a,b) for(int i = a;i <= b;i++)  
using namespace std;  
typedef long long ll;  
const int maxn = 100005;  
const int INF = 0x3f3f3f3f;  
struct ppp  
{     
    int v,nex;  
}e[maxn * 2];  
int head[maxn],q,n;  
int dp[maxn * 2][19],tole;  
int dep[maxn],pos[maxn],last[maxn * 2];  
int cnt;  
int st[maxn],ed[maxn];  
void make_edge(int u,int v)  
{  
    e[tole].v = v,e[tole].nex = head[u];head[u] = tole++;  
}  
int sum[maxn * 2],parent[maxn];  
inline int lowbit (int x){  
    return x & -x;  
}  
void add(int x,int v){  
    while(x <= cnt){  
        sum[x] += v;  
        x += lowbit(x);  
    }  
}  
int que(int x){  
    int ret = 0;  
    while(x >= 1){  
        ret += sum[x];  
        x -= lowbit(x);  
    }  
    return ret;  
}  
void dfs(int u,int fa,int deep)  
{  
    parent[u] = fa;  
    dep[u] = deep;  
    pos[u] = ++cnt;  
    st[u] = cnt;  
    last[cnt] = u;  
    int v;  
    for(int i = head[u];~i;i = e[i].nex)  
    {  
        v = e[i].v;  
        if(v == fa)continue;  
        dfs(v,u,deep + 1);  
        pos[u] = ++cnt;  
        last[cnt] = u;  
    }  
    ed[u] = cnt;  
}  
void ST()  
{  
    for(int i = 1;i <= cnt;i++)  
        dp[i][0] = last[i];  
    for(int j = 1;(1 << j) <= cnt;j++)  
        for(int i = 1;i + (1 << j) - 1 <= cnt;i++)  
        {  
            dp[i][j] = dp[i][j - 1];  
            if(dep[dp[i + (1 << (j - 1))][j - 1]] < dep[dp[i][j - 1]])dp[i][j] = dp[i + (1 << (j - 1))][j - 1];  
        }  
}  
int query(int l,int r)  
{  
    int k = 0;  
    while((1 << (k + 1)) <= r - l + 1)k++;  
    if(dep[dp[l][k]] < dep[dp[r - (1 << k) + 1][k]])  
        return dp[l][k];  
    else return dp[r - (1 << k) + 1][k];  
}  
void init()  
{  
    mem(head,-1);  
    tole = 0;  
    cnt = 0;  
    mem(sum,0);  
}  
int main()  
{  
    while(~scanf("%d",&n))  
    {  
        init();  
        for(int i = 1,a,b;i <= n - 1;i++){  
            scanf("%d%d",&a,&b);  
            make_edge(a,b);  
            make_edge(b,a);  
        }  
        dfs(1,-1,1);  
        ST();  
        scanf("%d",&q);//查询个数  
        char c;  
        int a,b;  
        while(q--){  
            scanf(" %c",&c);  
            if(c == 'Q'){  
                scanf("%d",&a);  
                printf("%d\n",que(st[a]));//其中这个是更改后的值统计，如果有原值的话要加上原值  
            }else {  
                int w;  
                scanf("%d%d",&a,&w);  
                add(st[a],w);  
                add(ed[a],-w);  
            }  
        }  
    }  
}

题型六：对子树X里所有的节点加上一个值W，查询某个子树的权值和。
明显的区间修改，区间查询，那么。。。线段树。。
修改：就在st[X]到ed[X]上都加一个W
查询：直接查询st[X]到ed[X]，记住都到的值除以2，因为每个点都算了两遍
代码就不挂了。

题型七：对于子树X内的所有点都加上一个值W，查询X到Y之间的路径上所有点权和。
那么这题就跟题型四很像，就是修改的时候改成修改一段区间，从X到Y路径上的话直接就套用题型四的做法。
贴一下别人的代码：

typedef struct {  
    int l, r, sum, add;  
} Seg;  

const int MAXN = 1e5+10;  

Seg T[4*MAXN];  
vector<int> edge[MAXN];  
int s[2*MAXN];  
int s1[2*MAXN];  
int seq[2*MAXN];  
int seq1[2*MAXN];  
int depth[2*MAXN];  
int first[MAXN];  
int dp[2*MAXN][25];  
int parent[MAXN];  
int st[MAXN];  
int ed[MAXN];  
int cnt, cnt1;  

int Lowbit(int x)  
{  
    return x & (-x);  
}  

void Add(int x, int val, int n)  
{  
    if(x <= 0) return ;  
    for(int i = x; i <= n; i += Lowbit(i)) {  
        s[i] += val;  
    }  
}  

void Add1(int x, int val, int n)  
{  
    if(x <= 0) return ;  
    for(int i = x; i <= n; i += Lowbit(i)) {  
        s1[i] += val;  
    }  
}  

int Sum(int x)  
{  
    int res = 0;  
    for(int i = x; i > 0; i -= Lowbit(i)) {  
        res += s[i];  
    }  
    return res;  
}  

int Sum1(int x)  
{  
    int res = 0;  
    for(int i = x; i > 0; i -= Lowbit(i)) {  
        res += s1[i];  
    }  
    return res;  
}  

void RMQ_Init(int n)  
{  
    for(int i = 1; i <= n; i++) {  
        dp[i][0] = i;  
    }  
    for(int j = 1; (1 << j) <= n; j++) {  
        for(int i = 1; i + (1 << j) - 1 <= n; i++) {  
            int a = dp[i][j-1], b = dp[i + (1 << (j-1))][j-1];  
            dp[i][j] = depth[a] < depth[b] ? a : b;  
        }  
    }  
}  

int RMQ_Query(int l, int r)  
{  
    int k = 0;  
    while((1 << (k + 1)) <= r - l + 1) k++;  
    int a = dp[l][k], b = dp[r-(1 << k)+1][k];  
    return depth[a] < depth[b] ? a : b;  
}  

int LCA(int u, int v)  
{  
    int a = first[u], b = first[v];  
    if(a > b) a ^= b, b ^= a, a ^= b;  
    int res = RMQ_Query(a, b);  
    return seq1[res];  
}  

void Dfs(int u, int fa, int dep)  
{  
    seq[++cnt] = u;  
    seq1[++cnt1] = u;  
    first[u] = cnt1;  
    parent[u] = fa;  
    depth[cnt1] = dep;  
    st[u] = cnt;  
    int len = edge[u].size();  
    for(int i = 0; i < len; i++) {  
        int v = edge[u][i];  
        if(v != fa) {  
            Dfs(v, u, dep+1);  
            seq1[++cnt1] = u;  
            depth[cnt1] = dep;  
        }  
    }  
    seq[++cnt] = u;  
    ed[u] = cnt;  
}  

void Init(int n)  
{  
    for(int i = 0; i <= n; i++) {  
        edge[i].clear();  
    }  
    memset(s, 0, sizeof(s));  
    memset(s1, 0, sizeof(s1));  
}  

void Debug()  
{  
    int u, v;  
    while(1) {  
        scanf("%d %d", &u, &v);  
        printf("The LCA of %d %d is %d\n", u, v, LCA(u, v));  
    }  
}  

int main()  
{  
    int n, op;  
    int u, v, w;  
    int cmd;  

    while(scanf("%d %d", &n, &op) != EOF) {  
        Init(n);  
        for(int i = 0; i < n-1; i++) {  
            scanf("%d %d", &u, &v);  
            edge[u].push_back(v);  
            edge[v].push_back(u);  
        }  
        cnt = cnt1 = 0;  
        Dfs(1, 0, 0);  
        RMQ_Init(cnt1);  
        while(op--) {  
            scanf("%d", &cmd);  
            if(cmd == 0) {  
                scanf("%d %d", &u, &w);  
                Add(st[u], w * (1 - depth[first[u]]), cnt);  
                Add(ed[u], -w * (1 - depth[first[u]]), cnt);  
                Add1(st[u], w, cnt);  
                Add1(ed[u], -w, cnt);  
            }  
            else if(cmd == 1) {  
                scanf("%d %d", &u, &v);  
                int lca = LCA(u, v);  
                int par = parent[lca];  
                int ans = Sum(st[u]);  
                ans += depth[first[u]] * Sum1(st[u]);  
                ans += Sum(st[v]);  
                ans += depth[first[v]] * Sum1(st[v]);  
                ans -= Sum(st[lca]);  
                ans -= depth[first[lca]] * Sum1(st[lca]);  
                ans -= Sum(st[par]);  
                ans -= depth[first[par]] * Sum1(st[par]);  
                printf("%d\n", ans);  
            }  
        }  
    }  

    return 0;  
}
Chenhongkan
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dfs序基本类型 详细
kkkkahlua的博客
08-25 720
参考dfs序七个经典问题 ——weeping本博文又名：手把手教你写树状数组1. 单点修改，子树和查询单点修改，区间查询树状数组维护每个点的权值： 1. 修改xx（增加ww）：单点修改——add(x,w); 2. 查询xx的子树：区间查询——ans=query(le[x])-query(ri[x]-1);2. 单点修改，树链和查询首先将 u−vu-v 树链和查询转化成 u−root,v−
DFS
vaelala的博客
03-03 494
搜索算法是利用计算机的高性能来有目的的穷举一个问题解空间的部分或所有的可能情况，从而求出问题的解的一种方法。 --百度百科搜索树的概念：将搜索过程中每一步的状态变成树的一个节点，根节点为初始状态，搜索便是不断遍历这棵树，直到找到目标状态为止。DFS主要算法过程：对于一个在有效的范围内的状态A，对于其所有的子状态，选择一种进行搜索，递归这一子状态，直到达到叶子节点，然后回溯到父亲节点，对另一种子状态...
dfs序基本类型总结
qwe2434127的专栏
11-13 4607
大致看了下dfs序的题型，大致清楚了大致的解题思路。。。但是对于一些题目还是比较无力。。。。 dfs序比较重要的性质：一棵子树的所有节点在dfs序里是连续一段，主要就是利用这个性质来解题 题型一：对某个点X权值加上一个数W，查询某个子树X里所有点权值和。 解：列出dfs序，实现修改一个数，查询一段序列的和，显然这个序列可以用树状数组维护。 题型二：对X到Y的最短路上所有点权
dfs序的常见用法整理
LIN452
06-27 4761
dfs序就是一棵树在dfs遍历时组成的节点序列. 它有这样一个特点:一棵子树的dfs序是一个区间. 下面是dfs序的基本代码: void dfs(int x,int pre,int d){//L,R表示一个子树的范围 L[x]=++tot; dep[x]=d; for(int i=0;i<e[x].size();i++){ int y=e[x][i];
dfs序七个经典问题
weixin_30721077的博客
05-12 253
update-2018.07.23:　　原文问题五思路描述有误，已更正。 　参考自：《数据结构漫谈》-许昊然 dfs序是树在dfs先序遍历时的序列，将树形结构转化成序列问题处理。 dfs有一个很好的性质：一棵子树所在的位置处于一个连续区间中。 ps:deep[x]为x的深度，l[x]为dfs序中x的位置，r[x]为dfs序中x子树的结束位置 1.点修改，子树和查询 　　在dfs序中，子...
三类最基础的DFS问题
Turing_Sheep的博客
01-03 1001
熟练解决三类最基础的DFS问题
LibreOJ-dfs序2 (dfs序，线段树）
01-03
LibreOJ-dfs序2 (dfs序，线段树） 题目描述 给一棵有根树，这棵树由编号为1~N 的 N个结点组成。根结点的编号为R。每个结点都有一个权值，结点 的权值为 。 接下来有 M组操作，操作分为两类： 1 a x，表示将结点 的子...
树的DFS序及其应用
10-20
适用于正在搞OI的选手学习和提高，一种很不错的思想，近年来NOIP考察树上的东西渐多，值得好好学习
dfs序的常见用法整理.docx
10-02
DFS序是一种在图论和算法竞赛中常用的工具，特别是在处理树结构的问题时。DFS（深度优先搜索）遍历一棵树时，按照一定的顺序访问每个节点，这个顺序就被称为DFS序。DFS序的一个重要特性是，一棵子树在DFS序中的表示...
Codeforces Round #629 (Div. 3) E – Tree Queries dfs序判祖先关系
01-20
3) E – Tree Queries dfs序判祖先关系"指的是一场编程竞赛中的问题，涉及到树结构的查询和深度优先搜索（DFS）来判断节点间的祖先关系。这个问题的目标是设计算法来确定在给定的树结构中，一个节点是否为另一个...
排列（DFS）
01-08
排列（DFS） 题目描述 给定一个整数n，将数字1~n排成一排，将会有很多种排列方法。 现在，请你按照字典序将所有的排列方法输出。 输入格式 共一行，包含一个整数n。 输出格式 按字典序输出所有排列方案，每个方案占...
树 DFS序 详解[完全版]
热门推荐
蒟蒻柴犬首相的博客
11-02 2万+
本文是博主通过几篇比较好的博文组合而成。下面是几篇博文的原地址： http://cdnnn.07net01.com/2015/08/899785.html http://blog.csdn.net/ccsu_001/article/details/47667587 http://blog.csdn.net/u012061345/article/details/54023285 http:/
DFS序学习
永远鲜红の幼月的博客
10-07 341
对于一棵树，将他DFS展开成一个数组，就是DFS序，它的作用有很多，下面再说； 先放代码： dfs序板子： void dfs(int x,int pre,int d)//L,R表示一个子树的范围 { //当前节点，父节点，深度 L[x]=++tot;//当前节点的左时间 dep[x]=d;//记录深度 for(int i=0;i&lt;e[x].size;++i)//遍历子节点...
dfs序
weixin_30713953的博客
10-02 63
dfs序比较重要的性质：一棵子树的所有节点在dfs序里是连续一段，主要就是利用这个性质来解题 题型一：对某个点X权值加上一个数W，查询某个子树X里所有点权值和。 解：列出dfs序，实现修改一个数，查询一段序列的和，显然这个序列可以用线段树维护。 题型二：对X到Y的最短路上所有点权值加上一个数W，查询某个...
树链剖分
Virgil's Blog
08-04 538
树链剖分简介树链剖分适用于一些复杂的题目，可以较为充分获取树上的信息，将其转换为线性结构后可以很方便的使用线性数据结构进行处理。那么，树链剖分试讲一棵树如何转化为一条链的呢？之前有前序、中序、后序遍历，而树链剖分与前三种方式相似但不相同。首先，有两个重要的概念：对于一个节点，他的子节点的子树中节点数最多的是他的重儿子，相对地，其他节点成为此节点的轻儿子。对每个节点，我们遍历的时候首先到它的重儿子，在
dfs超详解（基本用法+蓝桥杯真题）
2302_79815969的博客
04-04 1944
最后说一下本文是用于自己学习的笔记以及备战蓝桥杯的笔记，如果有与其他博主相似的代码勿喷（因为我就是跟他们学的）有一些是学习到的，有一些是自己总结的，有一些的语言不是很精准也请轻喷，欢迎大家借鉴。推荐去听b站杭电刘老师的dfs基础课，里边不仅讲解dfs的基本应用也讲了一些剪枝的技巧（虽然我现在也用不太明白剪枝）。当然会这几道题并不够学会dfs，推荐去蓝桥云课或者洛谷刷一些dfs的题目。
【算法笔记（十）】之DFS通用问题解决方法
开发小鸽
09-17 1107
本文章由公号【开发小鸽】发布！欢迎关注！！！ 老规矩–妹妹镇楼： 一． DFS （一）概述        深度优先搜索，以深度为优先选项，它会走遍所有的路径，即枚举所有完整路径来找到最佳的路径。 （二）实现思路        DFS可以使用栈来解决，DFS的使用过程和栈十分类似，选择一条路为进栈，退出一条路为出栈。更简单的实现方法是通过递归来实现DFS，递归中必须有递归式和递归边界，DFS中的递归式即为岔道口
ASP外观专利图像检索平台(源代码+论文).rar
最新发布
07-21
ASP外观专利图像检索平台(源代码+论文)
树形背包dfs序优化
08-08
DFS序优化是一种常用的解法，它通过遍历树的方式来处理背包问题。 具体步骤如下： 1. 对树进行深度优先搜索（DFS），遍历每个节点。 2. 在DFS的过程中，记录每个节点的DFS序号。可以使用一个数组来存储每个节点的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值