c++ - C++中无向图算法找环的实现

Question

所以基本上我想实现这个 Finding all cycles in undirected graphs在 C++ 中(唯一的区别是图表是加权的)，但这不是我现在的真正问题，因为我以后可能会处理它。

我尝试将 C# 代码重写为 C++，但我对 C++ 中的 OOP 仍然没有信心，我不太明白我做错了什么。我使用了调试器，我的程序甚至没有进入 findNewCycles 函数，我也很确定还有更多问题，但目前我想知道如何开始。我的 Path 类的构造函数有问题(至少调试器提示我这个)，但我不明白为什么。你能帮我么？这是我的代码:

#include <iostream>
#include <utility>
#include <vector>
#include <algorithm>

using namespace std;

class Graph {
        struct Edge {
                int vert[2];
                double value;
            public:
                Edge(int vec1, int vec2, double w) {
                    vert[0] = vec1;
                    vert[1] = vec2;
                    value = w;
                };
        };

        struct Path {
                vector<int> vertices;
                double totalValue;
            public:
                Path() : totalValue(0) {};
                Path(vector<int> v, double tv) : vertices(v), totalValue(tv) {};
                Path(const Path &a) {
                    totalValue = a.totalValue;
                    vertices = a.vertices;
                }
        };

        int vortexCount, edgeCount, cycleCount;
        vector<Path> cycles;
        vector<Edge> edges;

        void findNewCycles(Path a) {
            int n = a.vertices[0];
            int x;
            Path sub(a);

            for(int i = 0; i < edgeCount; i++) {
                for(int j = 0; j <=1; j++) {
                    if (edges[i].vert[j] == n) {
                        x = edges[i].vert[(j+1)%2];

                        if (!visited(x, a)) {
                            sub.totalValue += edges[i].value;
                            sub.vertices.insert(sub.vertices.begin(), x);
                            findNewCycles(sub);
                        }
                        else if ((a.vertices.size() > 2) && (x == a.vertices[a.vertices.size() - 1])) {
                            Path normal = normalize(a);
                            Path inv = invert(normal);
                            if(isNew(normal) && isNew(inv)) cycles.push_back(normal);
                        }
                    }
                }
            }
        }

        bool equals(Path a, Path b) {
            if((a.vertices.size() == b.vertices.size()) && (a.totalValue == b.totalValue)) {
                for (unsigned i=0; i < a.vertices.size(); i++) {
                    if(a.vertices[i] != b.vertices[i]) return false;
                }
                return true;
            }
            else return false;
        }

        Path invert(Path a) {
            Path inverted(a);
            reverse(inverted.vertices.begin(), inverted.vertices.end());
            return normalize(inverted);
        }

        Path normalize(Path a) {
            Path normalized(a);
            vector<int>::iterator smallest = min_element(normalized.vertices.begin(), normalized.vertices.end());
            std::rotate(normalized.vertices.begin(), smallest, normalized.vertices.end());
            return normalized;
        }

        bool isNew(Path a) {
            for(int i=0; i<cycleCount; i++) {
                if(equals(cycles[i], a)) {
                    return false;
                }
            }
            return true;
        }

        bool visited(int n, Path a) {
            for (unsigned i=0; i < a.vertices.size(); i++) {
                if(a.vertices[i] == n) return true;
            }
            return false;
        }

    public:
        Graph(int size) : vortexCount(size), edgeCount(0), cycleCount(0) {};
        ~Graph() {};

        vector<Edge>::iterator findEdge(int v1, int v2) {
            if(v1 == v2 || v1 > vortexCount || v2 > vortexCount) return edges.end();
            vector<Edge>::iterator iter;

            for(iter = edges.begin(); iter != edges.end(); ++iter) {
                if(iter->vert[0] == v1 && iter->vert[1] == v2) return iter;
                if(iter->vert[1] == v1 && iter->vert[0] == v2) return iter;
            }
            return edges.end();
        }

        bool addEdge(int v1, int v2, double value) {
            if(v1 == v2 || v1 > vortexCount || v2 > vortexCount) return false;

            vector<Edge>::iterator p = findEdge(v1, v2);

            if(p != edges.end()) {
                p->value = value;
            }
            else {
                Edge edge(v1, v2, value);
                edges.push_back(edge);
                edgeCount++;
            }
            return true;
        }

        void runCycleSearch() {
            for (int i = 0; i < edgeCount; i++) {
                for (int j = 0; j < 2; j++) {
                    cout << i << " " << j;
                    Path searchPath;
                    searchPath.vertices.push_back(edges[i].vert[j]);
                    findNewCycles(searchPath);
                }
            }

            for(int i=0; i<cycleCount; i++) {
                for(unsigned j=0; j<cycles[i].vertices.size(); j++) {
                    cout << cycles[i].vertices[j] << " ";
                }
                cout << cycles[i].totalValue;
            }
        }

};

int main() {
    int n, v1, v2;
    double val;
    bool control = true;

    cin >> n;
    Graph graph(n);

    while(control) {
        cin >> v1;
        if(v1 == -1) break;
        cin >> v2 >> val;

        control = graph.addEdge(v1, v2, val);
    }

    graph.runCycleSearch();
}

Answer 1

您确定要退出 while 循环吗？

在阅读输入后尝试添加这一行:

cout << "v1=" << v1 << ", v2=" << v2 << " val=" << val << endl;

并将while (control)更改为

for (int i=0; i < n; i++)