Problem:
Save Your Privacy!
君のプライバシーを守れ!
English text is not available in this practice contest.
ICPC (International Committee of Privacy and Confidence) は世界中に多くの構成員を持つ組織であり、その名の通り非常にプライバシーを尊重する、秘密主義者たちの団体である。構成員たちは必要上他の構成員の個人情報を知ってしまうことがあるが、それらを厳重に秘匿するよう義務付けられている。
しかしある日、何人かの構成員の個人情報が漏洩してしまった！ICPCの ACM (Account Control Manager: アカウント管理責任者) であるあなたは、速やかに情報を漏洩させた構成員を特定し、厳重に処分しなければならない。
あなたは構成員よりも大きな権限を持つ管理者なので、誰が誰の個人情報を知ってしまっているかを完全に把握している。もちろん、どの構成員も自分の知らない構成員の個人情報を漏洩させることはありえない。しかし、犯人は自分が知っている全ての個人情報を漏洩させたとは限らない。個人情報が漏洩してしまった構成員の一覧から、どの構成員が個人情報を漏洩させたのかを (可能ならば) 特定しよう。
ところで、ICPC という組織が何を目的として活動しているのかは最重要機密であり、管理者の権限をもってしても知ることはできない。
Input
入力ファイルは複数のデータセットを含む。1 つのデータセットは、以下の形式で与えられる。
N
M
1
p
1,1
p
1,2
...
p
1,M
1
M
2
p
2,1
p
2,2
...
p
2,M
2
:
M
N
p
N,1
p
N,2
...
p
N,M
N
K
l
1
l
2
...
l
K
N (2 ≤ N ≤ 100) は構成員の数を表す整数である。それぞれの構成員には 1 から N までの番号が振られている。
続く N 行には各構成員の番号順に、その構成員が知っている個人情報の一覧が与えられる。各行の最初の整数 M
i
(0 ≤ M
i
≤ N)は、後に続く整数の個数を表す。残りの整数は、その構成員が個人情報を知っている構成員の番号を表す。
最後の行には、個人情報が漏洩した構成員の一覧が示される。 K (1 ≤ K ≤ N) は漏洩した構成員の人数を表し、残りの整数は漏洩した構成員の番号を表す。
入力は正しく与えられると仮定してよい。つまり、ある構成員が知っている個人情報の一覧として、同じ構成員の番号が 2 回以上与えられたり、存在しない構成員の番号が与えられることはない。漏洩した構成員の番号の一覧も同様である。
N = 0 のとき、入力は終了する。
Output
個人情報を漏洩させた構成員を特定できるならば、その構成員の番号を出力せよ。特定できない場合 -1 を出力せよ。
特定できない場合には、次の 2 つのケースがある。 1 つは、流出させた可能性がある構成員が 2 人以上挙げられる場合である。もう 1 つは、どの構成員が流出させたと仮定しても矛盾が生じる場合である。どちらの場合でも、あなたのプログラムは -1 と出力しなければならない。
Sample Input
3
2 2 3
1 1
1 1
2 2 3
3
2 2 3
1 3
1 2
1 2
5
3 1 3 4
4 1 3 4 5
2 1 3
2 1 2
0
3 1 3 5
3
2 2 1
1 1
1 2
3 3 2 1
0
Output for Sample Input
1
-1
2
-1

Submitted solutions:

code_snippet: #include<bits/stdc++.h>

#define rep(i,n) for(int i = 0; i < n; ++i)
#define all(x) x.begin(), x.end()
#define X firsst
#define Y second
#define pb push_back
using namespace std;

int main(void){
  int n;
  while(cin >> n && n){
    int m, t, k;
    vector<int> ss[128];
    rep(i,n){
      cin >> m;
      rep(j,m){
        cin >> t;
        t--;
        ss[t].pb(i);
      }
    }
//     rep(i,n){
//       rep(j,ss[i].size()){
//         cout << ss[i][j] << "<";
//       }
//       cout << endl;
//     }
    cin >> k;
    int used[128]={0};
    rep(i,k){
      cin >> t;
      t--;
      rep(j, ss[t].size()){
        used[ss[t][j]]++;
      }
    }
    int index = -1;
    rep(i,n){
      if(used[i] == k){
        if(index == -1){
          index = i;
        }else{
          index = -2;
        }
      }
    }
    if(index < 0){
      cout << -1 << endl;
    }else{
      cout << index+1 << endl;
    }
  }

  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3528
final_rank: 12

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using a2 = array<ll, 2>;
using a3 = array<ll, 3>;

template <typename A> void chmin(A &l, const A &r) {
    if(r < l)
        l = r;
}
template <typename A> void chmax(A &l, const A &r) {
    if(l < r)
        l = r;
}

ll mod = 998244353;

ll n;
void input() { cin >> n; }

void solve() {
    vector<set<ll>> know(n);
    for(int i = 0; i < n; i++) {
        ll a;
        cin >> a;
        for(int j = 0; j < a; j++) {
            ll b;
            cin >> b;
            know[i].insert(b);
        }
    }
    ll a;
    cin >> a;
    set<ll> sh;
    for(int i = 0; i < n; i++)
        sh.insert(i);
    for(int i = 0; i < a; i++) {
        ll b;
        cin >> b;
        for(int j = 0; j < n; j++) {
            if(know[j].count(b) == 0)
                sh.erase(j);
        }
    }
    cout << (sh.size() == 1 ? *sh.begin() + 1 : -1) << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    while(1) {
        input();
        if(n == 0)
            break;
        solve();
    }

    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3784
final_rank: 13

code_snippet: #include <bits/stdc++.h>
using namespace std;

bool solve() {
    int N;
    cin >> N;
    if (N == 0) return false;
    vector<set<int>> S(N);
    for (int i = 0; i < N; i++) {
        int M;
        cin >> M;
        while (M--) {
            int a;
            cin >> a;
            S[i].insert(a);
        }
    }
    int K;
    cin >> K;
    vector<int> A(K);
    for (int i = 0; i < K; i++) cin >> A[i];
    int ans = -1;
    for (int i = 0; i < N; i++) {
        auto T = S[i];
        bool ok = true;
        for (int a : A) {
            if (T.find(a) == T.end()) ok = false;
        }
        if (ok) {
            if (ans != -1) {
                ans = -1;
                break;
            }
            ans = i + 1;
        }
    }
    cout << ans << '\n';
    return true;
}

int main() {
    while (solve()) {}
}
accuracy: 1
time_ms: 10
memory_kb: 3968
final_rank: 15

code_snippet: // AOJ 2399 - Save Your Privacy!
// JAG Practice Contest for Japan Domestic 2012 - Problem A

#include <bits/stdc++.h>
using namespace std;

bool solving() {
  int N; cin >> N;
  if(N == 0) return false;

  vector<set<int>> know(N);
  for(int i=0; i<N; ++i) {
    int M; cin >> M;
    for(int j=0; j<M; ++j) {
      int p; cin >> p;
      know[i].insert(p);
    }
  }
  int K; cin >> K;
  vector<int> leaked(K);
  for(int i=0; i<K; ++i) cin >> leaked[i];

  vector<bool> sus(N, true);
  for(int i=0; i<K; ++i) {
    for(int j=0; j<N; ++j) {
      if(!know[j].count(leaked[i])) sus[j] = false;
    }
  }
  int culprit = -1;
  for(int i=0; i<N; ++i) {
    if(sus[i]) {
      if(culprit == -1) culprit = i+1;
      else {
        cout << -1 << endl;
        return true;
      }
    }
  }
  cout << culprit << endl;
  return true;
}

int main() {
  while(solving()) {}
}
accuracy: 1
time_ms: 20
memory_kb: 3880
final_rank: 20

code_snippet: #include <iostream>
#include <vector>
using namespace std;

int main() {
    while (true) {
        int N;
        cin >> N;
        if (N == 0) break;

        vector<vector<int>> list;
        for (int i = 0; i < N; i++) {
            int n2;
            cin >> n2;
            vector<int> arr(n2);
            for (int j = 0; j < n2; j++) {
                cin >> arr[j];
                arr[j]--; // Adjusting to 0-based index
            }
            list.push_back(arr);
        }

        int K;
        cin >> K;
        if (K == 0) {
            cout << -1 << endl;
            continue;
        }

        vector<int> checkarr(K);
        for (int i = 0; i < K; i++) {
            cin >> checkarr[i];
            checkarr[i]--; // Adjusting to 0-based index
        }

        int ans = -1;
        bool doublefound = false;
        for (int i = 0; i < list.size(); i++) {
            if (doublefound) break;
            vector<int>& arr2 = list[i];
            int cursol = 0;
            for (int j = 0; j < arr2.size(); j++) {
                if (arr2[j] == checkarr[cursol]) {
                    cursol++;
                    j = -1; // Reset j to start from the beginning
                    if (cursol == K) {
                        if (ans == -1) {
                            ans = i + 1; // Convert to 1-based index
                        } else {
                            doublefound = true;
                        }
                        break;
                    }
                }
            }
        }

        if (doublefound) {
            cout << -1 << endl;
        } else {
            cout << ans << endl;
        }
    }

    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3520
final_rank: 11

code_snippet: #include <bits/stdc++.h>
using namespace std;

using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define rep3(i, a, b, c) for (ll i = (a); i < (b); i += (c))
#define rep2(i, a, b) rep3(i, a, b, 1)
#define rep1(i, n) rep2(i, 0, n)
#define rep0(n) rep1(aaaaa, n)
#define ov4(a, b, c, d, name, ...) name
#define rep(...) ov4(__VA_ARGS__, rep3, rep2, rep1, rep0)(__VA_ARGS__)
#define per(i, a, b) for (ll i = (a) - 1; i >= (b); i--)
#define fore(e, v) for (auto&& e : v)
#define all(a) begin(a), end(a)
#define sz(a) (int)(size(a))
#define lb(v, x) (lower_bound(all(v), x) - begin(v))
#define eb emplace_back

template <typename T, typename S>
bool chmin(T& a, const S& b) {
  return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
bool chmax(T& a, const S& b) {
  return a < b ? a = b, 1 : 0;
}
const int INF = 1e9 + 100;
const ll INFL = 3e18 + 100;
#define i128 __int128_t
struct _ {
  _() { cin.tie(0)->sync_with_stdio(0), cout.tie(0); }
} __;

void solve();
int main(){
  while(1)solve();
}

void solve(){
  int N;
  cin>>N;
  if(N==0)exit(0);
  vector<set<int>> A(N);
  rep(i,N){
    int M;
    cin>>M;
    rep(M){
      int t;
      cin>>t;
      A[i].insert(t);
    }
  }
  int K;
  cin>>K;
  vi  X(K);
  fore(i,X)cin>>i;
  vi ans;
  rep(i,N){
    bool ok=1;
    fore(j,X){
      if(!A[i].contains(j))ok=0;
    }
    if(ok)ans.eb(i+1);
  }
  if(sz(ans)!=1)cout<<"-1\n";
  else cout<<ans[0]<<'\n';
}
accuracy: 1
time_ms: 10
memory_kb: 3968
final_rank: 15

code_snippet: #include <bits/stdc++.h>
#include <atcoder/all>
using namespace atcoder;
using namespace std;
#define all(...) std::begin(__VA_ARGS__), std::end(__VA_ARGS__)
#define rall(...) std::rbegin(__VA_ARGS__), std::rend(__VA_ARGS__)
#define OVERLOAD_REP(_1, _2, _3, _4, name, ...) name
#define REP1(n) for(ll i=0;i<n;i++)
#define REP2(i, n) for (ll i=0;i<n;i++)
#define REP3(i, a, n) for (ll i=a;i<n;i++)
#define REP4(i, a, b, n) for(ll i=a;i<n;i+=b)
#define rep(...) OVERLOAD_REP(__VA_ARGS__, REP4, REP3, REP2, REP1)(__VA_ARGS__)
#define OVERLOAD_RREP(_1, _2, _3, _4, name, ...) name
#define RREP1(n) for(ll i=n;i>=0;i--)
#define RREP2(i, n) for(ll i=n;i>=0;i--)
#define RREP3(i, a, n) for(ll i=n;i>=a;i--)
#define RREP4(i, a, b, n) for(ll i=n;i>=a;i-=b)
#define rrep(...) OVERLOAD_RREP(__VA_ARGS__, RREP4, RREP3, RREP2, RREP1)(__VA_ARGS__)
#define foa(a,v)  (auto& a : (v))
#define uniq(a) sort(all(a));a.erase(unique(all(a)),end(a))
#define len(n) (long long)(n).size()
#define pb push_back
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vs = vector<string>;
using vvs = vector<vs>;
using vvvs = vector<vvs>;
using vld = vector<ld>;
using vvld = vector<vld>;
using vvvld = vector<vvld>;
using vc = vector<char>;
using vvc = vector<vc>;
using vvvc = vector<vvc>;
using pll = pair<ll,ll>;
using vpll = vector<pll>;
template<class... T>
constexpr auto min(T... a){
    return min(initializer_list<common_type_t<T...>>{a...});
}
template<class... T>
constexpr auto max(T... a){
    return max(initializer_list<common_type_t<T...>>{a...});
}
template<class... T>
void input(T&... a){
    (cin >> ... >> a);
}
ll modpow(ll a,ll b,ll c){
    ll ans = 1;
    while (b){
        if (b & 1){
            ans *= a;
            ans %= c;
        }
        a *= a;
        a %= c;
        b /= 2;
    }
    return ans;
}
#define INT(...) int __VA_ARGS__; input(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__; input(__VA_ARGS__)
#define ULL(...) ull __VA_ARGS__; input(__VA_ARGS__)
#define LD(...) ld __VA_ARGS__; input(__VA_ARGS__)
#define STR(...) string __VA_ARGS__; input(__VA_ARGS__)
#define CHA(...) char __VA_ARGS__; input(__VA_ARGS__)
#define VLL(name,length) vll name(length);rep(i,length){cin >> name[i];}
#define VVLL(name,h,w) vvll name(h,vll(w));rep(i,h)rep(j,w){cin >> name[i][j];}
#define VVVLL(name,a,b,c) vvvll name(a,vvll(b,vll(c)));rep(i,a)rep(j,b)rep(k,c){cin >> name[i][j][k];}
#define VI(name,length) vi name(length);rep(i,length){cin >> name[i];}
#define VVI(name,h,w) vvi name(h,vi(w));rep(i,h)rep(j,w){cin >> name[i][j];}
#define VVVI(name,a,b,c) vvvi name(a,vvll(b,vi(c)));rep(i,a)rep(j,b)rep(k,c){cin >> name[i][j][k];}
#define VLD(name,length) vld name(length);rep(i,length){cin >> name[i];}
#define VVLD(name,h,w) vvld name(h,vld(w));rep(i,h)rep(j,w){cin >> name[i][j];}
#define VVVLD(name,a,b,c) vvvld name(a,vvld(b,vld(c)));rep(i,a)rep(j,b)rep(k,c){cin >> name[i][j][k];}
#define VC(name,length) vc name(length);rep(i,length){cin >> name[i];}
#define VVC(name,h,w) vvc name(h,vc(w));rep(i,h)rep(j,w){cin >> name[i][j];}
#define VVVC(name,a,b,c) vvvc name(a,vvc(b,vc(c)));rep(i,a)rep(j,b)rep(k,c){cin >> name[i][j][k];}
#define VS(name,length) vs name(length);rep(i,length){cin >> name[i];}
#define VVS(name,h,w) vvs name(h,vs(w));rep(i,h)rep(j,w){cin >> name[i][j];}
#define VVVS(name,a,b,c) vvvs name(a,vvs(b,vs(c)));rep(i,a)rep(j,b)rep(k,c){cin >> name[i][j][k];}
#define PLL(name) pll name;cin>>name.first>>name.second;
#define VPLL(name,length) vpll name(length);rep(i,length){cin>>name[i].first>>name[i].second;}

void print(){cout << "\n";}
template<class T, class... Ts>
void print(const T& a, const Ts&... b){cout << a;(cout << ... << (cout << ' ', b));cout << '\n';}
void print(vll x){rep(i,len(x)){cout << x[i];if(i!=len(x)-1){cout << " ";}else{cout << '\n';}}}
void print(vvll x){rep(i,len(x))rep(j,len(x[i])){cout << x[i][j];if(j!=len(x[i])-1){cout << " ";}else{cout << '\n';}}}



int main(){
    while(1){
        LL(n);
        if(n == 0){break;}
        vector<set<ll>> a(n);
        rep(i,n){
            LL(m);
            VLL(b,m);
            for(auto x:b){
                a[i].emplace(x);
            }
        }
        LL(k);
        VLL(c,k);
        auto solve = [&](){
            ll ans = -1;
            rep(i,n){
                ll cnt = 0;
                rep(j,k){
                    if(a[i].count(c[j])){
                        cnt++;
                    }
                }
                if(cnt == k){
                    if(ans != -1){
                        print(-1);
                        return;
                    }
                    ans = i+1;
                }
            }
            print(ans);

        };
        solve();
    }
}
accuracy: 1
time_ms: 10
memory_kb: 4096
final_rank: 17

code_snippet: #include<bits/stdc++.h>
using namespace std;
int main() {
  while (1) {
    int N;
    cin >> N;
    if (N == 0) {
      break;
    }
    vector<int> M(N);
    vector<set<int>> st(N);
    for (int i = 0; i < N; i++) {
      cin >> M[i];
      for (int j = 0; j < M[i]; j++) {
        int p;
        cin >> p;
        st[i].insert(p);
      }
    }
    int K;
    cin >> K;
    vector<int> l(K);
    for (int i = 0; i < K; i++) {
      cin >> l[i];
    }
    int ans = -1;
    for (int i = 0; i < N; i++) {
      int cnt = 0;
      for (int j = 0; j < K; j++) {
        if (st[i].count(l[j])) {
          cnt++;
        }
      }
      if (cnt == K) {
        if (ans == -1) {
          ans = i + 1;
        } else {
          ans = -1;
          break;
        }
      }
    }
    cout << ans << '\n';
  }
}
accuracy: 1
time_ms: 20
memory_kb: 3800
final_rank: 19

code_snippet: #include <bits/stdc++.h>
#define rep(i,j,n) for (long long i = j; i < (int)(n); i++)
#define REP(i,j,n) for (long long i = j; i <= (int)(n); i++)
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define all(x) (x.begin(), x.end())
template<typename T1, typename T2> inline bool chmax(T1 &a, T2 b){
  bool compare = (a < b);
  if(compare) a = b;
  return compare;
}
template<typename T1, typename T2> inline bool chmin(T1 &a, T2 b){
  bool compare = (a > b);
  if(compare) a = b;
  return compare;
}
string substrback(string s,size_t p,size_t l){
	//s=文字列　p=後ろから数えて何文字目　l=pから何文字目まで
	const size_t strl = s.length();
	return s.substr(strl - p,l);
}
//pair型のfirstで比較
bool comparePairs(const pair<ll,ll> &a, const pair<ll,ll> &b){
	if(a.first != b.first)
	return a.first<b.first;
	return a.second < b.second;
}
//pair型のsecondで比較
bool comparePairs2(const pair<ll,ll> &a, const pair<ll,ll> &b){
	if(a.second != b.second)
	return a.second<b.second;
	return a.first < b.first;
}
//pair型の１.second  と2.firstをつなげていく
bool customsort(const pair<ll,ll>  &a,const pair<ll,ll> &b){
	if(a.second == b.first){
		return true;
	}
	return false;
}
bool customsort2(const pair<ll, ll> &a, const pair<ll, ll> &b) {
    // 特定の値がfirstに出た場合、そのsecond値を先頭に持ってくる
    if (a.first == -1) {
        return true;
    } else if (b.first == -1) {
        return false;
    }
    return a.first < b.first;
}

//nの階乗
ull facto(ll n){
	if (n==0 || n ==1){
		return 1;
	} else {
		return n *facto(n-1);
	}
}
//nのΣ
ll sum(ll n) {
	ll sum =0;
	sum = n*(n+1)/2;
	return sum;
}
struct V {
	int a, b;
};
bool acom(const V& a, const V& b) {
	return a.a < b.a;
}
bool bcom(const V& a, const V& b) {
	return a.b < b.b;
}
bool isPrime(ll num){
	if(num==1)return false;
	if(num==2)return true;
	if(num % 2 == 0)return false;
	for(ll i =3;i*i<=num;i+=2){
		if(num % i == 0)return false;
	}
	return true;
}
int gcd(int a, int b){
	if(a%b==0) return b;
	else return gcd(b, a%b);
}
/*
int main() {
	ll n,m;
	cin>>n>>m;
	for (ll i = (ll) sqrt(m) + 1; i >= 2; i--) {
		while(true) {
			if (n % i == 0 && m % i == 0) {
				m /= i;
				n /= i;
			} else {
				break;
			}
		}
	}
	ll g = gcd(n,m);
	n/=g; m/=g;
	//cout<<n<<" "<<m<<endl;
	int maxn =0; int maxm = 0;
	int n1 =n; int m1 =m;
	while(n1>0){
		chmax(maxn,n1%10);
		n1/=10;
	}
	while(m1>0){
		chmax(maxm,m1%10);
		m1/=10;
	}
	ll ans = max(n,m);
	if(ans>10)ans==10;
	cout<<ans<<endl;
}
*/
//atodekesite
unordered_set<ll> primes;
void bunkai(ll num) {
	cout<<num<<endl;
	if(num==1)return;
	if(num==2) {
		primes.insert(2);
		bunkai(num/2);
	}
	if(num % 2 == 0)return;
	for(ll i =3;i*i<=num;i+=2){
		if(num % i == 0) {
			primes.insert(i);
			bunkai(num/i);
		} else {
			return;
		}
	}
}
vector<bool> temp;
bool solve() {
    int n;
    cin>>n;
    if (n==0) return false;
    vector<vector<bool>> m(n);
    temp = vector<bool>(n);
    rep(i,0,n) temp[i] = false;
    rep(i,0,n) m[i]=temp;
    rep(i,0,n) {
        int k;
        cin>>k;
        rep(j,0,k) {
            int x;
            cin>>x;
            x--;
            m[i][x]=true;
        }
    }
    int z;
    cin>>z;
    vector<bool> flags(n);
    rep(i, 0, n) flags[i]= true;
    rep(i, 0, z) {
        int x;
        cin>>x;
        x--;
        rep(j, 0, n) {
            if (!m[j][x]) flags[j] = false;
        }
    }
    int ans = -1;
    int size = 0;
    rep(i, 0, n) {
        if (flags[i]) {
            size++;
            ans = i;
        }
    }
    if (size != 1) {
        cout<<-1<<endl;
    } else {
        cout<<ans+1<<endl;
    }
    return true;
}
int main(){
    while(solve());
}
accuracy: 1
time_ms: 10
memory_kb: 3228
final_rank: 2

code_snippet: #include <bits/stdc++.h>
using namespace std;
struct Init { Init() { ios::sync_with_stdio(0); cin.tie(0); cout << setprecision(13); } }init;

using ll = long long;
using ull = unsigned long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;

#define rep(i, x, limit) for (ll i = (ll)x; i < (ll)limit; i++)
#define REP(i, x, limit) for (ll i = (ll)x; i <= (ll)limit; i++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define el '\n'
#define spa " "
#define Yes cout << "Yes" << el
#define No cout << "No" << el
#define YES cout << "YES" << el
#define NO cout << "NO" << el
#define eps (1e-10)
#define Equals(a,b) (fabs((a) - (b)) < eps )
#define debug(x) cerr << #x << " = " << x << el

const double pi = 3.141592653589793238;
const int inf = 1073741823;
const ll infl = 1LL << 60;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string abc = "abcdefghijklmnopqrstuvwxyz";

template<typename T1, typename T2>
std::ostream &operator<< (std::ostream &os, std::pair<T1,T2> p){
    os << "{" << p.first << "," << p.second << "}";
    return os;
}

// 配列の要素を空白区切りで出力 第二引数をtrueにすると改行区切り
template<typename T> inline void print_vec(const vector<T> &v, bool split_line=false) {
    if(v.empty()){
        cout << "This vector is empty." << el;
        return;
    }
    bool isValue = (is_integral<T>::value);
    for (int i = 0; i < (int)v.size(); i++) {
        if(isValue && (v[i]==inf || v[i]==infl)) cout << 'x' << " \n"[split_line || i+1==(int)v.size()];
        else cout << v[i] << " \n"[split_line || i+1==(int)v.size()];
    }
}

template<typename T1, typename T2> inline void print_vec(const vector<pair<T1,T2>> &v, bool split_line=false){
    if(v.empty()){
        cout << "This vector is empty." << el;
        return;
    }
    for(int i = 0; i < (int)v.size(); i++){
        cout << '{';
        auto p = v[i];
        pair<bool,bool> isValue = {is_integral<T1>::value, is_integral<T2>::value};
        if(isValue.first && (p.first==inf || p.first==infl)) cout << "x,";
        else cout << p.first << ',';
        if(isValue.second && (p.second==inf || p.second==infl)) cout << 'x';
        else cout << p.second;
        cout << "}" << " \n"[split_line || i+1==(int)v.size()];
    }
}

template<typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
    bool compare = a < b;
    if(compare) a = b;
    return compare;
}
template<typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
    bool compare = a > b;
    if(compare) a = b;
    return compare;
}

// std::chronoを利用した時間計測用クラス
class Timer{
    chrono::system_clock::time_point start;
    public:
        Timer() : start(chrono::system_clock::now()) {}
    
        double count(){
            chrono::duration<double> Time_ = chrono::system_clock::now() - start;
            return Time_.count();
        }

        bool is_under(double x){
            return (this -> count()) < x;
        }
};

int main(){
    while(true){
        int n;
        cin >> n;
        if(n==0) break;
        vector<int> m(n);
        vector<vector<int>> p(n,vector<int>());
        rep(i,0,n){
            cin >> m[i];
            rep(j,0,m[i]){
                int x;
                cin >> x;
                p[i].emplace_back(x);
            }
        }
        int k;
        cin >> k;
        vector<int> l(k);
        rep(i,0,k) cin >> l[i];
        int idx = -1;
        rep(i,0,n){
            set<int> se;
            rep(j,0,m[i]) se.insert(p[i][j]);
            bool isok = true;
            rep(j,0,k){
                if(!se.count(l[j])) isok=false;
            }
            if(isok){
                if(idx!=-1){
                    idx = -1;
                    break;
                }
                idx = i+1;
            }
        }
        cout << idx << el;
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3408
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
#define all(x) x.begin(), x.end()
template <class A, class B>
inline bool chmin(A &a, const B &b) {
    return b < a && (a = b, true);
}
template <class A, class B>
inline bool chmax(A &a, const B &b) {
    return b > a && (a = b, true);
}

int solve() {
    int n;
    cin >> n;
    if (n == 0) return 1;
    vector s(n, vector<bool>(n));
    rep(i, n) {
        int m;
        cin >> m;
        rep(j, m) {
            int v;
            cin >> v;
            v--;
            s[i][v] = true;
        }
    }
    vector<bool> t(n);
    int k;
    cin >> k;
    rep(i, k) {
        int v;
        cin >> v;
        v--;
        t[v] = true;
    }
    int count = 0;
    int tar = 0;
    rep(i, n) {
        bool ok = true;
        rep(j, n) ok &= (!t[j] || s[i][j]);
        if (ok) {
            count++;
            tar = i;
        }
    }
    cout << (count == 1 ? tar + 1 : -1) << endl;
    return 0;
}

int main() {
    while (!solve())
        ;
}
accuracy: 1
time_ms: 10
memory_kb: 3388
final_rank: 5

code_snippet: #include <bits/stdc++.h>

bool solve() {
    int N;
    std::cin >> N;
    if (N == 0) return false;
    std::vector<std::set<int>> A(N);
    for (int i{} ; i < N ; i++) {
        int M;
        std::cin >> M;
        for (int j{} ; j < M ; j++) {
            int p;
            std::cin >> p;
            A[i].insert(p);
        }
    }
    int K;
    std::cin >> K;
    std::vector<int> L(K);
    for (auto& l : L) std::cin >> l;
    int cnt{}, pos{-1};
    for (int i{} ; i < N ; i++) {
        bool ok{true};
        for (auto l : L) ok &= A[i].find(l) != A[i].end();
        if (ok) {
            cnt++;
            pos = i + 1;
        }
    }
    if (cnt == 1) {
        std::cout << pos << '\n';
    }
    else {
        std::cout << -1 << '\n';
    }
    return true;
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    while (solve()) ;
}
accuracy: 1
time_ms: 10
memory_kb: 3868
final_rank: 14

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll=long long;

int main(){
    while(true){
        int N;
        cin >> N;
        if(N==0)break;
        vector<vector<int>>p(N,vector<int>(0));
        vector<int>M(N);
        for(int i=0;i<N;i++){
            cin >> M[i];
            for(int j=0;j<M[i];j++){
                int x;
                cin >> x;
                p[i].push_back(x);
            }
        }

        int K;
        cin >> K;
        vector<int>l(K);
        for(int i=0;i<K;i++){
            cin >> l[i];
        }
        int pos;
        int cnt2=0;
        for(int i=0;i<N;i++){
            int cnt=0;
            for(int j=0;j<K;j++){
                if(find(p[i].begin(),p[i].end(),l[j])!=p[i].end()){
                    cnt++;
                }
            }
            if(cnt==K){
                cnt2++;
                pos=i+1;
            }
        }
        if(cnt2==1)cout << pos << endl;
        else cout << -1 << endl;
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3436
final_rank: 8

code_snippet: #include <bits/stdc++.h>
using namespace std;

#define rep(i,k,n) for (int i = k; i < (n); ++i)
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
typedef long long ll;
typedef pair<ll, ll> P;
const long long INF = 1e17;

int main(){
    while(true){
        int n;
        cin >> n;
        if(n==0){
            break;
        }
        vector know(n,vector<int>());
        for(int i=0;i<n;i++){
            int m;
            cin >> m;
            for(int j=0;j<m;j++){
                int x;
                cin >> x;
                know[i].push_back(x);
            }
        }

        int k;
        cin >> k;

        vector<int> known(k);
        for(int i=0;i<k;i++){
            cin >> known[i];
        }

        int hannin = 0;
        int ans = -1;
        int ok = true;

        for(int i=0;i<n;i++){
            ok = true;
            for(int j=0;j<k;j++){
                bool exist = false; 
                for(int x=0;x<know[i].size();x++){
                    if(know[i][x]==known[j]){
                        exist = true;
                    }
                }
                if(!exist){
                    ok = false;
                }
            }
            if(ok){
                hannin++;
                ans = i+1;
            } 
        }

        if(hannin==1){
            cout << ans << endl;
        }
        else{
            cout << -1 << endl;
        }
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3428
final_rank: 7

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define all(a) a.begin(),a.end()
#define reps(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
#define rreps(i, a, n) for (int i = (a); i > (int)(n); i--)
const long long mod = 1000000007;
const long long INF = 1e18;

int n;

void solve() {
    vector<set<int>> v (n);
    int m;
    rep(i,n) {
        cin >> m;
        int x;
        rep(j,m) {
            cin >> x;
            v[i].insert(x);
        }
    }
    cin >> m;
    vector<int> kk (m);
    rep(i,m) {
        cin >> kk[i];
    }

    int sus = -1;
    rep(i,n) {
        rep(j,m) {
            if (v[i].find(kk[j]) == v[i].end()) {
                break;
            }
            if (j == m-1) {
                if (sus>=0) {
                    cout << -1 << endl;
                    return;
                }
                sus = i+1;
            }
        }
    }
    cout << sus << endl;
    return;
}

int main() {
    while (true) {
        cin >> n;
        if (n == 0) {
            return 0;
        }
        solve();
    }
}
accuracy: 1
time_ms: 20
memory_kb: 3760
final_rank: 18

code_snippet: // (⁠◕⁠ᴗ⁠◕⁠✿⁠)

#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define srep(i, s, n) for (ll i = s; i < (n); i++)
#define len(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
using namespace std;
template<typename T> using vc = vector<T>;
template<typename T> using vv = vc<vc<T>>;
template<typename T> using vvv = vv<vc<T>>;
using vi = vc<int>;using vvi = vv<int>; using vvvi = vv<vi>;
using ll = long long;using vl = vc<ll>;using vvl = vv<ll>; using vvvl = vv<vl>;
using ld = long double; using vld = vc<ld>; using vvld = vc<vld>; using vvvld = vc<vvld>;
using uint = unsigned int;
using ull = unsigned long long;
const ld pi = 3.141592653589793;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
// const ll mod = 1000000007;
const ll mod = 998244353;
inline bool inside(ll y, ll x, ll H, ll W) {return 0 <= (y) and (y) < (H) and 0 <= (x) and (x) < (W); }

#define debug(var)  do{std::cout << #var << " : \n";view(var);}while(0)
template<typename T> void view(T e){cout << e << endl;}
template<typename T> void view(const vc<T>& v){for(const auto& e : v){ cout << e << " "; } cout << endl;}
template<typename T> void view(const vv<T>& vv){ for(const auto& v : vv){ view(v); } }

int solve(int N){
    vvi know(N, vi(N, 0));
    rep(i, N){
        int M; cin >> M;
        rep(j, M){
            int p; cin >> p; p--;
            know[i][p] = 1;
        }
    }
    int K; cin >> K;
    vi L(K); rep(i, K) cin >> L[i];
    rep(i, K) L[i]--;
    vi cand;
    rep(i, N){
        bool flag = true;
        for (auto l : L) if (!know[i][l]) flag = false;
        if (flag) cand.push_back(i + 1);
    }
    if (len(cand) == 1) return cand[0];
    return -1;
}

int main(){
    vc<int> ans;
    while (true){
        int N; cin >> N;
        if (N == 0) break;
        ans.push_back(solve(N));
    }
    for (auto x : ans) cout << x << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3496
final_rank: 10

code_snippet: #include <bits/stdc++.h>

using namespace std;

int main() {
    while (true) {
        int n;
        cin >> n;

        if (n == 0) {
            break;
        }

        int memo[n][101];
        memset(memo, 0, sizeof(memo));
        for (int i = 0; i < n; i++) {
            int m;
            cin >> m;
            for (int j = 0; j < m; j++) {
                int p;
                cin >> p;
                memo[i][p] = 1;
            }
        }

        int k;
        cin >> k;
        int l[k];
        for (int i = 0; i < k; i++) {
            cin >> l[i];
        }

        int ans = -1;
        for (int i = 0; i < n; i++) {
            bool ok = true;
            for (int j = 0; j < k; j++) {
                if (!memo[i][l[j]]) {
                    ok = false;
                    break;
                }
            }
            if (ok) {
                if (ans == -1) {
                    ans = i+1;
                } else {
                    ans = -1;
                    break;
                }
            }
        }

        cout << ans << endl;
    }

    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3472
final_rank: 9

code_snippet: #include <bits/stdc++.h>

bool solve() {
    int n; std::cin >> n;
    if (n == 0) return false;
    std::vector P(n, std::vector<bool>(n));
    std::vector<int> know(n);
    for (int i{} ; i < n ; i++) {
        int m; std::cin >> m;
        for (int j{} ; j < m ; j++) {
            int v; std::cin >> v;
            P[i][v - 1] = true;
            know[v - 1]++;
        }
    }
    int m; std::cin >> m;
    std::vector<int> flow(m);
    for (auto& f : flow) {
        std::cin >> f;
        f--;
    }
    std::vector<bool> all(n);
    for (int i{} ; i < n ; i++) {
        bool ok{true};
        for (auto f : flow) ok &= P[i][f];
        all[i] = ok;
    }
    int count{(int)std::count(all.begin(), all.end(), true)};
    if (count != 1) {
        std::cout << -1 << '\n';
        return true;
    }
    bool only{};
    for (auto f : flow) only |= know[f] == 1;
    if (only) {
        int ans{(int)(std::find(all.begin(), all.end(), true) - all.begin())};
        ans++;
        std::cout << ans << '\n';
    }
    else {
        std::cout << -1 << '\n';
    }
    return true;
}

int main() {
    for (int i{} ; solve() ; i++) {
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3364
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main() {
    while(1) {
        int N;
        cin >> N;
        if (N == 0) return 0;
        bool B[100][100] = {};
        for (int i =0; i < N; i++) {
            int M;
            cin >> M;
            for (int j =0; j < M; j++) {
                int K;
                cin >> K;
                K--;
                B[K][i] = true;
            }
        }
        bool ANS[100] = {};
        for (int i =0; i < N; i++) ANS[i] = true;
        int L;
        cin >> L;
        for (int i = 0; i < L; i++) {
            int H;
            cin >> H;
            H--;
            for (int j =0; j < N; j++) {
                if (!B[H][j]) ANS[j] = false;
            }
        }
        int COUNT = 0;
        for (int i = 0; i < N; i++) if (ANS[i]) COUNT++;
        if (COUNT == 1) {
            for (int i = 0; i < N; i++) if (ANS[i]) cout << i + 1 << endl;
        }
        else {
            cout << -1 << endl;
        }
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3080
final_rank: 1

code_snippet: #include <bits/stdc++.h>

int solve() {
    using State = std::bitset<100>;
    int n;
    std::cin >> n;
    if (n == 0) return 1;
    std::vector<State> states(n + 1);

    for (int i = 0; i < n + 1; i++) {
        int m;
        std::cin >> m;
        while (m--) {
            int j;
            std::cin >> j;
            j--;
            states[i].set(j);
        }
    }

    // for (int i = 0; i < n; i++) {
    //     for (int j = 0; j < n; j++) {
    //         std::cerr << states[i][j] << ' ' ;
    //     }
    //     std::cerr << std::endl;
    // }

    int ans = -1;
    for (int i = 0; i < n; i++) {
        if ((states[i] & states[n]) == states[n]) {
            if (ans != -1) {
                std::cout << -1 << std::endl;
                return 0;
            }
            ans = i + 1;
        }
    }
    std::cout << ans << std::endl;
    return 0;
}

int main() {
    while (!solve());
}
accuracy: 1
time_ms: 10
memory_kb: 3372
final_rank: 4