用C ++實現無向圖算法中的循環

Question

所以基本上我想在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) to

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

Answer 2

我發現了第一個錯誤。 找到循環時，您沒有更新cycleCount變量。 即

                    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);
                    }

用。。。來代替

                    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)) {
                            cycleCount++;
                            cycles.push_back(normal);
                        }

                    }

我的建議只針對這個錯誤：刪除edgeCount和cycleCount ，你可以通過使用cycles.size()和edges.size()來計算它們的數量

我也改變了打印到cout：

in void runCycleSearch() function:

    cout << "Cycles:\n";
    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;
        cout << "\n";
    }

但是這段代碼非常粗心並且充滿了錯誤。 例如關於案例

4
1 2 0
2 3 0
3 4 0
1 4 0

它回來了

Cycles:
1 2 4 0
1 3 2 0
2 4 3 0
1 4 3 0

我可以繼續更正此代碼，但對我來說，從頭開始重寫更容易:)有很多問題：

1. 圖表表示為邊緣列表，因此查找特定邊緣需要O（E）時間。 這是非常低效的，用鄰接列表替換它
2. 盡量避免復制對象，每個向量都在復制，例如isNew(Path a)你需要將它替換為可能的引用。
3. 在線性時間內檢查路徑中頂點的存在。 為此目的使用全局集或無序集。 您還可以使用全局路徑變量，並且不需要在每次遞歸調用時復制它。