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.
M pairs of integers (a_i, b_i) where 1 ≤ a_i, b_i ≤ N.
### 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, where each tuple contains two integers
'''
```
Test Case Generator
Sure, let's write a test case generator for the provided competitive programming problem statement about the graph and minimum spanning tree.
To generate test cases, we need to consider the constraints and the requirements mentioned:
- \(2 \leq N \leq 20\)
- \(N-1 \leq M \leq N(N-1)/2\)
- The subgraph consisting of Vertex 1,2,\ldots,N and Edge 1,2,\ldots,N-1 must be a spanning tree.
- The graph is simple, connected, and undirected without self-loops or multiple edges.
Here's the Python code for generating test cases based on the above constraints:
```python
import random
def generate_spanning_tree(N):
""" Generate a spanning tree with N vertices. """
edges = []
for i in range(2, N + 1):
u = i
v = random.randint(1, i - 1)
edges.append((u, v))
return edges
def generate_additional_edges(N, M, current_edges):
""" Generate additional edges to ensure the graph has M edges in total. """
all_possible_edges = [(i, j) for i in range(1, N + 1) for j in range(i + 1, N + 1)]
existing_edges_set = set(current_edges)
remaining_edges = [edge for edge in all_possible_edges if edge not in existing_edges_set]
additional_edges_needed = M - (N - 1)
additional_edges = random.sample(remaining_edges, additional_edges_needed)
return additional_edges
def tcgen():
# Step 1: Randomly choose N
N = random.randint(2, 20)
# Step 2: Randomly choose M such that N-1 <= M <= N(N-1)/2
min_edges = N - 1
max_edges = (N * (N - 1)) // 2
M = random.randint(min_edges, max_edges)
# Step 3: Generate a spanning tree
spanning_tree_edges = generate_spanning_tree(N)
# Step 4: Generate additional edges to reach a total of M edges
additional_edges = generate_additional_edges(N, M, spanning_tree_edges)
# Combine all edges
all_edges = spanning_tree_edges + additional_edges
# Formatting output
result = [f"{N} {M}"]
for edge in all_edges:
result.append(f"{edge[0]} {edge[1]}")
return "\n".join(result)
# Generate a test case and print it
print(tcgen())
```
Explanation:
1. **generate_spanning_tree(N)**: Generates a spanning tree with \(N\) vertices ensuring that there are \(N-1\) edges.
2. **generate_additional_edges(N, M, current_edges)**: Generates additional edges to ensure the total number of edges is \(M\). It avoids duplicate and self-loops.
3. **tcgen()**: The main function that combines the above steps to generate a complete test case.
This generator ensures that the graph is always connected and adheres to the constraints mentioned in the problem statement.
Extract Arguments
def extract_arguments(fh):
N, M = map(int, fh.readline().strip().split())
edges = [tuple(map(int, fh.readline().strip().split())) for _ in range(M)]
return N, M, edges