Problem p03600 - Generation 3

Orig Description

Score : 500 points
Problem StatementIn Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads.
The following are known about the road network:
People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom.
He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v.
If such a network exist, find the shortest possible total length of the roads.
Constraints
1 \leq N \leq 300
If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
A_{i, i} = 0
InputsInput is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
OutputsIf there exists no network that satisfies the condition, print -1.
If it exists, print the shortest possible total length of the roads.
Sample Input 13
0 1 3
1 0 2
3 2 0
Sample Output 13
The network below satisfies the condition:
City 1 and City 2 is connected by a road of length 1.
City 2 and City 3 is connected by a road of length 2.
City 3 and City 1 is not connected by a road.
Sample Input 23
0 1 3
1 0 1
3 1 0
Sample Output 2-1
As there is a path of length 1 from City 1 to City 2 and City 2 to City 3, there is a path of length 2 from City 1 to City 3.
However, according to the table, the shortest distance between City 1 and City 3 must be 3.
Thus, we conclude that there exists no network that satisfies the condition.
Sample Input 35
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Sample Output 382
Sample Input 43
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Sample Output 43000000000

Extracted Specification

An integer N (1 ≤ N ≤ 300), representing some quantity or size.
An N x N matrix of integers A, where for all i ≠ j, 1 ≤ A[i][j] = A[j][i] ≤ 10^9, and for all i, A[i][i] = 0.

### Example Input:

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

### Function Signature:
Write a function f(N, A) that takes in the input.
def f(N: int, A: List[List[int]]):
    '''
    N: an integer
    A: a list of lists of integers
    '''

Test Case Generator

Sure, here is a test case generator for the given problem statement:

```python
import random

def generate_valid_distance_matrix(N):
    """
    Generates a valid shortest distance matrix for a fully connected undirected graph with N nodes.
    """
    A = [[0] * N for _ in range(N)]

    # Generate a random distance matrix for the upper triangle
    for i in range(N):
        for j in range(i + 1, N):
            A[i][j] = random.randint(1, 10**9)
            A[j][i] = A[i][j] # Symmetric matrix

    return A

def generate_invalid_distance_matrix(N):
    """
    Generates an invalid shortest distance matrix for testing.
    """
    A = generate_valid_distance_matrix(N)
    
    # Introduce an inconsistency
    i, j = random.sample(range(N), 2)
    A[i][j] += random.randint(1, 10) # Make sure A[i][j] is not the sum of shortest paths

    return A

def tcgen():
    N = random.randint(1, 300)
    
    if random.random() > 0.5:
        A = generate_valid_distance_matrix(N)
    else:
        A = generate_invalid_distance_matrix(N)
    
    return N, A

# Example of generating test cases
N, A = tcgen()
print(N)
for row in A:
    print(' '.join(map(str, row)))
```

### Explanation:
1. **generate_valid_distance_matrix(N)**: This function creates a valid distance matrix for a fully connected undirected graph with `N` nodes. The distances are random integers between 1 and 10^9. It ensures that the matrix is symmetric and that the diagonal elements are zero.

2. **generate_invalid_distance_matrix(N)**: This function first generates a valid distance matrix and then introduces an inconsistency by modifying a randomly selected element to ensure it does not represent the shortest path.

3. **tcgen()**: This function randomly decides whether to generate a valid or invalid distance matrix and returns it along with the size `N`.

The generated test cases can be used to evaluate both the correctness and robustness of your algorithm for detecting valid and invalid road networks.

Extract Arguments

def extract_arguments(fh):
    N = int(fh.readline().strip())
    A = []
    for _ in range(N):
        A.append(list(map(int, fh.readline().strip().split())))
    return N, A