Problem p02108 - Generation 2

Orig Description

Problem K: Donuts Purchase
Problem
Rafui has nothing to do during her vacation and she somehow wants to eat donuts, so she decided to go around the stores and buy donuts.
There is one donut store in each town, and all donut stores are closed on odd days.
Because Rafui has preferences for donuts, the satisfaction gained from each store is different.
So Rafui decided to act optimally to get as much satisfaction as possible.
In the world where Rafui lives, there are n towns numbered from 0 to n-1, and they are connected by m roads.
Each road is one-way, and Rafui can move from town ai to town bi.
At first, Rafui is in town 0 on an even day.
Rafui moves to another town by crossing one road once a day without staying in the town.
When Rafui arrives at town i on a certain day, she purchases one donut at the store if it is open and gains satisfaction ci.
She can visit the same town any number of times, but can only purchase once at each store.
Find the maximum sum of satisfaction obtained by Rafui when she acts optimally until she cannot get any more satisfaction.
Input
n m
c0 ... cn−1
a0 b0
...
am−1 bm−1
All input is given as an integer.
The first line contains the number of towns n and the number of roads m separated by a space.
The second line contains the satisfaction Rafui can get if she buys a donut at the store in town i.
The next m lines give the information of the roads, represented by ai and bi separated by a space.
Constraints
The input satisfies the following conditions.
1 ≤ n ≤ 105
0 ≤ m ≤ min(n×(n−1),105)
0 ≤ ci ≤ 1000
0 ≤ ai,bi ≤ n − 1
There are no self-loops or multiple edges.
Output
Print the maximum sum of satisfaction on one line.
Sample Input 1
2 1
1 2
0 1
Sample Output 1
1
Sample Input 2
5 5
1 1 1 1 1
0 1
1 2
2 3
3 0
3 4
Sample Output 2
3
Sample Input 3
4 4
1 1 1 1
0 1
1 2
2 0
2 3
Sample Output 3
4

Extracted Specification

Canonicalized Input Description:

An integer n (1 ≤ n ≤ 10^5), representing some quantity.
An integer m (0 ≤ m ≤ min(n×(n−1), 10^5)), representing some quantity.
A list of integers c of size n, where each integer is between 0 and 1000.
m pairs of integers (a, b), where 0 ≤ a, b ≤ n - 1.

### Example Input:

```
5 5
1 1 1 1 1
0 1
1 2
2 3
3 0
3 4
```

### Function Signature:
Write a function f(n, m, c, roads) that takes in the input.
def f(n: int, m: int, c: List[int], roads: List[Tuple[int, int]]):
    '''
    n: an integer
    m: an integer
    c: a list of integers
    roads: a list of tuples of integers
    '''

Test Case Generator

Here's a test case generator for the provided competitive programming problem "Donuts Purchase":

```python
import random

def tcgen():
    # Number of towns (1 ≤ n ≤ 10^5)
    n = random.randint(1, 10**5)
    
    # Maximum number of roads: min(n*(n-1), 10^5)
    max_m = min(n * (n - 1), 10**5)
    m = random.randint(0, max_m)
    
    # Satisfaction values for each town (0 ≤ ci ≤ 1000)
    satisfaction = [random.randint(0, 1000) for _ in range(n)]
    
    roads = set()
    while len(roads) < m:
        a = random.randint(0, n - 1)
        b = random.randint(0, n - 1)
        if a != b:
            roads.add((a, b))
    
    roads = list(roads)
    
    # Format the input as a string
    input_data = f"{n} {m}\n" + " ".join(map(str, satisfaction)) + "\n"
    for road in roads:
        input_data += f"{road[0]} {road[1]}\n"
    
    return input_data

# Generate a test case and print it
print(tcgen())
```

### Explanation of the Code:
1. **Number of Towns `n`:** Randomly generated between 1 and \(10^5\).
2. **Number of Roads `m`:** Randomly generated between 0 and the minimum of \(n \times (n - 1)\) and \(10^5\), ensuring the constraints are satisfied.
3. **Satisfaction Values `ci`:** A list of `n` integers where each integer is randomly chosen between 0 and 1000.
4. **Roads `ai` and `bi`:** A set is used to ensure there are no duplicate roads or self-loops; roads are then randomly generated.
5. **Formatting the Input:** The input is formatted according to the problem statement.

This generator will create diverse test cases within the specified constraints, useful for testing solutions to the problem.

Extract Arguments

def extract_arguments(fh):
    n, m = map(int, fh.readline().strip().split())
    c = list(map(int, fh.readline().strip().split()))
    roads = [tuple(map(int, fh.readline().strip().split())) for _ in range(m)]
    return n, m, c, roads