Problem:
Score : 300 points

Problem Statement

There are N people numbered 1 to N. Each of them is either an honest person whose testimonies are always correct or an unkind person whose testimonies may be correct or not.

Person i gives A_i testimonies. The j-th testimony by Person i is represented by two integers x_{ij} and y_{ij}. If y_{ij} = 1, the testimony says Person x_{ij} is honest; if y_{ij} = 0, it says Person x_{ij} is unkind.

How many honest persons can be among those N people at most?

Constraints

All values in input are integers.

1 \leq N \leq 15

0 \leq A_i \leq N - 1

1 \leq x_{ij} \leq N

x_{ij} \neq i

x_{ij_1} \neq x_{ij_2} (j_1 \neq j_2)

y_{ij} = 0, 1

Input

Input is given from Standard Input in the following format:

N
A_1
x_{11} y_{11}
x_{12} y_{12}
:
x_{1A_1} y_{1A_1}
A_2
x_{21} y_{21}
x_{22} y_{22}
:
x_{2A_2} y_{2A_2}
:
A_N
x_{N1} y_{N1}
x_{N2} y_{N2}
:
x_{NA_N} y_{NA_N}

Output

Print the maximum possible number of honest persons among the N people.

Sample Input 1

3
1
2 1
1
1 1
1
2 0

Sample Output 1

2

If Person 1 and Person 2 are honest and Person 3 is unkind, we have two honest persons without inconsistencies, which is the maximum possible number of honest persons.

Sample Input 2

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

Sample Output 2

0

Assuming that one or more of them are honest immediately leads to a contradiction.

Sample Input 3

2
1
2 0
1
1 0

Sample Output 3

1

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)


import java.util.Scanner;

class Main{
	public static void main(String[] args) {

		int maxNumberOfHonest = 0;
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] A = new int[N];

        //claim[i][x_ij] = y_ij 人iは人x_ijがy_ij（正直者1 or 不親切な人0　or　主張なし-1）だと主張している
        int[][] claim = new int[N][N];

        //claimを初期化
        for(int i=0;i<N;i++) {
        	for(int j=0;j<N;j++) {
        		claim[i][j] = -1;
        	}
        }

        //全員の主張を入力
        for(int i=0; i< N; i++) {
        	A[i] = sc.nextInt();
        	for(int j=0; j<A[i]; j++) {
        		int x_ij = sc.nextInt();
        		int y_ij = sc.nextInt();
        		claim[i][x_ij-1] = y_ij;
        	}
        }

        //2^N通りをbit全探査
        //例：001001であれば、６人の中で３人目と６人目だけが正直者
        //(1<<N) = 2^N
        for(int i=0;i<(1<<N);i++) {
        	int numberOfHonest = 0;

        	//assumptin[j] = 0 or1
        	//人jが正直者or不親切な人と仮定
        	//初期値は全員不親切な人
        	int[] assumption = new int[N];
        	for(int j=0;j<N;j++) {
        		assumption[j] = 0;
        	}

        	//正直者と仮定した人を探す
        	//人数も数えておく
        	for(int j=0;j<N;j++) {
        		if((1 & (i>>j))==1) { //iのjbit目が1かどうか　つまり　人jが正直者かどうか
        			assumption[j] = 1;
        			numberOfHonest ++;
        			}
        	}

        	//正直者の主張が、仮定と矛盾しないかチェックする
        	//矛盾する場合は、ループを続ける
        	//矛盾がなければ、ループを脱出する
        	boolean check = true;
        	for(int j=0;j<N;j++) {
        		if(assumption[j]==1) {
        			for(int k=0;k<N;k++) {
        				if(claim[j][k] == -1) continue;
        				if(claim[j][k] != assumption[k]) check = false;
        			}
        		}
        	}

        	if(check) maxNumberOfHonest = Math.max(numberOfHonest, maxNumberOfHonest);
        }
        
        System.out.println(maxNumberOfHonest);


	}

}