Language: C++

// ConsoleApplication2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"


//#include <vector>
//
//enum eDirection {
//	RIGHT = 0,
//	DOWN,
//	LEFT,
//	UP,
//};
//const int direction[][2] = {
//	{ 1, 0 },{ 0, 1 },{ -1, 0 },{ 0, -1 },
//};
//using namespace std;
//class Solution {
//public:
//	vector<int> spiralOrder(vector<vector<int>>& matrix) {
//		int left = 0, top = 0, right = matrix[0].size() - 1, bottom = matrix.size() - 1;
//
//		int rows = matrix.size();
//		int cols = matrix.size();
//		const int size = rows*cols;
//		vector<int> result;
//
//		int dir = RIGHT;
//		int x = 0, y = 0;
//		for (int i = 0; i<size; i++) {
//			if (x >= left && x <= right && y >= top && y <= bottom) {
//				result.push_back(matrix[y][x]);
//				if (result.size() >= size) {
//					break;
//				}
//				if (dir == RIGHT) {
//					if (x == right) {
//						dir = DOWN;
//						top++;
//					}
//				}
//				else if (dir == DOWN) {
//					if (y == bottom) {
//						dir = LEFT;
//						right--;
//					}
//				}
//				else if (dir == LEFT) {
//					if (x == left) {
//						dir = UP;
//						bottom--;
//					}
//				}
//				else if (dir == UP) {
//					if (y == top) {
//						dir = RIGHT;
//						left++;
//					}
//				}
//				else {
//					//assert(0);
//				}
//				x = x + direction[dir][0];
//				y = y + direction[dir][1];
//			}
//		}
//		return result;
//	}
//};
//
//int main() {
//	std::vector<std::vector<int>> vec(3);
//	for (int i = 0; i < 3; i++) {
//		vec[i].resize(4);
//		for (int j = 0; j < 4; j++) {
//			vec[i][j] = j + i * 3 + 1;
//		}
//	}
//	Solution s;
//	s.spiralOrder(vec);
//
//	return 0;
//}
//
//
//struct ListNode {
//	int val;
//	ListNode *next;
//	ListNode(int x) : val(x), next(NULL) {}
//};
//
//class Solution {
//public:
//	ListNode* reverseKGroup(ListNode* head, int k) {
//		if (head == NULL)
//			return head;
//
//		ListNode* pRet = head;
//		ListNode* cur = head;
//		ListNode* pre = NULL;
//		ListNode* pPre = NULL;
//		ListNode* pNext = NULL;
//		ListNode* tmp = NULL;
//		bool bFirst = false;
//		for (int idx = 0;; idx++) {
//			if (pNext) {
//				cur = pNext;
//			}
//			else {
//				if (idx != 0)
//					break;
//			}
//
//			//get k
//			int i = 0;
//			for (i = 0; i<k; i++) {
//				if (cur) {
//					cur = cur->next;
//				}
//				else {
//					break;
//				}
//			}
//			if (i != k) {
//				break;
//			}
//			pNext = cur;
//
//			if (idx == 0) {
//				cur = head;
//			}
//			else {
//				cur = pPre->next;
//			}
//			for (i = 0; i<k; i++) {
//				pre = cur;
//				cur = cur->next;
//
//				if (i == 0) {
//					pPre = pre;
//					pre->next = pNext; //next
//					tmp = pre;
//				}
//				else {
//					pre->next = tmp;
//					tmp = pre;
//				}
//			}
//			if (idx == 0) {
//				pRet = tmp;
//			}
//			else {
//				pPre->next = tmp;
//			}
//		}
//
//		return pRet;
//	}
//};
//
//
//
//int main() {
//	ListNode* head = NULL;
//	ListNode* cur = NULL;
//	for (int i = 0; i < 5; i++) {
//		ListNode* node = new ListNode(i+1);
//		node->next = NULL;
//		if (head == NULL) {
//			head = node;
//			cur = head;
//		}
//		else {
//			cur->next = node;
//			cur = node;
//		}
//	}
//	Solution s;
//	s.reverseKGroup(head, 2);
//
//	return 0;
//}

//class Solution {
//public:
//	int _divide(long long dividend, long long divisor) {
//		if (dividend <= 0)
//			return 0;
//		if (dividend < divisor)
//			return 0;
//		if (dividend == divisor)
//			return 1;
//		else {
//			long long sum = divisor;
//			long long i = 1;
//			for (; ; i *= 2) {
//				sum = divisor*i;
//				if (sum > dividend)
//					break;
//			}
//			return i/2 + divide(dividend - i/2*divisor, divisor);
//		}
//	}
//
//	int divide(long dividend, long divisor) {
//		int flag = 1;
//		if (dividend == 0)
//			return 0;
//		if (dividend < 0) {
//			flag = -1;
//			dividend = -dividend;
//		}
//		if (divisor < 0) {
//			flag *= -1;
//			divisor = -divisor;
//		}
//		return flag*_divide(dividend, divisor);
//	}
//};
//
//int main() {
//	Solution s;
//	s.divide(7, -3);
//	return 0;
//}
//#include<string>
//#include<vector>
//using namespace std;
//
//class Solution {
//public:
//
//	bool isMatch(string s, string p) {
//		bool bRet = false;
//		for (int i = 0; i<p.size(); i++) {
//			if (p[i] == '*') {
//				if (i == p.size() - 1)
//					return true;
//				else {
//					string sub_p = p.substr(i + 1, p.size() - i - 1);
//					if (s.size() <= 0)
//						return false;
//					string sub_s = s.substr(i, s.size() - i);
//					int j = 0;
//					for (; j<sub_s.size(); j++) {
//						if (isMatch(sub_s.substr(j, sub_s.size() - j), sub_p)) {
//							return true;
//						}
//					}
//					if (j == sub_s.size())
//						return false;
//
//				}
//			}
//			else if (p[i] == '.') {
//
//			}
//			else {
//				if (s.size()<i)
//					return false;
//				if (p[i] != s[i])
//					return false;
//			}
//			if (i == p.size() - 1) {
//				if (s.size() - p.size() > 0)
//					return false;
//			}
//		}
//		return true;
//	}
//};
//
//
//int main() {
//	Solution s;
//	std::string a("ab"), b("a.*");
//	bool bRtn = s.isMatch(a, b);
//
//
//}

//struct ListNode {
//	int val;
//	ListNode *next;
//	ListNode(int x) : val(x), next(NULL) {}
//};
//
//class Solution {
//public:
//	ListNode* removeNthFromEnd(ListNode* head, int n) {
//		ListNode* cur = NULL;
//		int N = 0;
//		//depth
//		for (cur = head; cur; cur = cur->next) {
//			N++;
//		}
//		if (N == n) {
//			if (head)
//				return head->next;
//		}
//
//		int idx = 0;
//		for (cur = head;;) {
//			if (cur) {
//				if (idx == N - n - 1) {
//					if (cur->next) {
//						cur->next = cur->next->next;
//						break;
//					}
//					else {
//						break;
//					}
//				}
//				idx++;
//				cur = cur->next;
//			}
//			else {
//				break;
//			}
//		}
//		return head;
//
//	}
//};
//
//
//int main() {
//	ListNode* head = NULL;
//	ListNode* cur = NULL;
//	for (int i = 0; i < 5; i++) {
//		ListNode* node = new ListNode(i+1);
//		node->next = NULL;
//		if (head == NULL) {
//			head = node;
//			cur = head;
//		}
//		else {
//			cur->next = node;
//			cur = node;
//		}
//	}
//	Solution s;
//	s.removeNthFromEnd(head, 2);
//
//	return 0;
//}

//#include <vector>
//#include <string>
//using namespace std;
//
//class Solution {
//public:
//	void generateParenthesis(vector<string>& vec, string str, int open, int close, int n)
//	{
//		if (str.size() == n) {
//			vec.push_back(str);
//			return;
//		}
//
//		if (open < n / 2)
//			generateParenthesis(vec, str + "(", open + 1, close, n);
//		if (close < open)
//			generateParenthesis(vec, str + ")", open, close + 1, n);
//
//	}
//	vector<string> generateParenthesis(int n) {
//		vector<string> vec;
//		generateParenthesis(vec, "", 0, 0, n);
//		return vec;
//	}
//};
//
//int main() {
//	Solution s;
//	s.generateParenthesis(2);
//}



#include <iostream>
#include <vector>
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
#include <numeric>

using namespace std;

bool setValue(std::vector<std::vector<std::pair<int, int>>>& test,
	std::vector<int>& persons, int idx) {
	for (int i = 0; i < test[idx].size(); i++) {
		auto pr = test[idx][i];
		int val = persons[idx] == 1 ? (pr.second) : (1 - pr.second);
		if (persons[pr.first] == -1)
			persons[pr.first] = val;
		else {
			if (persons[pr.first] != val)
				return false;
		}
	}
	return true;
}

bool check(std::vector<std::vector<std::pair<int, int>>>& test,
	std::vector<int> persons, int idx, int& nResult) {
	if (idx >= persons.size()) {
		int cnt = std::accumulate(persons.begin(), persons.end(), 0);
		nResult = max(nResult, cnt);
		return true;
	}
	if (persons[idx] == -1) {
		std::vector<int> _persons = persons;
		bool bRtn = false;
		for (int k = 1; k >= 0; k--) {
			_persons[idx] = k;
			if (setValue(test, _persons, idx)) {
				if (check(test, _persons, idx + 1, nResult)) {
					bRtn = true;
				}
			}
		}
		return bRtn;
	}
	else {
		if (setValue(test, persons, idx)) {
			if (check(test, persons, idx + 1, nResult)) {
				return true;
			}
		}
	}
	return false;
}

int main() {
	int N;
	std::cin >> N;

	std::vector<std::vector<std::pair<int, int>>> test(N);

	for (int i = 0; i<N; i++) {
		int c;
		std::cin >> c;
		test[i].resize(c);
		for (int j = 0; j<c; j++) {
			int a, b;
			std::cin >> a >> b;
			test[i][j] = std::pair<int, int>(a - 1, b);
		}
	}

	std::vector<int> persons(N, -1);
	int nResult = -1;
	bool bRtn = check(test, persons, 0, nResult);

	std::cout << nResult;

	return 0;
}

Compiler output:
a.cc:4:10: fatal error: stdafx.h: No such file or directory
    4 | #include "stdafx.h"
      |          ^~~~~~~~~~
compilation terminated.