DFS 算法——五棵树

JingLuan1109

已于 2023-01-14 23:22:20 修改

阅读量172

点赞数

文章标签：深度优先算法

于 2023-01-02 22:23:46 首次发布

本文链接：https://blog.csdn.net/JingLuan1109/article/details/128525105

版权

文章介绍了五种不同的树型数据结构：排序树、组合树、子集树、拆分树和搜索树，每种树都有其特定的规则，如孩子与祖先的关系。同时，提出了两种判断树类型的方法，一种基于根节点为空的情况，如排序树、组合树、子集树和拆分树；另一种基于根节点非空，如搜索树。

摘要由CSDN通过智能技术生成

1.五棵树

1.1 排序树(孩子不与祖先重复)

1.2组合树(父亲>孩子)

1.3子集树(左孩子0,右孩子1, 0不选择,1选择)

1.4拆分树(孩子>=父亲)

1.5搜索树(孩子不与祖先重复)

2.判断答案的两种方法

2.1判断孩子(当根节点是虚空的时候，比如排序树，组合树，子集树，拆分树)

#include<bits/stdc++.h>
using namespace std;
#define N 1000  //问题的规模
void dfs(int k);//第k 代/步/层
int vis[N]; //标记，去重
int ans[N]; //存答案 ans[k]就是存第K层的答案
int main()
{



    return 0;
}
void dfs(int k)
{
    for(int i=1; i<=n; i++) //(枚举第K代所有孩子的线索)
    { 
        //生成孩子
        if()  //看孩子的合法性， (符合约束条件且不重复)
        {
            //保存孩子
            //标记孩子
            if()  //孩子是答案，输出
            {
                //输出
            }
            else  //如果不是答案，就继续从下一代找
            {
                dfs(k+1); 
            }
            //取消标记
        }
    }
}

2.2判断父亲(当根节点是非虚空的时候，比如搜索树)

#include<bits/stdc++.h>
using namespace std;
#define N 1000 //问题规模
void dfs(int k);//第k 代/步/层
int vis[N]; //标记，去重
int ans[N]; //存答案 ans[k]就是存第K层的答案
int main()
{



    return 0;
}
void dfs(int u)  //搜索树是对图而言的
{
    //保存父亲
    //标记父亲
    if()  //父亲是答案，输出
    {
        //输出
    }
    for(int i=1; i<=n; i++) //(枚举第K代所有孩子的线索)
    {
        //生成孩子
        if()  //看孩子的合法性， (符合约束条件且不重复)
        {
            dfs(k+1);
        }
    }
    //取消标记(父亲的标记)
}

3.代码

3.1 排序树

#include<bits/stdc++.h>
using namespace std;
#define N 1000  //问题的规模
void dfs(int k);//第k 代/步/层
int vis[N]; //标记，去重
int ans[N]; //存答案 ans[k]就是存第K层的答案
int n;
int main()
{
    cin>>n;
    dfs(1);
    return 0;
}
void dfs(int k)
{
    for(int i=1; i<=n; i++) //(枚举第K代所有孩子的线索)
    {
        //生成孩子
        if(vis[i]==0 )  //看孩子的合法性， (符合约束条件且不重复)
        {
            //保存孩子
            ans[k]=i;
            //标记孩子
            vis[i]=1;
            if(k>=n)  //孩子是答案，输出
            {
                //输出
                for(int j=1; j<=k; j++)
                {
                    cout<<ans[j]<<" ";
                }
                cout<<endl;
            }
            else  //如果不是答案，就继续从下一代找
            {
                dfs(k+1);
            }
            //取消标记
            vis[i]=0;
        }
    }
}

3.2 组合树

#include<bits/stdc++.h>
using namespace std;
#define N 1000  //问题的规模
void dfs(int k);//第k 代/步/层
int vis[N]; //标记，去重
int ans[N]; //存答案 ans[k]就是存第K层的答案
int n,r; //从n个数字里取r个数字组合
int main()
{
    cin>>n>>r;
    dfs(1);
    return 0;
}
void dfs(int k)
{
    for(int i=1; i<=n; i++) //(枚举第K代所有孩子的线索)
    {
        //生成孩子
        if(i>ans[k-1])  //看孩子的合法性， (符合约束条件且不重复)
        {
            //保存孩子
            ans[k]=i;
            if(k>=r)  //孩子是答案，输出
            {
                //输出
                for(int j=1; j<=k; j++)
                {
                    cout<<ans[j]<<" ";
                }
                cout<<endl;
            }
            else  //如果不是答案，就继续从下一代找
            {
                dfs(k+1);
            }
            //取消标记
            vis[i]=0;
        }
    }
}

3.3 子集树

#include<bits/stdc++.h>
using namespace std;
#define N 1000  //问题的规模
void dfs(int k);//第k 代/步/层
int vis[N]; //标记，去重
int ans[N]; //存答案 ans[k]就是存第K层的答案，ans[k]==1表示第k个物品被选中，ans[k]==0表示第k个物品未被选中
int n; //表示有n个物品
int main()
{
    cin>>n;
    dfs(1);
    return 0;
}
void dfs(int k)
{
    for(int i=0; i<=1; i++) //(枚举第K代所有孩子的线索)
    {
        //生成孩子
        if(1)  //看孩子的合法性， (符合约束条件且不重复)
        {
            //保存孩子
            ans[k]=i;
            if(k>=n)  //孩子是答案，输出
            {
                //输出
                for(int j=1; j<=k; j++)
                {
                    cout<<ans[j]<<" ";
                }
                cout<<endl;
            }
            else  //如果不是答案，就继续从下一代找
            {
                dfs(k+1);
            }
        }
    }
}

3.4 拆分树

#include<bits/stdc++.h>
using namespace std;
#define N 1000  //问题的规模
void dfs(int s, int k);//第k 代/步/层
int vis[N]; //标记，去重
int ans[N]; //存答案 ans[k]就是存第K层的答案
int n;
int main()
{
    ans[0]=1;
    cin>>n;
    dfs(n,1);
    return 0;
}
void dfs(int s, int k)
{
    for(int i=1; i<=s; i++) //(枚举第K代所有孩子的线索)
    {
        //生成孩子
        if(i>=ans[k-1])  //看孩子的合法性， (符合约束条件且不重复)
        {
            //保存孩子
            ans[k]=i;
            //标记孩子
            s=s-i;
            if(s==0)  //孩子是答案，输出
            {
                //输出
                for(int j=1; j<=k; j++)
                {
                    cout<<ans[j]<<" ";
                }
                cout<<endl;
            }
            else  //如果不是答案，就继续从下一代找
            {
                dfs(s,k+1);
            }
            //取消标记
            s=s+i;
        }
    }
}

3.5 搜索树 //计算从起点到终点的路径

#include<bits/stdc++.h>
using namespace std;
#define N 1000 //问题规模
//存储图
int n,m; // n 点，m 边
vector<int> a[N];

void dfs(int u,int k);//第k 代/步/层
int vis[N]; //标记，去重
int ans[N]; //存答案 ans[k]就是存第K层的答案
int start=0;  //起点
int target=2; //终点
int main()
{
    cin>>n>>m;
    for(int i=1; i<=m; i++)
    {
        int u,v;
        cin>>u>>v;
        a[u].push_back(v);
        a[v].push_back(u);
    }
    dfs(start,1);
    return 0;
}
void dfs(int u,int k)  //搜索树是对图而言的
{
    //保存父亲
    ans[k]=u;
    //标记父亲
    vis[u]=1;
    if(u==target)  //父亲是答案，输出
    {
        //输出
        for(int j=1; j<=k; j++)
        {
            cout<<ans[j]<<" ";
        }
        cout<<endl;
    }
    for(int i=0; i<a[u].size(); i++) //(枚举第K代所有孩子的线索)
    {
        //生成孩子
        int v=a[u][i]; //u的第i个孩子
        if(vis[v]==0)  //看孩子的合法性， (符合约束条件且不重复)
        {
            dfs(v,k+1);
        }
    }
    //取消标记(父亲的标记)
    vis[u]=0;
}
/*
5 7
0 1
0 3
0 4
1 2
1 4
2 3
3 4
*/