Find if a Degree Sequence can form a Simple Graph | Havel-Hakimi Algorithm

A degree chain in graph theory indicates the order of vertices' degrees. It is crucial to ascertain whether a degree order can result in a simple graph, or a graph without parallel or self−looping edges. We will examine three approaches to resolving this issue in this blog, concentrating on the Havel−Hakimi algorithm. We'll go over the algorithm used by each technique, offer related code representations with the appropriate headers, and show off each approach's unique results.

Methods Used

• Havel−Hakimi Algorithm

• Sort & check

• Direct Count

Havel− Hakimi Algorithm

The Havel−Hakimi algorithm is a popular technique for figuring out whether a degree sequence can result in a straightforward graph. Up until an initial case is attained, degrees are eliminated one at a time.

Algorithm

• Arrange the degree series in descending order using the following algorithm.

• Return true if the degree chain is zero (it creates a simple graph).

• Return false (it cannot form a simple graph) if the initial degree is unfavourable or higher than the sum of the remainder degrees.

• Subtract the initial degree from the list.

• Deduct 1 from the following 'k' degrees, where 'k' is the deleted degree's value.

• Perform from step 1−5 again.

Example

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

using namespace std;

bool havelHakimi(vector<int>& degrees) {
    sort(degrees.rbegin(), degrees.rend()); // Sort in non-increasing order

    while (!degrees.empty() && degrees.front() > 0) {
        int firstDegree = degrees.front();
        degrees.erase(degrees.begin()); // Remove the first degree

        if (firstDegree > degrees.size()) {
            return false;
        }

        for (int i = 0; i < firstDegree; ++i) {
            degrees[i]--;
        }

        sort(degrees.rbegin(), degrees.rend()); // Re-sort the sequence
    }

    return degrees.empty(); // Return true if the sequence is empty
}

int main() {
    // Test the havelHakimi function
    vector<int> degrees = {3, 1, 2, 3, 1, 0};
    bool result = havelHakimi(degrees);

    if (result) {
        cout << "The sequence can represent a valid graph." << endl;
    } else {
        cout << "The sequence cannot represent a valid graph." << endl;
    }

    return 0;
}

Output

The sequence cannot represent a valid graph.

Sort & Check

The second approach is sorting the degree series in a non−decreasing order and repeatedly determining if the prerequisites for a straightforward graph are met.

Algorithm

• Sort the degree series in descending order using the following algorithm.

• Repeat this process for every degree in the series.

• Return false if the present level is unfavourable or more numerous than the number of available degrees.

• If every degree passes the tests, return true (it creates a straightforward graph).

Example

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

using namespace std;

bool havelHakimiAlgorithm(vector<int>& degrees) {
    // Sort the degree sequence in non-increasing order
    sort(degrees.rbegin(), degrees.rend());

    while (!degrees.empty() && degrees[0] > 0) {
        int highestDegree = degrees[0];
        int n = degrees.size();

        // Check if the highest degree is greater than the number of remaining vertices
        if (highestDegree >= n) {
            return false;
        }

        // Remove the highest degree vertex
        degrees.erase(degrees.begin());

        // Decrease the degrees of its neighbors
        for (int i = 0; i < highestDegree; ++i) {
            degrees[i]--;
        }

        // Sort the degree sequence again
        sort(degrees.rbegin(), degrees.rend());
    }

    // If all degrees are zero, the degree sequence can form a simple graph
    return degrees.empty();
}

int main() {
    // Example degree sequence
    vector<int> degrees = {3, 3, 2, 2, 1};

    // Check if the degree sequence can form a simple graph
    bool canFormGraph = havelHakimiAlgorithm(degrees);

    if (canFormGraph) {
        cout << "The degree sequence can form a simple graph." << endl;
    } else {
        cout << "The degree sequence cannot form a simple graph." << endl;
    }

    return 0;
}

Output

The degree sequence cannot form a simple graph.

Direct Count

The fourth approach simply measures the number of levels meeting predetermined criteria to ascertain whether the sequence may be represented as a simple graph.

Algorithm

• Determine the number of degrees that are more than or equal to 0 and save the result in 'n'.

• Return false if 'n' is an odd number (it cannot form a simple graph).

• Measure and keep in 'k' the number of non−zero degrees that are more than the number of left degrees.

• Return false if 'k' is higher than the number of left degrees.

• Return true if all requirements are satisfied (it creates a basic graph).

Example

#include <iostream>
#include <vector>

using namespace std;

bool directCount(vector<int>& degrees) {
    int n = 0;
    int k = 0;

    for (int degree : degrees) {
        if (degree >= 0) {
            n++;
            if (degree > degrees.size() - n) {
                k++;
            }
        }
    }

    return (n % 2 == 0) && (k <= n);
}

int main() {
    // Test the directCount function
    vector<int> degrees = {3, 1, 2, 3, 1, 0};
    bool result = directCount(degrees);

    if (result) {
        cout << "The sequence can represent a valid graph." << endl;
    } else {
        cout << "The sequence cannot represent a valid graph." << endl;
    }

    return 0;
}

Output

The sequence can represent a valid graph.

Conclusion

In this post, we looked at three distinct approaches to figuring out whether a particular degree sequence can result in a straightforward graph. We talked about the Havel−Hakimi algorithm, which employs a method of gradual reduction to determine whether the formation of a graph is feasible. We also looked at the degree array approach, the straightforward count method, and the sort and check method, each of which had a different strategy for validating a basic graph's conditions. You can quickly decide whether or not a graph can be created from a particular degree sequence by comprehending and using these techniques. The method chosen will depend on the particular specifications and features of the current degree sequence.