Problem:
関連商品
インターネット通販サイトでは、ユーザが現在見ている商品と同じページに、過去に他のユーザによって、現在見ている商品と一緒に買われた別の商品をいくつか表示してくれます。関連性の高いと思われる商品を提示することで、売り上げを伸ばすことができると考えられているからです。
似たようなことは、一緒に買われることが多い商品を近くに配置する、という工夫として、近所のスーパーマーケットでも目にすることができます（例えば、パンとジャムのような）。あなたの仕事は、商品配置の工夫を助けるプログラムを書くことです。今回は、ある基準となる回数を設定し、一緒に買われた回数が基準回数以上である、２つの商品の組み合わせを求めたいと思います。
一緒に買われた商品の情報と基準回数が与えられたとき、基準回数以上一緒に買われた商品２つの組み合わせを出力するプログラムを作成せよ。
Input
入力は以下の形式で与えられる。
N
F
info
1
info
2
:
info
N
１行目に、一緒に買われた商品の情報の数
N
(1 ≤
N
≤ 100) と、基準回数
F
(1 ≤
F
≤ 100) が与えられる。続く
N
行に、一緒に買われた商品の情報が与えられる。一緒に買われた商品の情報
info
i
は、以下の形式で与えられる。
M
item
1
item
2
...
item
M
M
(1 ≤
M
≤ 10) は、この情報がいくつの商品を含むかを表す。
item
j
は、この買い物で買われた商品の名前であり、英小文字だけから成る長さ 1 以上 30 以下の文字列である。
info
i
の中に同じ商品が与えられることはない。
Output
１行目に基準回数以上一緒に買われた商品２つの組み合わせの数を出力し、２行目以降に組み合わせをすべて出力する。ただし、組み合わせが一つもない場合は２行目以降には何も出力しない。
出力の順番は、組み合わせ内の商品名どうしを、辞書式順序（英和辞書で単語が並んでいる順番）で並べたあと、組み合わせどうしについては以下のようにする。
一つ目の商品名どうしを比較して、辞書式順序で早いほうが先。
同じ場合は、二つ目の商品名どうしを比較して、辞書式順序で早いほうが先。
商品名はスペース一つで区切り、商品の組み合わせは改行一つで区切る。
Sample Input 1
5 2
3 bread milk banana
2 milk cornflakes
3 potato bread milk
4 cornflakes bread milk butter
2 potato bread
Sample Output 1
3
bread milk
bread potato
cornflakes milk
Sample Input 2
5 5
3 bread milk banana
2 milk cornflakes
3 potato bread milk
4 cornflakes bread milk butter
2 potato bread
Sample Output 2
0

Submitted solutions:

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


using namespace std;
//make -f ../makefile SRC=
/*
WA on test 3
*/


//------------------------------------------------------------------------------
bool DEBUG = false;
const int INF = 1000000000;

static char buf[150];

const int MAX_N = 100;
static vector<string> food[MAX_N];

const int BITS = 1000;
typedef bitset<BITS> Mask;


typedef pair<int,int> PA;
typedef vector<PA> PAS;
//------------------------------------------------------------------------------
Mask encode(int N, int B, map<string,int>& to_vert, int index)
{
    Mask mask;
    for (string s: food[index]) mask[ to_vert[s] ] = 1;
    return mask;
}

// mask => pair of foods
bool feasible(int N, int K, const vector<Mask>& masks, const Mask &mask)
{
    int res = 0;
    for (Mask m: masks)
        if ((m & mask) == mask)
            {
                res++;
                if (res >= K) return true; //<--------- FIXME
            }
    return false;
}
//------------------------------------------------------------------------------
void solve(int N, int K, int B, map<string,int>& to_vert, const vector<string>& to_str)
{
    if (DEBUG) printf("N=%d, K=%d, B=%d\n", N, K, B);
    //--------------------------------------------------------------------------
    // base cases:
    //--------------------------------------------------------------------------
    // init:
    vector<Mask> masks(N);
    for (int i=0; i<N; ++i) masks[i] = encode(N, B, to_vert, i);

    //--------------------------------------------------------------------------
    // compute:
    PAS R;
    int num = 0;
    for (int b1=0; b1<B-1; ++b1)
    {
        for (int b2=b1+1; b2<B; ++b2)
        {
            Mask mask;
            mask[b1] = 1;
            mask[b2] = 1;
            if (feasible(N, K, masks, mask)) R.push_back( {b1, b2} );
        }
    }
    //--------------------------------------------------------------------------
    // report:
    printf("%ld\n", R.size());
    for (PA p: R) printf("%s %s\n", to_str[p.first].c_str(), to_str[p.second].c_str());

}

//------------------------------------------------------------------------------
void test()
{

}

//------------------------------------------------------------------------------
int main()
{
    //test(); return 0;
    //DEBUG = true;
    //--------------------------------------------------------------------------
    int N, K, F, B, num;
    set<string> unique;

    num = scanf("%d %d ", &N, &K);
    for (int i=0; i<N; ++i)
    {
        num = scanf("%d ", &F);
        for (int f=0; f<F; ++f)
        {
            num = scanf("%s ", buf);
            food[i].push_back(string(buf));
            unique.insert( food[i].back() );
        }
    }
    
    B = unique.size();
    vector<string> to_str(B);
    map<string,int> to_vert;
    int b = 0;
    for (string s: unique)
    {
        to_vert[s] = b;
        to_str[b++] = s;
    }
    solve(N, K, B, to_vert, to_str);
    //--------------------------------------------------------------------------
    return 0;
}
//------------------------------------------------------------------------------
accuracy: 1
time_ms: 510
memory_kb: 4036
final_rank: 13

code_snippet: #include"bits/stdc++.h"
#include<random>
using namespace std;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<int> vint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<string> vstring;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
typedef vector<vbool> vvbool;
typedef vector<vpllint> vvpllint;
#define rep(i,n) for(int i=0;i<n;i++)
#define drep(i,n) for(int i=n-1;0<=i;i--)
#define yes(ans) if(ans)cout<<"yes"<<endl;else cout<<"no"<<endl;
#define Yes(ans) if(ans)cout<<"Yes"<<endl;else cout<<"No"<<endl;
#define YES(ans) if(ans)cout<<"YES"<<endl;else cout<<"NO"<<endl;
#define POSSIBLE(ans) if(ans)cout<<"POSSIBLE"<<endl;else cout<<"IMPOSSIBLE"<<endl;
#define Pi 3.1415926535897932384626
#define mod llint(1e9+7)
#define mod9 998244353
#define Inf 2147483647
#define llInf 9223372036854775807
#define all(x) x.begin(),x.end()
#define isin(i,n) (0<=i&&i<n)

int main() {
	int n, f;
	cin >> n >> f;
	map<string, int>item;
	int cnt = 0;
	vvint table(1001, vint(1001));
	rep(i, n) {
		int m;
		cin >> m;
		vstring s(m);
		rep(j, m) {
			cin >> s[j];
			if (item[s[j]] == 0) {
				item[s[j]] = ++cnt;
			}
			rep(k, j) {
				table[item[s[k]]][item[s[j]]]++;
				table[item[s[j]]][item[s[k]]]++;
			}
		}
	}
	vector<pair<string, string>>ans;
	for (auto [s, i] : item) {
		for (auto [t, j] : item) {
			if (table[i][j] >= f && s < t)ans.push_back({ s,t });
		}
	}
	sort(all(ans));
	cout << ans.size() << endl;
	for (auto [s, t] : ans)cout << s << " " << t << endl;
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 8012
final_rank: 4

code_snippet: #include<bits//stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0;i<n;i++)
#define ALL(a) a.begin(),a.end()
typedef long long ll;
int main(){
    int n,f,m;cin >>n >>f;
    map<pair<string,string>,int> mp;
    set<string>st;
    rep(i,n){
        cin >>m;vector<string> s(m);
        rep(j,m){
            cin >> s[j];st.insert(s[j]);
        }sort(ALL(s));
        rep(j,m-1){
            for(int k = j+1;k<m;k++){
                mp[{s[j],s[k]}]++;
            }
        }
    }vector<string> s;vector<string> v,w;
    for(string it : st) s.push_back(it);
    for(string S:s){
        for(string T:s){
            if(S==T) continue;
            if(mp[{S,T}]>= f){
                v.push_back(S);
                w.push_back(T);
            }
        }
    }cout << v.size() <<endl;
    rep(i,v.size()){
        cout << v[i] << " " << w[i] <<endl;
    }
}
accuracy: 1
time_ms: 490
memory_kb: 65828
final_rank: 16

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

int dp[1000][1000];

int main() {
    int n, x;
    cin >> n >> x;
    int cnt = 0;
    map<string, int> mp;
    vector<string> a;
    for (int i = 0; i < n; ++i) {
        vector<int> v;
        int m;
        cin >> m;
        for (int j = 0; j < m; ++j) {
            string s;
            cin >> s;
            if(!mp.count(s)){
                v.emplace_back(cnt);
                a.emplace_back(s);
                mp[s] = cnt++;
            }else {
                v.emplace_back(mp[s]);
            }
        }
        for (int j = 0; j < m; ++j) {
            for (int k = 0; k < m; ++k) {
                if(j != k){
                    dp[v[j]][v[k]]++;
                }
            }
        }
    }
    vector<pair<string, string>> ans;
    for (int j = 0; j < cnt; ++j) {
        for (int k = 0; k < cnt; ++k) {
            if(a[j] < a[k] && dp[j][k] >= x){
                ans.emplace_back(a[j], a[k]);
            }
        }
    }
    cout << ans.size() << "\n";
    sort(ans.begin(),ans.end());
    for (auto &&l : ans) {
        cout << l.first << " " << l.second << "\n";
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 7208
final_rank: 2

code_snippet: #include<iostream>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#define int long long
#define mod 1000000007
#define for0(i, n) for(int i = 0; i < (n); i++)
#define for1(i, n) for(int i = 1; i <= (n);i++)
using namespace std;
int get() { int r; cin >> r; return r; }
set<pair<string, string>>s;
map<pair<string, string>, int>m;
int n, k;
string a[12];
vector<pair<string, string>>ans;
signed main() {
	cin >> n >> k;
	for1(hoge, n) {
		int p; cin >> p;
		for0(i, p)cin >> a[i];
		sort(a, a + p);
		for0(i, p) {
			for (int j = i + 1; j < p; j++) {
				pair<string, string>pr = make_pair(a[i], a[j]);
				if (find(s.begin(), s.end(), pr) == s.end()) {
					s.insert(pr);
					m[pr] = 1;
				}
				else m[pr]++;
			}
		}
	}
	for (pair<string, string>p : s)
		if (m[p] >= k)ans.push_back(p);
	cout << ans.size() << endl;
	for (pair<string, string>p : ans)cout << p.first << ' ' << p.second << endl;
}
accuracy: 1
time_ms: 120
memory_kb: 3936
final_rank: 8

code_snippet: // クエリ先読みして出てくる単語を掌握
// グラフを張る
// 辞書順に全探索して実際に成立するか確かめる

#include <iostream>
#include <vector>
#include <string>
#include <set>

using namespace std;

int main() {
	int n, f;
	cin >> n >> f;
	set<string>se;
	vector<vector<string>>input(n);
	for (int i = 0; i < n; i++) {
		int m; cin >> m;
		for (int j = 0; j < m; j++) {
			string s;
			cin >> s;
			se.insert(s);
			input[i].push_back(s);
		}
	}
	vector<string>product;
	for (auto s : se)product.push_back(s);

	vector<vector<int>>graph(product.size(), vector<int>(product.size()));
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < input[i].size(); j++) {
			for (int k = j + 1; k < input[i].size(); k++) {
				int a = 0;
				for (int index = 0; index < product.size(); index++) {
					if (product[index] == input[i][j])a = index;
				}
				int b = 0;
				for (int index = 0; index < product.size(); index++) {
					if (product[index] == input[i][k])b = index;
				}
				graph[a][b]++;
				graph[b][a]++;
			}
		}
	}

	vector<vector<string>>ret;
	for (int i = 0; i < product.size(); i++) {
		for (int j = i + 1; j < product.size(); j++) {
			if (graph[i][j] >= f) {
				ret.push_back({ product[i],product[j] });
			}
		}
	}

	cout << ret.size() << endl;
	for (auto x : ret)cout << x[0] << " " << x[1] << endl;
	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 7368
final_rank: 5

code_snippet: #include<bits/stdc++.h>
#define V vector
#define VI vector<int>
#define VVI vector<vector<int>>
#define REP(i,n) for(int i=0;i<(n);i++)
#define REPR(i,n) for(int i=n;i>=0;i--)
#define FOR(i,m,n) for(int i=m;i<n;i++)
#define MOD 1000000007
#define INF 1e9
#define F first
#define S second
#define All(x) (x).begin(),(x).end()
using namespace std;
typedef long long ll;

int main(void){
    map<string,map<string,int>> item;
    int N,F;
    cin>>N>>F;
    V<string> all;
    REP(i,N){
        int M;cin>>M;
        V<string> in(M);
        REP(j,M){
            cin>>in[j];
            all.push_back(in[j]);
        }
        REP(j,M){
            FOR(k,j+1,M){
                item[in[j]][in[k]]++;
                item[in[k]][in[j]]++;
            }
        }
    }
    sort(All(all));
    all.erase(unique(All(all)),all.end());
    int cnt=0;
    V<pair<int,int>> ans;
    REP(i,all.size()){
        FOR(j,i+1,all.size()){
            if(item[all[i]][all[j]]>=F){
                cnt++;
                ans.push_back(make_pair(i,j));
            }
        }
    }
    cout<<cnt<<endl;
    REP(i,cnt){
        cout<<all[ans[i].F]<<" "<<all[ans[i].S]<<endl;
    }
}
accuracy: 1
time_ms: 130
memory_kb: 34856
final_rank: 12

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

int main() {
  int n,m,ans=0;
  string t;
  cin >> n >> m;
  vector<int> a(n);
  vector<string> s(0);
  vector<vector<string>> u(n,vector<string>(0));
  for (int i=0;i<n;i++){
    cin >> a.at(i);
    for (int j=0;j<a.at(i);j++){
      int y=0;
      cin >> t;
      u.at(i).push_back(t);
      for (int k=0;k<s.size();k++){
        if (s.at(k)==t) {y=1;break;}
      }
      if (y==0) s.push_back(t);
    }
    sort(u.at(i).begin(),u.at(i).end());
  }
  sort(s.begin(),s.end());
  vector<vector<pair<pair<string,string>,int>>> h(s.size(),vector<pair<pair<string,string>,int>>(s.size()));
  for (int i=0;i<s.size()-1;i++){
    for (int j=i+1;j<s.size();j++){
      pair<pair<string,string>,int> v;
      v.first.first=s.at(i);v.first.second=s.at(j);v.second=0;
      h.at(i).at(j)=v;
    }
  }
  for (int i=0;i<n;i++){
    for (int j=0;j<a.at(i)-1;j++){
      for (int k=j+1;k<a.at(i);k++){
       for (int e=0;e<s.size()-1;e++){
           if (h.at(e).at(s.size()-1).first.first==u.at(i).at(j)){
         for (int ii=e+1;ii<s.size();ii++){
           if (h.at(e).at(ii).first.first==u.at(i).at(j) && h.at(e).at(ii).first.second==u.at(i).at(k)) h.at(e).at(ii).second++;
         }
           }
       }
      }
    }
  }
  for (int i=0;i<s.size()-1;i++) {
    for (int j=i+1;j<s.size();j++){
      if (h.at(i).at(j).second>=m) ans++;
    }
  }
  cout << ans << endl;
  for (int i=0;i<s.size()-1;i++) {
    for (int j=i+1;j<s.size();j++){
      if (h.at(i).at(j).second>=m) cout << h.at(i).at(j).first.first << " " << h.at(i).at(j).first.second << endl;
    }
  }
}
accuracy: 1
time_ms: 80
memory_kb: 26332
final_rank: 9

code_snippet: #include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<cmath>
#include<cstring>
#include<map>
#include<string.h>
#include<stdexcept>
using namespace std;

map<string,int>item;
vector<string>comb;

int main(){
  int n,f,m;
  string s[10];
  item.clear();
  scanf("%d %d",&n,&f);
  for(int i=0;i<n;i++){
    scanf("%d",&m);
    for(int j=0;j<m;j++){
      cin>>s[j];
    }
    sort(s,s+m);
    for(int j=0;j<m;j++){
      for(int k=j+1;k<m;k++){
	string temp;
	temp=s[j]+" ";
	temp+=s[k];
	if(!count(comb.begin(),comb.end(),temp)){
	  comb.push_back(temp);
	}
	item[temp]++;
      }
    }
  }

  sort(comb.begin(),comb.end());

  int ans=0;
  string ansstr[500000];
  for(int i=0;i<comb.size();i++){
    if(item[comb[i]]>=f){
      ansstr[ans]=comb[i];
      ans++;
    }
  }

  printf("%d\n",ans);
  for(int i=0;i<ans;i++){
    cout<<ansstr[i]<<endl;
  }

  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 8004
final_rank: 6

code_snippet: #include <iostream>
#include <string>
using namespace std;
struct info{
    string word[10];
    int m;
};

struct tag{
    string a;
    int id;
    int counter[10000];
};

void check(void);
void Pair(void);
void count(int name,int infomation);
void dictionary(int one,int two);


int n,f,tag_l;
int ans,filing;
tag t[1000];
info str[100];
string k,ans_file[10000];

int main(void){
    cin>>n>>f;
    for(int i=0;i<n;i++){
        cin>>str[i].m;
        for(int j=0;j<str[i].m;j++){
            cin>>str[i].word[j];
        }
    }
    check();
    Pair();
    
    k=' ';
    
    ans=0;
    
    for(int i=0;i<tag_l;i++){
        for(int j=0;j<tag_l;j++){
            if(i==j)continue;
            if(t[i].counter[j]>=f){
                ans++;
                t[j].counter[i]=0;
            }
        }
    }
    
    cout<<ans<<endl;
    filing=0;
    if(ans!=0){
        for(int i=0;i<tag_l;i++){
            for(int j=0;j<tag_l;j++){
                if(i==j)continue;
                if(t[i].counter[j]>=f){
                    dictionary(i,j);
                }
            }
        }
    }
    
    string sub;
    
    for(int i=0;i<filing-1;i++){
        for(int j=i;j<filing;j++){
            if(ans_file[i]>ans_file[j]){
                sub=ans_file[i];
                ans_file[i]=ans_file[j];
                ans_file[j]=sub;
            }
        }
    }
    
    for(int i=0;i<filing;i++){
        cout<<ans_file[i]<<endl;
    }
    /*
    for(int i=0;i<tag_l;i++){
        cout<<t[i].a<<' '<<t[i].id<<' ';
    }cout<<endl;
    
    for(int i=0;i<tag_l;i++){
        cout<<t[i].a<<endl;
        for(int j=0;j<tag_l;j++){
            cout<<t[i].counter[j]<<endl;
        }
    }cout<<endl;
    cout<<ans<<endl;
    */
}


void check(void){
    tag_l=0;
    for(int i=0;i<n;i++){
        for(int j=0;j<str[i].m;j++){
            if(tag_l==0){t[tag_l].a=str[i].word[j]; t[tag_l].id=tag_l; tag_l++;}
            else{
                for(int k=0;k<tag_l;k++){
                    if(t[k].a==str[i].word[j]){
                        break;
                    }
                    if(k==tag_l-1){t[tag_l].a=str[i].word[j]; t[tag_l].id=tag_l; tag_l++;}
                }
            }
        }
    }
}

void Pair(void){
    for(int h=0;h<tag_l;h++){
        for(int i=0;i<n;i++){
            for(int j=0;j<str[i].m;j++){
                if(str[i].word[j]==t[h].a){
                    count(h,i);
                }
            }
        }
    }
}

void count(int name,int infomation){
    for(int j=0;j<str[infomation].m;j++){
        for(int i=0;i<tag_l;i++){
            if(str[infomation].word[j]==t[i].a){
                t[name].counter[t[i].id]++;
            }
        }
    }
}

void dictionary(int one,int two){
    if(t[one].a>t[two].a){
        ans_file[filing]=t[two].a+k+t[one].a;
        
    }
    else{
        ans_file[filing]=t[one].a+k+t[two].a;
    }
    filing++;
}
accuracy: 1
time_ms: 240
memory_kb: 9592
final_rank: 10

code_snippet: #include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
using namespace std;
struct DOBERMAN{
char c[61],s[61];
int g;
};
DOBERMAN doberman[1000000]={0},q[1000000]={0},t;
int main(){
int i,j,n,f,m,u=0,o=0,r,l,b=0,jc,jk,js;
static int p[1000000]={0};
char d[61][61];
scanf("%d%d",&n,&f);
for(i=0;i<n;i++){
	scanf("%d",&m);
	for(j=0;j<m;j++){
		cin>>d[j];
	}
	for(j=0;j<m;j++){
		for(r=j+1;r<m;r++){
			o=0;
			//printf("%s %s\n",d[j],d[r]);
			for(l=0;l<u;l++){
				if((strcmp(d[j],doberman[l].c)==0&&strcmp(d[r],doberman[l].s)==0)||(strcmp(d[r],doberman[l].c)==0&&strcmp(d[j],doberman[l].s)==0)){
					//printf("%d:%d\n%d:%d\n",strcmp(d[j],doberman[l].c),strcmp(d[r],doberman[l].s),strcmp(d[r],doberman[l].c),strcmp(d[j],doberman[l].s));
					o=1;
					doberman[l].g++;
					if(doberman[l].g>=f&&p[l]==0){
						q[b]=doberman[l];
						p[l]=1;
						b++;
					}
					break;
				}
			}
			if(o==0){
				//printf("MorishitaSHINE\n");
				js=0;
				for(jc=0;jc<min(strlen(d[j]),strlen(d[r]));jc++){
					if(d[j][jc]-'a'>d[r][jc]-'a'){
						js=1;
						break;
					}
					if(d[j][jc]-'a'<d[r][jc]-'a'){
						js=2;
						break;
					}
				}
				if(js==1){
					strcpy(t.c,d[r]);
					strcpy(t.s,d[j]);
					t.g=doberman[u].g+1;
				}
				else{
				strcpy(t.c,d[j]);
				strcpy(t.s,d[r]);
				t.g=doberman[u].g+1;
				}
				doberman[u]=t;
				//printf("%s %s %d\n",doberman[u].c,doberman[u].s,doberman[u].g);
				if(doberman[u].g>=f&&p[u]==0){
					q[b]=doberman[u];
					p[u]=1;
					b++;
				}
				u++;
			}
		}
	}
}
for(i=0;i<b;i++){
	for(j=i+1;j<b;j++){
		js=0;
		for(jc=0;jc<min(strlen(q[i].c),strlen(q[j].c));jc++){
			if(q[i].c[jc]-'a'>q[j].c[jc]-'a'){
				js=1;
				break;
			}
			if(q[i].c[jc]-'a'<q[j].c[jc]-'a'){
				js=2;
				break;
			}
		}
		if(js==0){
		for(jc=0;jc<min(strlen(q[i].s),strlen(q[j].s));jc++){
			if(q[i].s[jc]-'a'>q[j].s[jc]-'a'){
				js=1;
				break;
			}
			if(q[i].s[jc]-'a'<q[j].s[jc]-'a'){
				js=2;
				break;
			}
		}
		}
		if(js==1){
			t=q[i];
			q[i]=q[j];
			q[j]=t;
		}
	}
}
printf("%d\n",b);
for(i=0;i<b;i++){
	cout<<q[i].c<<' '<<q[i].s<<endl;
}
return 0;
}
accuracy: 1
time_ms: 290
memory_kb: 4308
final_rank: 11

code_snippet: #include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
using namespace std;
struct DOBERMAN{
char c[61],s[61];
int g;
};
DOBERMAN doberman[1000000]={0},q[1000000]={0},t;
int main(){
int i,j,n,f,m,u=0,o=0,r,l,b=0,jc,jk,js;
static int p[1000000]={0};
char d[61][61];
scanf("%d%d",&n,&f);
for(i=0;i<n;i++){
	scanf("%d",&m);
	for(j=0;j<m;j++){
		cin>>d[j];
	}
	for(j=0;j<m;j++){
		for(r=j+1;r<m;r++){
			o=0;
			//printf("%s %s\n",d[j],d[r]);
			for(l=0;l<u;l++){
				if((strcmp(d[j],doberman[l].c)==0&&strcmp(d[r],doberman[l].s)==0)||(strcmp(d[r],doberman[l].c)==0&&strcmp(d[j],doberman[l].s)==0)){
					//printf("%d:%d\n%d:%d\n",strcmp(d[j],doberman[l].c),strcmp(d[r],doberman[l].s),strcmp(d[r],doberman[l].c),strcmp(d[j],doberman[l].s));
					o=1;
					doberman[l].g++;
					if(doberman[l].g>=f&&p[l]==0){
						q[b]=doberman[l];
						p[l]=1;
						b++;
					}
					break;
				}
			}
			if(o==0){
				//printf("MorishitaSHINE\n");
				js=0;
				for(jc=0;jc<min(strlen(d[j]),strlen(d[r]));jc++){
					if(d[j][jc]-'a'>d[r][jc]-'a'){
						js=1;
						break;
					}
					if(d[j][jc]-'a'<d[r][jc]-'a'){
						js=2;
						break;
					}
				}
				if(js==1){
					strcpy(t.c,d[r]);
					strcpy(t.s,d[j]);
					t.g=doberman[u].g+1;
				}
				else{
				strcpy(t.c,d[j]);
				strcpy(t.s,d[r]);
				t.g=doberman[u].g+1;
				}
				doberman[u]=t;
				//printf("%s %s %d\n",doberman[u].c,doberman[u].s,doberman[u].g);
				u++;
			}
		}
	}
}
for(i=0;i<b;i++){
	for(j=i+1;j<b;j++){
		js=0;
		for(jc=0;jc<min(strlen(q[i].c),strlen(q[j].c));jc++){
			if(q[i].c[jc]-'a'>q[j].c[jc]-'a'){
				js=1;
				break;
			}
			if(q[i].c[jc]-'a'<q[j].c[jc]-'a'){
				js=2;
				break;
			}
		}
		if(js==0){
		for(jc=0;jc<min(strlen(q[i].s),strlen(q[j].s));jc++){
			if(q[i].s[jc]-'a'>q[j].s[jc]-'a'){
				js=1;
				break;
			}
			if(q[i].s[jc]-'a'<q[j].s[jc]-'a'){
				js=2;
				break;
			}
		}
		}
		if(js==1){
			t=q[i];
			q[i]=q[j];
			q[j]=t;
		}
	}
}
printf("%d\n",b);
for(i=0;i<b;i++){
	cout<<q[i].c<<' '<<q[i].s<<endl;
}
return 0;
}
accuracy: 0.16666666666666666
time_ms: 50
memory_kb: 3776
final_rank: 17

code_snippet: #include<bits/stdc++.h>
using namespace std;
int a[2000][2000]={};
int main(){
  int n,f;
  //int a[2000][2000]={};
  map<string,int> M;
  map<int,string> MD;
  set<string> S;
  int c=0;
  int count=0;
  cin>>n>>f;
  for(int i=0;i<n;i++){
    int m;
    cin>>m;
    vector<string> st;
    for(int t=0;t<m;t++){
      string s;
      cin>>s;
      st.push_back(s);
      if(S.find(s)==S.end()){S.insert(s); MD[count]=s; M[s]=count; count++;}
      for(int h=0;h<st.size()-1;h++){
	a[M[s]][M[st[h]]]++;
	a[M[st[h]]][M[s]]++;
	if(a[M[st[h]]][M[s]]==f){c++;}
      }
    }
  }
  cout<<c<<endl;
  for(set<string>::iterator i=S.begin();i!=S.end();i++){
    for(set<string>::iterator t=i;t!=S.end();t++){
      if(a[M[(*i)]][M[(*t)]]>=f){
	  cout<<(*i)<<" "<<(*t)<<endl;
      }
    }
  }

  return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 7312
final_rank: 7

code_snippet: #include <stdio.h>
#include <iostream>
#include <utility>
#include <set>
#include <vector>
#include <string>
#include <algorithm>
#define rep(i, n) for(int i = 0; i < n; ++i)
using namespace std;

int main(void) {
  int i, j, k, n, f;
  vector< pair< pair<string, string>, int> > v;
  scanf("%d%d", &n, &f);
  rep(i, n) {
    int m, l = 0;
    scanf("%d", &m);
    string s[m];
    rep(j, m) cin >> s[j];
    sort(s, s + m);
    rep(j, m) for(k = j + 1; k < m; ++k) {
      l = 0;
      pair<string, string> p = make_pair(s[j], s[k]);
      vector< pair< pair<string, string>, int> >::iterator it;
      for(it = v.begin(); it != v.end(); ++it) {
        if((*it).first.first == s[j] && (*it).first.second == s[k]) {
          (*it).second++;
          l = 1;
          break;
        }
      }
      pair< pair<string, string>, int> p1 = make_pair(p, 1);
      if(!l) v.push_back(p1);
    }
  }
  sort(v.begin(), v.end());
  vector< pair< pair<string, string>, int> >::iterator it;
  int ans = 0;
  for(it = v.begin(); it != v.end(); ++it) {
    if((*it).second >= f) ++ans;
    /*cout << (*it).first.first << " " << (*it).first.second << " " << (*it).second << "\n";*/
  }
  printf("%d\n", ans);
  for(it = v.begin(); it != v.end(); ++it) {
    if((*it).second >= f) cout << (*it).first.first << " " << (*it).first.second << "\n";
  }
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3496
final_rank: 3

code_snippet: #include<iostream>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
#include<functional>
#include<utility>
using namespace std;
int main() {
	int n, f;
	cin >> n >> f;
	map<pair<string, string>, int> m;
	for (int i = 0; i < n; i++) {
		int M;
		cin >> M;
		vector<string>item(M);
		for (int j = 0; j < M; j++)cin >> item[j];
		sort(item.begin(), item.end());
		for (int j = 0; j < M; j++) {
			for (int k = j + 1; k < M; k++) {
				m[make_pair(item[j], item[k])] += 1;
			}
		}
	}
	int res = 0;
	for (map<pair<string, string>, int>::iterator it = m.begin(); it != m.end(); it++) {
		if (it->second >= f)res++;
	}
	cout << res << endl;
	for (map<pair<string, string>, int>::iterator it = m.begin(); it != m.end(); it++) {
		if (it->second >= f) cout << it->first.first << " " << it->first.second << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3476
final_rank: 1

code_snippet: #include <iostream>
#include <string>
#include <set>
#include <map>
#include <vector>
#include <algorithm>

using namespace std;

typedef pair<string, string> P;

int main() {
	int n, f;
	cin >> n >> f;
	set<string> st;
	map<P, int> mp;
	for (int i = 0; i < n; i++) {
		int m;
		cin >> m;
		vector<string> s(m);
		for (int j = 0; j < m; j++) {
			cin >> s[j];
			st.insert(s[j]);
		}
		for (int j = 0; j < m; j++) {
			for (int k = j + 1; k < m; k++) {
				mp[P(s[j], s[k])]++;
				mp[P(s[k], s[j])]++;
			}
		}
	}
	vector<string> ss;
	for (set<string>::iterator ite = st.begin(); ite != st.end(); ite++) {
		ss.push_back(*ite);
	}
	int ans = 0;
	sort(ss.begin(), ss.end());
	for (int i = 0; i < ss.size(); i++) {
		for (int j = i + 1; j < ss.size(); j++) {
			if (mp[P(ss[i], ss[j])] >= f) {
				ans++;
			}
		}
	}
	cout << ans << endl;
	for (int i = 0; i < ss.size(); i++) {
		for (int j = i + 1; j < ss.size(); j++) {
			if (mp[P(ss[i], ss[j])] >= f) {
				cout << ss[i] << ' ' << ss[j] << endl;
			}
		}
	}
	return 0;
}
accuracy: 1
time_ms: 370
memory_kb: 34820
final_rank: 15

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include<string>
#include<set>
#include<map>
using namespace std;

int main() {
	int n, f;
	int ans = 0;
	cin >> n >> f;
	vector<string> input(n);
	set<string> itemList;
	vector <pair<string, string> > ansList;

	// input
	for (int i = 0; i < n; i++) {
		int m;
		cin >> m;
		for (int j = 0; j < m; j++) {
			string temp;
			cin >> temp;
			input[i] += temp;
			input[i] += ",";
			itemList.insert(temp);
		}
	}


	// solve
	auto itr = itemList.begin();
	auto itr_end = itemList.end();
	itr_end--;
	for (; itr != itr_end; itr++) {
		auto itr_temp = itr;
		itr_temp++;
		for (auto itr2=itr_temp; itr2 != itemList.end(); itr2++) {
			string nowFirstItem = *itr;
			string nowSecondItem = *itr2;

			int nowF = 0;
			for (int i = 0; i < n; i++) {
				if (input[i].find(nowFirstItem) != string::npos &&
					input[i].find(nowSecondItem) != string::npos) {
					nowF++;
				}
			}
			if (nowF >= f) {
				ans++;
				ansList.push_back(make_pair(nowFirstItem, nowSecondItem));
			}
		}
	}
	sort(ansList.begin(), ansList.end());

	// output
	cout << ans << endl;
	for (int i = 0; i < ansList.size(); i++) {
		cout << ansList[i].first << " " << ansList[i].second << endl;
	}

}
accuracy: 0.1111111111111111
time_ms: 30
memory_kb: 3180
final_rank: 20

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include<string>
#include<set>
#include<map>
using namespace std;

int main() {
	int n, f;
	int ans = 0;
	cin >> n >> f;
	vector<string> input(n);
	set<string> itemList;
	vector <pair<string, string> > ansList;

	// input
	for (int i = 0; i < n; i++) {
		int m;
		cin >> m;
		for (int j = 0; j < m; j++) {
			string temp;
			cin >> temp;
			input[i] += temp;
			input[i] += ",";
			itemList.insert(temp);
		}
	}

	// solve
	auto itr = itemList.begin();
	auto itr_end = itemList.end();
	itr_end--;
	for (; itr != itr_end; itr++) {
		auto itr_temp = itr;
		itr_temp++;
		for (auto itr2=itr_temp; itr2 != itemList.end(); itr2++) {
			string nowFirstItem = *itr;
			string nowSecondItem = *itr2;

			int nowF = 0;
			for (int i = 0; i < n; i++) {
				if (input[i].find(nowFirstItem) != string::npos &&
					input[i].find(nowSecondItem) != string::npos) {
					nowF++;
				}
			}
			if (nowF >= f) {
				ans++;
				ansList.push_back(make_pair(nowFirstItem, nowSecondItem));
			}
		}
	}

	// output
	cout << ans << endl;
	for (int i = 0; i < ansList.size(); i++) {
		cout << ansList[i].first << " " << ansList[i].second << endl;
	}

}
accuracy: 0.1111111111111111
time_ms: 30
memory_kb: 3128
final_rank: 19

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include<string>
#include<set>
#include<map>
using namespace std;

int main() {
	int n, f;
	int ans = 0;
	cin >> n >> f;
	//vector<vector<string> > input(n,(vector<string>(10)));
	vector<string> input(n);
	set<string> itemList;
	//vector<vector<string> > ansList(n*10, (vector<string>(2)));
	vector <pair<string, string> > ansList;

	// input
	for (int i = 0; i < n; i++) {
		int m;
		cin >> m;
		for (int j = 0; j < m; j++) {
			string temp;
			cin >> temp;
			//input[i][j] = temp;
			input[i] += temp;
			input[i] += ",";
			itemList.insert(temp);
		}
	}

	auto /*itr = itemList.begin();
	while (itr != itemList.end()) {
		cout << *itr << ", ";
		itr++;
	}
	cout << endl;*/

	// solve
	itr = itemList.begin();
	for (; itr != --itemList.end(); itr++) {
		auto itr_temp = itr;
		itr_temp++;
		for (auto itr2=itr_temp; itr2 != itemList.end(); itr2++) {
			string nowFirstItem = *itr;
			string nowSecondItem = *itr2;
			//cout << *itr << " " << *itr2 << endl;

			int nowF = 0;
			for (int i = 0; i < n; i++) {
				if (input[i].find(nowFirstItem) != string::npos &&
					input[i].find(nowSecondItem) != string::npos) {
					nowF++;
				}
			}
			if (nowF >= f) {
				ans++;
				ansList.push_back(make_pair(nowFirstItem, nowSecondItem));
			}
		}
	}

	// output
	cout << ans << endl;
	for (int i = 0; i < ansList.size(); i++) {
		cout << ansList[i].first << " " << ansList[i].second << endl;
	}

}
accuracy: 0.1111111111111111
time_ms: 30
memory_kb: 3040
final_rank: 18

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second

using ps = pair<string,string>;

int main()
{
    int n,f;
    cin >>n >>f;

    vector<string> name;
    map<ps,int> ct;
    rep(i,n)
    {
        int m;
        cin >>m;

        vector<string> s(m);
        rep(j,m)
        {
            cin >>s[j];
            name.pb(s[j]);
        }
        sort(all(s));

        rep(k,m)rep(j,k) ++ct[ps(s[j],s[k])];
    }

    sort(all(name));
    name.erase(unique(all(name)),name.end());

    int N = name.size();

    set<ps> ans;
    rep(j,N)rep(i,j)
    {
        ps p(name[i],name[j]);
        if(ct[p]>=f) ans.insert(p);
    }

    cout << ans.size() << endl;
    for(const auto &p:ans) cout << p.fi << " " << p.se << endl;
    return 0;
}
accuracy: 1
time_ms: 300
memory_kb: 34588
final_rank: 14