Problem:
Score : 300 points

Problem Statement

We 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.

Input

Input 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

Output

Print the number of combinations of "on" and "off" states of the switches that light all the bulbs.

Sample Input 1

2 2
2 1 2
1 2
0 1

Sample Output 1

1

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 2

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

Sample Output 2

0

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 3

5 2
3 1 2 5
2 2 3
1 0

Sample Output 3

8

Solution in Rust (1.15.1) (judge verdict: Accepted)

// mod custom_lib;
use std::collections::HashMap;

use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
  let stdin = stdin();
  let stdin = stdin.lock();
  let token: String = stdin
    .bytes()
    .map(|c| c.expect("failed to read char") as char)
    .skip_while(|c| c.is_whitespace())
    .take_while(|c| !c.is_whitespace())
    .collect();
  token.parse().ok().expect("failed to parse token")
}

pub fn read_n<T: FromStr>(n: u32) -> Vec<T> {
  read_n_logic::<T>(n, vec![])
}

pub fn read_n_logic<T: FromStr>(n: u32, mut a: Vec<T>) -> Vec<T> {
  match n {
    0 => a,
    _ => {
      a.push(read::<T>());
      read_n_logic(n - 1, a)
    }
  }
}

fn main() {
  let n = read::<u32>();
  let m = read::<u32>();

  let mut s_map: HashMap<u32, Vec<u32>> = HashMap::new();
  let light_status = vec![0; m as usize];
  let mut answer = 0;

  for k_index in 0..m {
    let k = read::<u32>();
    let conn_switch = read_n::<u32>(k);
    for switch in conn_switch {
      if s_map.contains_key(&switch) {
        let mut prev_vec = s_map.get_mut(&switch).unwrap();
        prev_vec.push(k_index);
      } else {
        s_map.insert(switch, vec![k_index]);
      }
    }
  }

  let idial_light_status = read_n::<u32>(m);


  let two: i32 = 2;
  for i in 0..two.pow(n) {
    let result: String = format!("{:0>keta$b}", i, keta = n as usize);
    let mut clone_status = light_status.clone();

    for (keta, value) in result.chars().enumerate() {
      if value == '1' {
        search(&mut clone_status, (keta + 1) as u32, &s_map);
      }
    }

    if check_the_same(&clone_status, &idial_light_status) {
      answer += 1
    };
  }

  println!("{}", answer);
}

fn search(current_status: &mut Vec<u32>, change_switch: u32, s_map: &HashMap<u32, Vec<u32>>) {
  let target_lights = match s_map.get(&change_switch) {
    Some(s) => s,
    None => return,
  };

  for light in target_lights {
    current_status[*light as usize] = if current_status[*light as usize] == 0 {
      1
    } else {
      0
    };
  }
}

fn check_the_same(c_status: &Vec<u32>, i_status: &Vec<u32>) -> bool {
  let c_status_str: String = c_status
    .into_iter()
    .map(|i| i.to_string())
    .collect::<String>();
  let i_status_str: String = i_status
    .into_iter()
    .map(|i| i.to_string())
    .collect::<String>();
  if i_status_str == c_status_str {
    true
  } else {
    false
  }
}