Method search_bfs

Extensions/QMapping/SabreQMapping.cpp:137–204

* @brief 广度优先算法: Gets the connected subgraph of the specified number of nodes in the graph * @param[in, out] matched_subgraph : Holds the sum of the weights of the connected subgraph and the set of connected subgraphs * @param[in, out] temp : Holds the set of connected subgraph * @param[in, out] visited : Holds the flag for whether a node in the graph is accessed * @param[in] g

     * @param[in] target_num : The number of nodes of the target connected subgraph
     */
    void search_bfs(std::map<double, std::vector<std::vector<uint32_t>>, greater<double>>& matched_subgraph,
		std::vector<uint32_t>& temp, std::vector<bool>& visited, const ArchGraph::sRef g,
		std::vector<std::vector<double>>& fidelity,
		double weight, uint32_t u, int& quantum_num, int target_num)
    {
        auto handle_new_node_func = [&](const uint32_t new_node)->bool {
            temp.emplace_back(new_node);
            ++quantum_num;
            visited[new_node] = true;
            if (quantum_num == target_num)
            {
                /* 基于子图进行最短路径搜索 */
                ShortestDistanceByBFS sub_graph_shortest_distance;
                ArchGraph::sRef tmp_graph = build_sub_graph(temp, g);
                //ArchGraph::sRef tmp_graph = mArchGraph;
                //std::cout << "Got temp_graph: \n" << tmp_graph->dotify() << "\n------ graph_text end ------" << std::endl;
                sub_graph_shortest_distance.init(tmp_graph.get());

                /* Combine quantum circuit fidelity and quantum dispersion as weights */
                //const double res = /*sum * 0.2 +*/ m_shortest_distance.get_overall_dispersion(temp) * 10/*0.8*/;
                const double res = sub_graph_shortest_distance.get_overall_dispersion(temp);
                //std::cout << "Got sub graph_" << matched_subgraph.size() << " fidelity-res: " << res << std::endl;
                matched_subgraph[res].emplace_back(temp);
                return true; /* 找到合适子图，返回true */
            }

            return false; /* 未找到合适子图 */
        };

        bool b_find_sub_graph = false;
        std::vector<uint32_t> new_node_vec;
        for (uint32_t v : g->adj(u))
        {
            if (!visited[v])
            {
                /* 将每个相邻的点加入子图 */
                new_node_vec.emplace_back(v);

                /* 如果找到子图，就不再搜索，其他的子图组合会在对应的节点的子图搜索过程中，被发现 */
                if (handle_new_node_func(v))
                {
                    b_find_sub_graph = true;

					for (const uint32_t& new_v : new_node_vec)
                    {
                        visited[temp.back()] = false;
                        temp.pop_back();
                        --quantum_num;
                    }

                    new_node_vec.clear();
                }
            }
        }

        /* 如果本次搜索已经找到合适子图，就不再递归搜索 */
        if (b_find_sub_graph) 
        {