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.
A list of M sublists, each containing integers. The first integer in each sublist represents k_i (1 ≤ k_i ≤ N), followed by k_i integers (1 ≤ integer ≤ N).
A list of M integers, each being either 0 or 1.
### Example Input:
```
2 2
2 1 2
1 2
0 1
```
### Function Signature:
Write a function f(N, M, data, P) that takes in the input.
def f(N: int, M: int, data: List[List[int]], P: List[int]):
'''
N: an integer
M: an integer
data: a list of lists of integers
P: a list of integers
'''
Test Case Generator
Sure! Below is a test case generator for the given problem statement regarding switches and bulbs.
The generator will create random values for \(N\) (number of switches) and \(M\) (number of bulbs), and for each bulb, it will also generate random values for \(k_i\) (number of switches connected to a bulb), the corresponding switch indices, and the value \(p_i\) (parity condition).
```python
import random
def generate_test_case():
# Step 1: Generate random values for N and M
N = random.randint(1, 10)
M = random.randint(1, 10)
# Step 2: Initialize arrays to store bulb configurations and parity conditions
bulb_configs = []
parity_conditions = []
# Step 3: Generate bulb configurations and parity conditions
for _ in range(M):
k_i = random.randint(1, N) # Random number of switches connected to this bulb
switches = random.sample(range(1, N + 1), k_i) # Randomly choose k_i unique switches
bulb_configs.append((k_i, switches))
parity_conditions.append(random.randint(0, 1)) # Random parity condition (0 or 1)
# Step 4: Format the test case as required by the problem statement
test_case_str = f"{N} {M}\n"
for k_i, switches in bulb_configs:
test_case_str += f"{k_i} " + " ".join(map(str, switches)) + "\n"
test_case_str += " ".join(map(str, parity_conditions)) + "\n"
return test_case_str
# Example usage
print(generate_test_case())
```
### Explanation of the Generator:
1. **Step 1:** Generate random values for \(N\) (number of switches) and \(M\) (number of bulbs), both between 1 and 10 as per the problem constraints.
2. **Step 2:** Initialize lists to store the configurations for each bulb and the parity conditions.
3. **Step 3:** For each bulb, generate:
- `k_i`: A random number of switches connected to the bulb.
- `switches`: A random sample of `k_i` unique switches from the available switches.
- Append these values to the `bulb_configs` list and randomly generate the parity condition \(p_i\) (either 0 or 1) and append it to the `parity_conditions` list.
4. **Step 4:** Format the generated test case into the required input format.
The function `generate_test_case` returns a string that represents a test case in the correct format. This string can be printed or used directly in a testing framework.
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