两次遍历一个图形，例如来回，然后返回向量中的路径

问题描述

我想遍历一个图两次，然后来回返回向量中的路径，它对于较小的节点值可以正常工作，但是当节点数很大时，例如：1000000个具有星形图的节点。它的工作太慢。此函数返回结果：vector plan（Iterator balconys_begin，Iterator balconys_end，size_t N）它给了我存储节点连接（to，from）的向量的开始和结束，N是节点号。 有什么想法可以使其更快吗？

struct Edge {
    int32_t to;
    bool used;
};

vector<int32_t>res;
vector< vector<Edge> > edge;
vector<bool> covered;
list<int32_t > chainlist;



void edgeuse(int node,int neighbour) {
    for (auto & i : edge[node]) {
        if (i.to == neighbour) {
            i.used = true;
        }
    }
}

void BFS(int start)
{
    stack<int32_t>dstack;
    dstack.push(start);

    vector<int32_t> wherefrom;
    wherefrom.resize(edge.size(),-1);

    while (!dstack.empty())
    {
        int next= dstack.top();
        dstack.pop();

        for(unsigned i=0;i<edge[next].size();i++)
        {
            if(!edge[next][i].used)
            {
                if (wherefrom[edge[next][i].to] == -1) {
                    wherefrom[edge[next][i].to] = next;
                }
                dstack.push(edge [next][i].to);
                if (edge [next][i].to == start) {

                    auto iter = find(chainlist.begin(),chainlist.end(),start);
                    iter++;

                
                    int node = wherefrom[start];
                  
                    covered[start] = true;

                    edgeuse(start,node);

                    while (node != start) {
                   
                        covered[node] = true;
                        chainlist.insert(iter,node);
                        edgeuse(node,wherefrom[node]);
                        node = wherefrom[node];
                    }
                    chainlist.insert(iter,node);
               
                    return;
                }
            }
        }
    }
    wherefrom.clear();

}
int next()
{
    for(unsigned int i=0;i<edge.size();i++)
    {
        if(covered[i]) {
            for (unsigned int j = 0; j < edge[i].size(); j++) {
                if (!edge[i][j].used) {
                    return i;
                }
            }
        }
    }
    return -1;
}

void add_Edge(int s,int d)
{
    edge[s].push_back({d,false});
    edge[d].push_back({s,false});

}
template <typename Iterator>
    vector<int32_t>plan(Iterator corridors_begin,Iterator corridors_end,size_t N)
{

    edge.resize(N);
    covered.resize(N,false);
    for(auto i=corridors_begin;i!=corridors_end;i++){
        add_Edge(i->from - 1,i->to - 1);
    }
    chainlist.push_back(0);
    int startnode = 0;
    do {
        BFS(startnode);
       
        for (auto i = chainlist.begin(); i != chainlist.end(); i++) {
    
        }
        startnode = next();
      
    } while (startnode != -1);
    res.clear();
    res.resize(chainlist.size());
    int index = 0;
    for (auto i = chainlist.begin(); i != chainlist.end(); i++,index++) {
       
        res[index] = *i + 1;
    }

    edge.clear();
    covered.clear();
    chainlist.clear();
    return res;
}

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）