Problem p03031 - Generation 3

Orig Description

Score : 300 points
Problem StatementWe have N switches with "on" and "off" state, and M bulbs. The switches are numbered 1 to N, and the bulbs are numbered 1 to M.
Bulb i is connected to k_i switches: Switch s_{i1}, s_{i2}, ..., and s_{ik_i}. It is lighted when the number of switches that are "on" among these switches is congruent to p_i modulo 2.
How many combinations of "on" and "off" states of the switches light all the bulbs?
Constraints
1 \leq N, M \leq 10
1 \leq k_i \leq N
1 \leq s_{ij} \leq N
s_{ia} \neq s_{ib} (a \neq b)
p_i is 0 or 1.
All values in input are integers.
InputInput is given from Standard Input in the following format:
N M
k_1 s_{11} s_{12} ... s_{1k_1}
:
k_M s_{M1} s_{M2} ... s_{Mk_M}
p_1 p_2 ... p_M
OutputPrint the number of combinations of "on" and "off" states of the switches that light all the bulbs.
Sample Input 12 2
2 1 2
1 2
0 1
Sample Output 11
Bulb 1 is lighted when there is an even number of switches that are "on" among the following: Switch 1 and 2.
Bulb 2 is lighted when there is an odd number of switches that are "on" among the following: Switch 2.
There are four possible combinations of states of (Switch 1, Switch 2): (on, on), (on, off), (off, on) and (off, off). Among them, only (on, on) lights all the bulbs, so we should print 1.
Sample Input 22 3
2 1 2
1 1
1 2
0 0 1
Sample Output 20
Bulb 1 is lighted when there is an even number of switches that are "on" among the following: Switch 1 and 2.
Bulb 2 is lighted when there is an even number of switches that are "on" among the following: Switch 1.
Bulb 3 is lighted when there is an odd number of switches that are "on" among the following: Switch 2.
Switch 1 has to be "off" to light Bulb 2 and Switch 2 has to be "on" to light Bulb 3, but then Bulb 1 will not be lighted. Thus, there are no combinations of states of the switches that light all the bulbs, so we should print 0.
Sample Input 35 2
3 1 2 5
2 2 3
1 0
Sample Output 38

Extracted Specification

An integer N (1 ≤ N ≤ 10), representing some quantity or size.
An integer M (1 ≤ M ≤ 10), representing some quantity or size.
M lines each containing an integer k_i (1 ≤ k_i ≤ N) followed by k_i integers (1 ≤ s_{ij} ≤ N).
A list of M integers, where each integer is either 0 or 1.

### Example Input:

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

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

Test Case Generator

Sure! Let's create a test case generator based on the problem statement you provided. The generator will create random values for the number of switches, bulbs, their connections, and the parity conditions for each bulb. Here's a Python function to generate test cases:

```python
import random

def generate_test_case():
    N = random.randint(1, 10)  # Number of switches
    M = random.randint(1, 10)  # Number of bulbs
    
    bulbs = []
    for _ in range(M):
        k_i = random.randint(1, N)
        s_i = random.sample(range(1, N + 1), k_i)  # Choose k_i unique switches
        bulbs.append((k_i, s_i))
    
    p = [random.randint(0, 1) for _ in range(M)]  # Parity conditions for each bulb
    
    print(N, M)
    for b in bulbs:
        print(b[0], ' '.join(map(str, b[1])))
    print(' '.join(map(str, p)))

# Example usage
generate_test_case()
```

### Explanation
1. **N and M**: Generate the number of switches (`N`) and bulbs (`M`), both within the range [1, 10].
2. **Bulb Connections**: For each bulb, determine the number of switches it's connected to (`k_i`) and then choose `k_i` unique switches randomly from the range [1, N].
3. **Parity Conditions**: Generate a list of parity conditions (`p_i`) for each bulb, where each condition is either 0 or 1.
4. **Output Format**: Print the generated input in the specified format.

### Example Output
The function will produce output in the form:
```
3 2
2 1 2
1 3
0 1
```
This output corresponds to:
- 3 switches and 2 bulbs.
- Bulb 1 is connected to switches 1 and 2.
- Bulb 2 is connected to switch 3.
- Parity conditions: Bulb 1 lights up if the number of "on" switches is even, and Bulb 2 lights up if the number of "on" switches is odd.

You can call `generate_test_case()` multiple times to generate different test cases for your problem.

Extract Arguments

def extract_arguments(fh):
    N, M = map(int, fh.readline().strip().split())
    switches_to_bulbs = []
    for _ in range(M):
        line = list(map(int, fh.readline().strip().split()))
        k_i = line[0]
        s_i = line[1:]
        switches_to_bulbs.append((k_i, s_i))
    p = list(map(int, fh.readline().strip().split()))
    return N, M, switches_to_bulbs, p