树与图存储和遍历

树与图的邻接表存储

树与图的存储

//邻接表存储树，图
int h[N],e[M],ne[M],idx;
//初始化
void init()
{
    memset(h,-1,sizeof h);//把每个链表置空就是初始化
}
//往h[a] 的后面加入结点b(数据)  或者说存在边  a-->b
void add(int a,int b)
{
    e[idx]=b;//b是树的结点标号，idx树中插入到了第几个结点
    ne[idx]=h[a];
    h[a]=idx;
    idx++;
}

树与图的深度优先遍历

//树和图的深度优先遍历
void dfs(int u)
{
    st[u]=true;//结点u搜过，标记一下
    //遍历一下u的所有出边（u指向的所有边）
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];//j存当前链表中结点 对应 图中结点的编号是什么
        if(!st[j])dfs(j);
    }
}

对应练习：acwing846，树的重心

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Id4f4M2l-1626599291802)(C:\Users\dell\AppData\Roaming\Typora\typora-user-images\1619363791157.png)]

对于4上面那部分的结点数量可以用 n-size（4） 总的减去以4位根结点的结点数量

下面程序中，ans存最终答案；res存去掉u结点后所有的连通块中结点数的最大值

sum存以该点为父节点的树的结点数。

//代码 树的深度优先遍历
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N=1e5+10;

int n;
int h[N],e[N*2],ne[N*2],idx;
bool st[N];
int ans=N;


void init()
{
    memset(h,-1,sizeof h);
}
void add(int a,int b)
{
    e[idx]=b;ne[idx]=h[a],h[a]=idx;idx++;//
    
}
//返回以当前结点为根的树 的 结点数量
int dfs(int u)
{
    st[u]=true;
    
    int sum=1,res=0;//res 存 删掉当前节点后每一个连通块取最大值
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!st[j]){
            int s=dfs(j);
            res=max(res,s);
            sum+=s;
        }
    }
    res=max(res,n-sum);
    ans=min(res,ans);
    
    return sum; //返回以点前节点为根结点的的 节点数量
}

int main()
{
    cin>>n;
    init();//不能忘记初始化！！！
    for(int i=0;i<n-1;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a, b);add(b,a);
    }
    dfs(1);
    cout<<ans<<endl;
    
    return 0;
}

树与图的的宽度优先遍历

q.push()

while(q不空){
	t=q.top();q.pop();
	拓展与t相邻的点
	if(第一次遍历){
		处理
	}
}

对应习题：acwing847 图中点的层次

//代码
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N=1e5+5;

int n,m;
int h[N],e[N],ne[N*2],idx;
int d[N],q[N];

void add(int a,int b)
{
    e[idx]=b;
    ne[idx]=h[a];
    h[a]=idx;
    idx++;
}

int bfs()
{
    memset(d,-1,sizeof d);
    
    int hh=0,tt=0; //hh指向对头元素，tt指向队尾元素
    q[0]=1;
    d[1]=0;//勿忘！
    while(hh<=tt){
        int t=q[hh];hh++;
        for(int i=h[t];i!=-1;i=ne[i])
        {//扩展每个点的临边
            int j=e[i];
            if(d[j]==-1){
                d[j]=d[t]+1;
                tt++;q[tt]=j;
            }
        }
    }
    return d[n];
}

int main()
{
    cin>>n>>m;
    
    memset(h, -1, sizeof h);
    
    for(int i=0;i<m;i++){
        int a,b;
        cin>>a>>b;
        add(a, b);
    }
    int res=bfs();
    
    cout<<res<<endl;
    return 0;
}

拓扑排序：图宽搜的应用

有向图才会有拓扑序列 有环一定不存在拓扑序
可以证明一个有向无环图（拓扑图）一定存在拓扑序列

入度：多少条边指向自己。出度：多少条边从自己出去。

所有入度为0的点都可以作为拓扑序的起点

​ 把所有入度为0的点入队

​ while（队列不空）{

​ t=队头

​ 枚举t的所有出边

​ 删掉 t—>j ( 就是d[j]-- )

​ if(d[j]==0) j 入队

​ }

练习：拓扑排序

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1e5+10;

int n,m;
int h[N],e[N],ne[N],idx;
int q[N],d[N];//q队列 d存每个点的入度

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

int topsort()
{
    int hh=0,tt=-1;
    
    for(int i=1;i<=n;i++){
        if(d[i]==0) q[++tt]=i;
    }
    
    while(hh<=tt){
        int t=q[hh];hh++;
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            d[j]--;//勿忘！ t是入度为0的一个点 删掉了t j的入度便-1
            if(d[j]==0)q[++tt]=j;
        }
    }
    return n-1==tt;
}

int main()
{
    cin>>n>>m;
    
    memset(h,-1,sizeof h);
    
    while (m -- ){
        int a,b;
        cin>>a>>b;
        add(a, b);
        d[b]++;//b的入度+1
    }
    
    if(topsort())
    {
        for(int i=0;i<n;i++)printf("%d ",q[i]);
        puts("");
    }
    else 
    {
        puts("-1");
    }
    
    return 0;
}

m – ){
int a,b;
cin>>a>>b;
add(a, b);
d[b]++;//b的入度+1
}

if(topsort())
{
    for(int i=0;i<n;i++)printf("%d ",q[i]);
    puts("");
}
else 
{
    puts("-1");
}

return 0;

}