Problem p03052 - Generation 2

Orig Description

Score : 1200 points
Problem StatementYou are given a simple connected undirected graph G consisting of N vertices and M edges.
The vertices are numbered 1 to N, and the edges are numbered 1 to M.
Edge i connects Vertex a_i and b_i bidirectionally.
It is guaranteed that the subgraph consisting of Vertex 1,2,\ldots,N and Edge 1,2,\ldots,N-1 is a spanning tree of G.
An allocation of weights to the edges is called a good allocation when the tree consisting of Vertex 1,2,\ldots,N and Edge 1,2,\ldots,N-1 is a minimum spanning tree of G.
There are M! ways to allocate the edges distinct integer weights between 1 and M.
For each good allocation among those, find the total weight of the edges in the minimum spanning tree, and print the sum of those total weights modulo 10^{9}+7.
Constraints
All values in input are integers.
2 \leq N \leq 20
N-1 \leq M \leq N(N-1)/2
1 \leq a_i, b_i \leq N
G does not have self-loops or multiple edges.
The subgraph consisting of Vertex 1,2,\ldots,N and Edge 1,2,\ldots,N-1 is a spanning tree of G.
InputInput is given from Standard Input in the following format:
N M
a_1 b_1
\vdots
a_M b_M
OutputPrint the answer.
Sample Input 13 3
1 2
2 3
1 3
Sample Output 16
An allocation is good only if Edge 3 has the weight 3. For these good allocations, the total weight of the edges in the minimum spanning tree is 3, and there are two good allocations, so the answer is 6.
Sample Input 24 4
1 2
3 2
3 4
1 3
Sample Output 250
Sample Input 315 28
10 7
5 9
2 13
2 14
6 1
5 12
2 10
3 9
10 15
11 12
12 6
2 12
12 8
4 10
15 3
13 14
1 15
15 12
4 14
1 7
5 11
7 13
9 10
2 7
1 9
5 6
12 14
5 2
Sample Output 3657573092
Print the sum of those total weights modulo 10^{9}+7.

Extracted Specification

Canonicalized Input Description:

An integer N (2 ≤ N ≤ 20), representing some quantity or size.
An integer M (N-1 ≤ M ≤ N(N-1)/2), representing some quantity or size.
A list of M tuples, where each tuple contains two integers (1 ≤ a, b ≤ N), representing relationships between entities.

### Example Input:

```
3 3
1 2
2 3
1 3
```

### Function Signature:

Write a function f(N, M, edges) that takes in the input.
```python
def f(N: int, M: int, edges: List[Tuple[int, int]]):
    '''
    N: an integer
    M: an integer
    edges: a list of tuples with two integers each
    '''
```

Test Case Generator

Sure! Here is a test case generator for the competitive programming problem you provided. This generator creates a simple connected undirected graph with the constraints given.

```python
import random

def generate_spanning_tree(N):
    # Generate a random spanning tree using a union-find structure
    parent = list(range(N))
    edges = []

    def find(a):
        if parent[a] != a:
            parent[a] = find(parent[a])
        return parent[a]

    def union(a, b):
        rootA = find(a)
        rootB = find(b)
        if rootA != rootB:
            parent[rootB] = rootA
            return True
        return False

    # Ensure that the spanning tree has exactly N-1 edges
    for _ in range(N - 1):
        while True:
            a, b = random.sample(range(N), 2)
            if union(a, b):
                edges.append((a + 1, b + 1))  # convert to 1-based index
                break
    return edges

def tcgen():
    N = random.randint(2, 20)
    # M must be at least N-1 (spanning tree) and at most N(N-1)/2 (complete graph)
    M = random.randint(N - 1, N * (N - 1) // 2)
    
    # Generate a spanning tree
    spanning_tree_edges = generate_spanning_tree(N)

    # Generate additional edges to reach M edges
    all_possible_edges = set((min(a, b), max(a, b)) for a in range(1, N+1) for b in range(a+1, N+1))
    existing_edges = set(spanning_tree_edges)
    additional_edges = list(all_possible_edges - existing_edges)
    random.shuffle(additional_edges)
    additional_edges = additional_edges[:M - (N - 1)]
    
    # The final list of edges
    edges = spanning_tree_edges + additional_edges

    # Shuffle edges to ensure randomness
    random.shuffle(edges)

    return N, M, edges

def format_tc(N, M, edges):
    formatted_edges = "\n".join(f"{a} {b}" for a, b in edges)
    return f"{N} {M}\n{formatted_edges}"

# Example usage
if __name__ == "__main__":
    N, M, edges = tcgen()
    test_case = format_tc(N, M, edges)
    print(test_case)
```

### Explanation:

1. **generate_spanning_tree(N)**:
    - This function generates a random spanning tree for a graph with \(N\) vertices using the union-find structure to avoid cycles.
    - It ensures that the tree has exactly \(N-1\) edges.

2. **tcgen()**:
    - Randomly determines \(N\) (number of vertices) and \(M\) (number of edges) within the provided constraints.
    - Uses `generate_spanning_tree(N)` to ensure the graph contains a spanning tree subgraph.
    - Adds additional edges to reach \(M\) edges while avoiding self-loops and multiple edges.

3. **format_tc(N, M, edges)**:
    - Formats the generated graph into the required input format.

This generator will help create randomized test cases that meet the problem's constraints and ensure the proper structure of the graph.

Extract Arguments

def extract_arguments(fh):
    N, M = map(int, fh.readline().strip().split())
    edges = []
    for _ in range(M):
        a, b = map(int, fh.readline().strip().split())
        edges.append((a, b))
    return N, M, edges