# 5 Best Ways to Check Whether Given Degrees of Vertices Represent a Graph or Tree in Python

💡 Problem Formulation: When dealing with graph theory in Python, it’s common to ponder whether a sequence of vertex degrees represents a valid graph or a tree. A sequence can represent a graph if the sum of all vertex degrees is even. It can represent a tree if, in addition, the sum equals twice the number of edges. For example, consider the degree sequence [3, 2, 2, 1], which should be checked for both graph and tree properties.

## Method 1: Handshaking Lemma and Tree Properties

This method employs the Handshaking Lemma, asserting that a graph is valid if the sum of its degrees is even. To verify tree properties, it checks that there are exactly n-1 edges for n vertices. Here, the function `represents_graph_or_tree` returns a tuple (is_graph, is_tree).

Here’s an example:

```def represents_graph_or_tree(degrees):
n = len(degrees)
edges = sum(degrees) // 2
is_graph = sum(degrees) % 2 == 0
is_tree = is_graph and edges == n - 1
return is_graph, is_tree

degrees = [3, 2, 2, 1]
print(represents_graph_or_tree(degrees))
```

Output:

`(True, True)`

This example calculates the sum of the given degree sequence, then checks for evenness to determine whether it represents a graph and compares the number of edges to the number of vertices minus one to verify whether it represents a tree. The output is a tuple indicating that the sequence satisfies both conditions.

## Method 2: Using the Degree Sum Formula

The Degree Sum Formula, which states the sum of all vertex degrees must be equal to twice the number of edges, is applied here. This method is especially useful for validating the sequence as a graph.

Here’s an example:

```def is_valid_graph(degrees):
return sum(degrees) % 2 == 0

degrees = [3, 2, 2, 1]
print(is_valid_graph(degrees))
```

Output:

`True`

This snippet simply adds all values in the degree sequence and checks if the total is even, which indicates that the sequence could represent a graph according to the Degree Sum Formula.

## Method 3: Counting Leaf Nodes

To check if a degree sequence can represent a tree, it’s helpful to count leaf nodes, i.e., nodes with a degree of 1. For a valid tree with n vertices, there must be at least two leaf nodes.

Here’s an example:

```def can_be_tree(degrees):
leaves = degrees.count(1)
return leaves >= 2

degrees = [3, 2, 2, 1]
print(can_be_tree(degrees))
```

Output:

`True`

The function `can_be_tree` counts how many times 1 appears in the list, suggesting they are leaf nodes. If there are two or more leaf nodes, it may represent a tree, which is true for this degree sequence.

## Method 4: The Prüfer Code Method

The Prüfer Code is a unique sequence associated with labeled trees. By constructing the Prüfer Code and ensuring its length is n-2, we can check if a degree sequence represents a tree.

Here’s an example:

```from itertools import combinations

def is_tree_using_pruefer(degrees):
n = len(degrees)
pruefer_length = n - 2
return all(x <= n for x in degrees) and sum(degrees) == 2 * pruefer_length

degrees = [3, 2, 2, 1]
print(is_tree_using_pruefer(degrees))
```

Output:

`True`

This snippet ensures that all degrees are within the correct range for the vertex count and that the sum of degrees matches the double length of its expected Prüfer Code, hence validating the degree sequence as a tree.

## Bonus One-Liner Method 5: Using a Lambda Function

With a lambda function, we can quickly check if the given degree sequence represents a tree. This is a concise and efficient approach for simple sequences.

Here’s an example:

```degrees = [3, 2, 2, 1]
is_tree = lambda ds: sum(ds) == 2 * (len(ds) - 1)
print(is_tree(degrees))
```

Output:

`True`

The lambda function directly checks the tree condition by comparing the sum of degrees and twice the number of vertices minus two.

## Summary/Discussion

Method 1: Handshaking Lemma and Tree Properties. This approach is thorough and checks both graph and tree properties. However, it may be less efficient for larger sequences due to sequential operations. Method 2: Degree Sum Formula. It is a quick check for graph validity, but it does not confirm tree structure on its own. Best for initial graph validation. Method 3: Counting Leaf Nodes. This method is simple and intuitive but may not be sufficient as the sole criterion for tree validation because it does not consider the overall structure. Method 4: The Prüfer Code Method. It is a solid method for confirming tree structures given correct standards of coding. However, its implementation is more complicated than other methods. Method 5: Lambda Function. This is a quick and elegant one-liner suitable for simple checks but lacks robustness for complex validations and error handling.