uva1599 bfs双向遍历 利用数组保存中间结果

  1. bfs双向遍历。
    a. 双向遍历可以保存多条最短路。
    b. 无权无向图,还可以提升bfs效率,是单向bfs的2倍。
  2. 利用额外的数组保存值。
  3. 反向遍历输出路径。

题目链接:http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=51300
通过双向遍历找到最短的多条路径并找到颜色最小的路径,将中间需要保存的最小颜色值保存在数组当中。利用额外数组保存距离等值。

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#define maxn 100000+5
using namespace std;
vector<int> g[maxn];//图的连通
vector<int> c[maxn];//图的颜色
int n,m,vis[maxn],d[maxn],ans[maxn];//d保存距离,ans保存最小颜色
int init(){//初始化
    int x,y;
    int temp;
    memset(vis,0,sizeof(vis));
    memset(d,0,sizeof(d));
    memset(ans,0,sizeof(ans));  
    for (int i=0;i<=n;i++)g[i].clear();
    for (int i=0;i<=n;i++)c[i].clear();
    for (int i=0;i<m;i++){
        cin>>x>>y;
        g[x].push_back(y);
        g[y].push_back(x);
        cin>>temp;
        c[x].push_back(temp);
        c[y].push_back(temp);
    }
}
void bfs1(int n)//进行距离的遍历,完成d数组。
{  
    memset(d,-1,sizeof(d));
    queue<int> q;  
    d[n]=0;  
    q.push(n);  
    while(!q.empty())  
    {  
        int u=q.front();q.pop();  
        int sz=g[u].size();  
        for(int v=0;v<sz;v++)  
        {  
            int vv=g[u][v];  
            if(vv==1)  
            {  
                d[1]=d[u]+1;  
                return;  
            }  
            if(d[vv]==-1)
            {  
                d[vv]=d[u]+1;  
                q.push(vv);  
            }  
        }  
    }  
    return;  
}  
void bfs2()//对颜色进行排序,并保存颜色
{  
    memset(vis,0,sizeof(vis));  
    queue<int> q;  
    q.push(1);  
    while(!q.empty())  
    {  
        int u=q.front();q.pop();  
        if(d[u]==0) return;  
        int sz=g[u].size();  
        int mm=-1;  
        for(int i=0;i<sz;i++)//找到最小的颜色  
        {  
            int vv=g[u][i];  
            if(d[vv]==d[u]-1)  
            {  
                if(mm==-1)  
                    mm=c[u][i];  
                else  
                    mm=min(mm,c[u][i]);  
            }  
        }  
        int t=d[1]-d[u];  
        if(ans[t]==0) ans[t]=mm;  
        else  
            ans[t]=min(mm,ans[t]);  
        for(int v=0;v<sz;v++)  //将同时满足条件的节点加入队列,并同时进行bfs。
        {  
            int vv=g[u][v];  
            if(vis[vv]==0&&d[vv]==d[u]-1&&c[u][v]==mm)  
            {  
                q.push(vv);  
                vis[vv]=1;  
            }  
        }//通过额外的数组保存最小的颜色来筛选出不符合的同等条件后序遍历结果。若输出节点则还需进行标识并在此回返。
    }  
    return;  
}  
int main()
{
    while (cin>>n>>m){
        init();
        bfs1(n);
        bfs2();
        printf("%d\n",d[1]);  
        for(int i=0;i<d[1];i++)  
        {  
            if(i) printf(" ");  
            printf("%d",ans[i]);  
        }  
        printf("\n");  
    }
}
<think>好的,用户想了解如何在前端编写遍历树状数组的方法,包括递归和非递归的示例。我需要先理解树状数组的结构,然后分别考虑递归和迭代的实现方式。 首先,递归方法通常比较直观。根据引用3和引用4中的例子,递归遍历树结构时,通常会先处理当前节点,然后递归处理子节点。比如,深度优先遍历(DFS)可以用递归实现。用户可能希望看到如何通过递归访问每个节点,并执行某些操作,比如收集节点信息或者修改节点属性。 然后是非递归方法,也就是迭代法。引用4提到DFS可以用栈来实现,而广度优先遍历BFS)则用队列。我需要分别给出这两种方法的例子。例如,DFS的非递归实现可以用一个栈来保存待处理的节点,每次取出栈顶元素处理,并将其子节点逆序压入栈中,以保持正确的访问顺序。而BFS则使用队列,按层级处理节点。 另外,用户可能需要具体的代码示例,所以得用JavaScript写出递归和两种非递归(DFS和BFS)的方法。同时,需要注意代码的可读性和注释,方便用户理解。 还要考虑用户提到的树状数组结构,通常每个节点可能有children属性存储子节点。因此,在遍历时,需要检查节点的children是否存在且有元素,避免错误。 最后,根据引用中的信息,比如引用4提到的DFS和BFS的区别,以及如何处理子节点,需要确保示例代码正确反映这些概念。可能还需要提到遍历的应用场景,比如搜索、修改节点等,帮助用户理解何时使用哪种方法。</think>### 前端遍历树状数组的实现方法 树状数组(Tree Structure)在前端开发中常用于展示层级数据,例如菜单、组织结构等。遍历方法分为**递归**和**非递归**两种,其中非递归又包含**深度优先遍历(DFS)**和**广度优先遍历BFS)**两种策略。 --- ### 一、递归实现 递归是最直观的遍历方式,通过函数自身调用逐层处理子节点。以下是一个深度优先遍历的递归示例: ```javascript // 递归遍历树状数组(DFS) function recursiveTreeTraversal(tree, callback) { for (const node of tree) { callback(node); // 处理当前节点 if (node.children?.length > 0) { recursiveTreeTraversal(node.children, callback); // 递归处理子节点 } } } // 示例数据 const treeData = [ { id: 1, name: 'Root', children: [ { id: 2, name: 'Child 1', children: [] }, { id: 3, name: 'Child 2', children: [ { id: 4, name: 'Grandchild', children: [] } ]} ] } ]; // 使用示例:打印节点名称 recursiveTreeTraversal(treeData, node => console.log(node.name)); ``` **输出顺序**:`Root → Child 1 → Child 2 → Grandchild` **特点**:代码简洁,但需注意递归深度过大可能导致栈溢出[^3][^4]。 --- ### 二、非递归实现 非递归方法通过**栈(DFS)**或**队列(BFS)**模拟递归过程,避免栈溢出问题。 #### 1. 深度优先遍历(DFS) 使用栈结构实现,后进先出(LIFO): ```javascript function dfsTreeTraversal(tree, callback) { const stack = [...tree]; // 初始节点入栈 while (stack.length > 0) { const node = stack.pop(); // 取栈顶元素 callback(node); // 子节点逆序入栈,保证正序处理 if (node.children?.length) { stack.push(...[...node.children].reverse()); } } } // 使用示例 dfsTreeTraversal(treeData, node => console.log(node.name)); ``` **输出顺序**:`Root → Child 2 → Grandchild → Child 1` **适用场景**:文件目录遍历、依赖关系分析。 #### 2. 广度优先遍历BFS) 使用队列结构实现,先进先出(FIFO): ```javascript function bfsTreeTraversal(tree, callback) { const queue = [...tree]; // 初始节点入队 while (queue.length > 0) { const node = queue.shift(); // 取队首元素 callback(node); if (node.children?.length) { queue.push(...node.children); // 子节点入队 } } } // 使用示例 bfsTreeTraversal(treeData, node => console.log(node.name)); ``` **输出顺序**:`Root → Child 1 → Child 2 → Grandchild` **适用场景**:层级展开、最短路径搜索[^4]。 --- ### 三、方法对比 | 方法 | 数据结构 | 时间复杂度 | 空间复杂度 | 适用场景 | |--------|----------|------------|------------|------------------------| | 递归 | 函数调用栈 | $O(n)$ | $O(h)$ | 简单遍历、树深度较小 | | DFS | 栈 | $O(n)$ | $O(h)$ | 深度优先处理 | | BFS | 队列 | $O(n)$ | $O(w)$ | 层级处理、最短路径搜索 | *注:$h$为树的高度,$w$为树的最大宽度,$n$为节点总数。* ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值