Problem:
Icy Composer
Time Limit: 8 sec / Memory Limit: 64 MB
F: 氷の作曲家
岡部錬太郎(愛称オカレン)は，西洋音楽の第一人者である．
彼は，5歳から作曲を行うことができた天才であり，彼が作詞・作曲した『攻城の槌』はとても有名である．
才能あふれるオカレンだが，残念なことに，彼は，レストランで食べた魚にあたって亡くなっている．
・・・少なくとも，この世界線では，そういうことになっている．
世界線とは何か？
一つの歴史は，一つの世界線に対応する．
我々が歩んできた歴史とは，無限に存在する世界線のうちの一つに過ぎず，
別の世界線では，また違った歴史が刻まれている．
オカレンは，自らを待ちうける過酷な未来に立ち向かうために，別の世界線へと旅立つことを決意したのだった．
オカレンが目指す世界線は，かの有名な世界線「ヒャダインズゲート」である．
「ヒャダインズゲート」では，全ての魚は氷の魔法を用いて新鮮なまま冷凍保存されるため，魚にあたる人はいない．
世界線は，アルファベットの小文字からなる文字列で表される．
「ヒャダインズゲート」を表す文字列は既に解明されているが，非常に長い文字列で表される．
これを簡潔に表記するため，文字列
seq
の
N
回の繰り返しを
N
(
seq
) と圧縮して表す．
ここで，
N
は，1以上の自然数であり，
seq
は小文字からなる文字列か，圧縮して表された文字列，または，それらをいくつか連結した文字列である．
例えば，以下の表記は，文字列 bbbababababxbbbababababx を表す．
2(3(b)4(ab)x)
オカレンは，彼のもつ「魔眼リーディングヒャダイナー」によって，彼がいる世界線から次に移動できる世界線を読みとることができる．
彼がいる世界線は，「ヒャダインズゲート」から遠く離れているため，直接「ヒャダインズゲート」へ移動することはできない．
オカレンは，「ヒャダインズゲート」にできるだけ近づくために，「ヒャダインズゲート」に対する類似度が高い世界線へと移動することにした．
「ヒャダインズゲート」を表す文字列を
x
，ある世界線を表す文字列を
y
とした場合，
x
に対する
y
の類似度は，
y
の部分文字列のうち，
x
にも部分文字列として現れるものの数である．
ただし，
y
の部分文字列として同じ文字列が複数回現れたとしても，それらは，別々に数えるものとする．
類似度が同じ世界線が複数ある場合は，先に入力として与えられた世界線の方が類似度が高いとみなすものとする．
諸君には，世界線「ヒャダインズゲート」を表す文字列とオカレンが次に移動できる世界線に対応する文字列が複数与えられたときに，「ヒャダインズゲート」に対する類似度が最も高い世界線を求めてもらいたい．
健闘を祈る．
エル・プサイ・コンガリィ．
Input
入力は以下の形式で与えられる．
n
m
k
s
t
1
t
2
...
t
k
入力形式の各変数の意味は以下の通りである．
n
はヒャダインズゲートを表す文字列
s
の長さ (1 <=
n
<= 250)
m
はオカレンが移動できる世界線を表す文字列の長さ (1 <=
m
<= 400)
k
はオカレンが移動できる世界線を表す文字列の数 (1 <=
k
<= 5)
s
はヒャダインズゲートを表す文字列
t
i
はオカレンが移動できる世界線を表す文字列 (1 <=
i
<=
k
)
Output
文字列
s
に最も類似する文字列
t
i
の番号
i
と類似度を空白区切りで一行で出力せよ．
Sample Input 1
5 3 2
aaaaa
aaa
aab
Sample Output 1
1 6
Sample Input 2
10 3 3
2(ab)3(bc)
abc
bcb
cbc
Sample Output 2
2 6
Sample Input 3
13 24 1
2(3(b)4(ab)x)
bbbababababxbbbababababx
Sample Output 3
1 300
Sample Input 4
12 7 5
hyadainsgate
hyadain
mahyado
behoimi
megante
moshyas
Sample Output 4
1 28
Sample Input 5
44 6 5
sh1000(1000(1000(1000(ee))))t100(a)paz100(u)
sheeta
pazuuu
romusk
apalou
rlaput
Sample Output 5
2 21

Submitted solutions:

code_snippet: #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

int n, m, k;
char input[6][500];
char str[10000100];
set<string> opened;

string Open(int &pos) {
  string ret;
  while (input[5][pos] != '\0' && input[5][pos] != ')') {
    if (isdigit(input[5][pos])) {
      int num = 0;
      while (isdigit(input[5][pos])) {
        num *= 10;
        num += input[5][pos++] - '0';
        num = min(num, m);
      }
      assert(num != 0);
      assert(input[5][pos] == '(');
      pos++;
      string nret = Open(pos);
      assert(input[5][pos] == ')');
      pos++;
      num = min(num, max(2, (m + (int)nret.size() - 1) / (int)nret.size()));
      if (nret.size() >= 400) {
        if (opened.count(nret)) { num = 1; }
        opened.insert(nret);
      }
      string add;
      REP(i, num) { add += nret; }
      if (add.size() >= 400) { opened.insert(add); }
      ret += add;
    } else {
      ret += input[5][pos++];
    }
  }
  assert((int)ret.size() <= 10000000);
  return ret;
}

int main() {
  while (scanf("%d %d %d", &n, &m, &k) > 0) {
    opened.clear();
    scanf("%s", input[5]);
    REP(i, k) {
      scanf("%s", input[i]);
    }
    {
      int pos = 0;
      string s = Open(pos);
      sprintf(str, "%s", s.c_str());
    }
    int ans = -1;
    int maxValue = -1;
    REP(iter, k) {
      int lv = 0;
      REP(r, m) {
        REP(l, r + 1) {
          char c = input[iter][r + 1];
          input[iter][r + 1] = 0;
          lv += strstr(str, input[iter] + l) != NULL;
          input[iter][r + 1] = c;
        }
      }
      if (lv > maxValue) {
        ans = iter + 1;
        maxValue = lv;
      }
    }
    printf("%d %d\n", ans, maxValue);
  }
}
accuracy: 1
time_ms: 6220
memory_kb: 1088
final_rank: 3

code_snippet: #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

int n, m, k;
char input[6][500];
char str[10000100];
set<string> opened;

string Open(int &pos) {
  string ret;
  while (input[5][pos] != '\0' && input[5][pos] != ')') {
    if (isdigit(input[5][pos])) {
      int num = atoi(input[5] + pos);
      int v = 0;
      while (isdigit(input[5][pos])) { pos++; v++; }
      assert(v <= 7);
      assert(input[5][pos] == '(');
      pos++;
      string nret = Open(pos);
      assert(input[5][pos] == ')');
      pos++;
      num = min(num, max(2, (m + (int)nret.size() - 1) / (int)nret.size()));
      if (nret.size() >= 400) {
        if (opened.count(nret)) { num = 1; }
        opened.insert(nret);
      }
      string add;
      REP(i, num) { add += nret; }
      if (add.size() >= 400) { opened.insert(add); }
      ret += add;
    } else {
      ret += input[5][pos++];
    }
  }
  assert((int)ret.size() <= 10000000);
  return ret;
}

int main() {
  while (scanf("%d %d %d", &n, &m, &k) > 0) {
    opened.clear();
    scanf("%s", input[5]);
    REP(i, k) {
      scanf("%s", input[i]);
    }
    {
      int pos = 0;
      string s = Open(pos);
      sprintf(str, "%s", s.c_str());
    }
    int ans = -1;
    int maxValue = -1;
    REP(iter, k) {
      int lv = 0;
      REP(r, m) {
        REP(l, r + 1) {
          char c = input[iter][r + 1];
          input[iter][r + 1] = 0;
          lv += strstr(str, input[iter] + l) != NULL;
          input[iter][r + 1] = c;
        }
      }
      if (lv > maxValue) {
        ans = iter + 1;
        maxValue = lv;
      }
    }
    printf("%d %d\n", ans, maxValue);
  }
}
accuracy: 1
time_ms: 6220
memory_kb: 1088
final_rank: 3

code_snippet: #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

int n, m, k;
char input[6][500];
char str[10000100];
set<string> opened;

string Open(int &pos) {
  string ret;
  while (input[5][pos] != '\0' && input[5][pos] != ')') {
    if (isdigit(input[5][pos])) {
      int num = atoi(input[5] + pos);
      while (isdigit(input[5][pos])) { pos++; }
      assert(input[5][pos] == '(');
      pos++;
      string nret = Open(pos);
      assert(input[5][pos] == ')');
      pos++;
      num = min(num, max(2, (m + (int)nret.size() - 1) / (int)nret.size()));
      if (nret.size() >= 400) {
        if (opened.count(nret)) { num = 1; }
        opened.insert(nret);
      }
      string add;
      REP(i, num) { add += nret; }
      if (add.size() >= 400) { opened.insert(add); }
      ret += add;
    } else {
      ret += input[5][pos++];
    }
  }
  assert((int)ret.size() <= 10000000);
  return ret;
}

int main() {
  while (scanf("%d %d %d", &n, &m, &k) > 0) {
    opened.clear();
    scanf("%s", input[5]);
    REP(i, k) {
      scanf("%s", input[i]);
    }
    {
      int pos = 0;
      string s = Open(pos);
      sprintf(str, "%s", s.c_str());
    }
    int ans = -1;
    int maxValue = -1;
    REP(iter, k) {
      int lv = 0;
      REP(r, m) {
        REP(l, r + 1) {
          char c = input[iter][r + 1];
          input[iter][r + 1] = 0;
          lv += strstr(str, input[iter] + l) != NULL;
          input[iter][r + 1] = c;
        }
      }
      if (lv > maxValue) {
        ans = iter + 1;
        maxValue = lv;
      }
    }
    printf("%d %d\n", ans, maxValue);
  }
}
accuracy: 1
time_ms: 6220
memory_kb: 1088
final_rank: 3

code_snippet: #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

int n, m, k;
char input[6][500];
char str[10000100];
set<string> opened;

string Open(int &pos) {
  string ret;
  while (input[5][pos] != '\0' && input[5][pos] != ')') {
    if (isdigit(input[5][pos])) {
      int num = 0;
      while (isdigit(input[5][pos])) {
        num *= 10;
        num += input[5][pos++] - '0';
        num = min(num, m);
      }
      assert(input[5][pos] == '(');
      pos++;
      string nret = Open(pos);
      assert(input[5][pos] == ')');
      pos++;
      num = min(num, max(2, (m + (int)nret.size() - 1) / (int)nret.size()));
      if (nret.size() >= 400) {
        if (opened.count(nret)) { num = 1; }
        opened.insert(nret);
      }
      string add;
      REP(i, num) { add += nret; }
      if (add.size() >= 400) { opened.insert(add); }
      ret += add;
    } else {
      ret += input[5][pos++];
    }
  }
  assert((int)ret.size() <= 10000000);
  return ret;
}

int main() {
  while (scanf("%d %d %d", &n, &m, &k) > 0) {
    opened.clear();
    scanf("%s", input[5]);
    REP(i, k) {
      scanf("%s", input[i]);
    }
    {
      int pos = 0;
      string s = Open(pos);
      sprintf(str, "%s", s.c_str());
    }
    int ans = -1;
    int maxValue = -1;
    REP(iter, k) {
      int lv = 0;
      REP(r, m) {
        REP(l, r + 1) {
          char c = input[iter][r + 1];
          input[iter][r + 1] = 0;
          lv += strstr(str, input[iter] + l) != NULL;
          input[iter][r + 1] = c;
        }
      }
      if (lv > maxValue) {
        ans = iter + 1;
        maxValue = lv;
      }
    }
    printf("%d %d\n", ans, maxValue);
  }
}
accuracy: 1
time_ms: 6210
memory_kb: 1088
final_rank: 2

code_snippet: #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

int n, m, k;
char input[6][500];
char str[10000100];
set<string> opend;

string Open(int &pos) {
  string ret;
  while (input[5][pos] != '\0' && input[5][pos] != ')') {
    if (isdigit(input[5][pos])) {
      int num = 0;
      while (isdigit(input[5][pos])) {
        num *= 10;
        num += input[5][pos++] - '0';
        num = min(num, m);
      }
      assert(input[5][pos] == '(');
      pos++;
      string nret = Open(pos);
      assert(input[5][pos] == ')');
      pos++;
      num = min(num, max(2, (m + (int)nret.size() - 1) / (int)nret.size()));
      string add;
      REP(i, num) { add += nret; }
      if (add.size() >= 400) {
        if (opend.count(add)) { num = 1; }
        opend.insert(add);
      }
      ret += add;
    } else {
      ret += input[5][pos++];
    }
  }
  assert((int)ret.size() <= 10000000);
  return ret;
}

int main() {
  while (scanf("%d %d %d", &n, &m, &k) > 0) {
    opend.clear();
    scanf("%s", input[5]);
    REP(i, k) {
      scanf("%s", input[i]);
    }
    {
      int pos = 0;
      string s = Open(pos);
      sprintf(str, "%s", s.c_str());
    }
    int ans = -1;
    int maxValue = -1;
    REP(iter, k) {
      int lv = 0;
      REP(r, m) {
        REP(l, r + 1) {
          char c = input[iter][r + 1];
          input[iter][r + 1] = 0;
          lv += strstr(str, input[iter] + l) != NULL;
          input[iter][r + 1] = c;
        }
      }
      if (lv > maxValue) {
        ans = iter + 1;
        maxValue = lv;
      }
    }
    printf("%d %d\n", ans, maxValue);
  }
}
accuracy: 0.8275862068965517
time_ms: 6210
memory_kb: 1084
final_rank: 7

code_snippet: #include<string>
#include<cstring>
#include<iostream>
#include<algorithm>

#define rep(i,n) for(int i=0;i<(n);i++)

using namespace std;

int m;
int idx;
string s;

string expr();

int number(){
	int a=0;
	for(;s[idx]!='(';idx++){
		a=10*a+(s[idx]-'0');
		a=min(a,m);
	}
	return a;
}

string expr2(){
	if(isdigit(s[idx])){
		int num=number();
		idx++;
		string a=expr();
		idx++;

		string res;
		if(a.length()<m){
			rep(i,num){
				if(res.length()>=m) break;
				res+=a;
			}
		}
		else{
			res=a;
			num--;
			if(num>0){
				res+=a.substr(0,m);
				res+='@';
				res+=a.substr(a.length()-m,m);
			}
		}
		return res;
	}
	else return string(1,s[idx++]);
}

string expr(){
	string res;
	while(idx<s.length() && (isdigit(s[idx]) || islower(s[idx]))) res+=expr2();
	return res;
}

void regularize(string &s){
	::s=s;
	idx=0;
	s=expr();
}

class suffix_array{
	const static int N_MAX=200000;
	char s[N_MAX+1];
	int n,sa[N_MAX+1];

	int f[N_MAX+1];
	bool inc[N_MAX+1];

	struct cmp0{
		char *s;
		cmp0(char *s):s(s){}
		bool operator()(int i,int j){ return s[i]<s[j]; }
	};
	struct cmp1{
		int h,*f;
		cmp1(int h,int *f):h(h),f(f){}
		bool operator()(int i,int j){ return i==j||f[i]!=f[j]?f[i]<f[j]:f[i+h]<f[j+h]; }
	};

public:
	void build(const char *ss){
		n=strlen(ss);
		rep(i,n+1){
			s[i]=ss[i];
			sa[i]=i;
		}

		cmp0 c0(s);
		sort(sa,sa+n+1,c0);
		f[sa[0]]=0;
		rep(i,n) f[sa[i+1]]=f[sa[i]]+(c0(sa[i],sa[i+1])?1:0);

		for(int h=1;f[sa[n]]<n;h<<=1){
			cmp1 c1(h,f);
			sort(sa,sa+n+1,c1);
			rep(i,n) inc[i+1]=c1(sa[i],sa[i+1]);
			rep(i,n) f[sa[i+1]]=f[sa[i]]+(inc[i+1]?1:0);
		}
	}

	int calc_lcp(char *a,char *b){
		int i;
		for(i=0;a[i]&&b[i]&&a[i]==b[i];i++);
		return i;
	}

	int solve(char *t){
		int res=0,len;
		for(len=::m;len;len--,t++){
			int lo=0,hi=n;
			while(lo<hi){
				int mi=(lo+hi)/2;
				if(strcmp(t,s+sa[mi])<0) hi=mi; else lo=mi+1;
			}

			int tmp=calc_lcp(t,s+sa[lo]);
			if(lo>0) tmp=max(tmp,calc_lcp(t,s+sa[lo-1]));
			if(lo<n) tmp=max(tmp,calc_lcp(t,s+sa[lo+1]));
			res+=tmp;
		}
		return res;
	}
};

int main(){
	int n,k;
	string s; cin>>n>>m>>k>>s;

	regularize(s);

	static suffix_array SA;
	SA.build(s.c_str());

	int ans=-1,i_ans=-1;
	rep(i,k){
		char t[401]; cin>>t;
		int tmp=SA.solve(t);
		if(ans<tmp) ans=tmp, i_ans=i;
	}
	printf("%d %d\n",i_ans+1,ans);

	return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 1744
final_rank: 1

code_snippet: #include<iostream>
#include<sstream>
#include<vector>
#include<algorithm>
#include<map>
#include<queue>
#include<complex>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cassert>
using namespace std;

#define rep(i,n) for(int i=0;i<(int)n;i++)
#define fr(i,c) for(__typeof(c.begin()) i=c.begin();i!=c.end();i++)
#define pb push_back
#define mp make_pair
#define all(c) c.begin(),c.end()
#define dbg(x) cerr<<#x<<" = "<<(x)<<endl

typedef vector<int> vi;
typedef pair<int,int> pi;
typedef long long ll;
const int inf=(int)1e9;
const double EPS=1e-9, INF=1e12;

// Larsson-Sadakane's Suffix array Construction: O(n (log n)^2)
struct SAComp {
  const int h, *g;
  SAComp(int h, int* g) : h(h), g(g) {}
  bool operator() (int a, int b) {
    return a == b ? false : g[a] != g[b] ? g[a] < g[b] : g[a+h] < g[b+h];
  }
};
int *buildSA(char* t, int n) {
  int g[n+1], b[n+1], *v = new int[n+1];
  rep(i,n+1) v[i] = i, g[i] = t[i];
  b[0] = 0; b[n] = 0;

  sort(v, v+n+1, SAComp(0, g));
  for(int h = 1; b[n] != n ; h *= 2) {
    SAComp comp(h, g);
    sort(v, v+n+1, comp);
    rep(i, n) b[i+1] = b[i] + comp(v[i], v[i+1]);
    rep(i, n+1) g[v[i]] = b[i];
  }
  return v;
}
// Naive matching O(m log n)
int find(char *t, int n, char *p, int m, int *sa) {
  int a = 0, b = n;
  while (a < b) {
    int c = (a + b) / 2;
    if (strncmp(t+sa[c], p, m) < 0) a = c+1; else b = c;
  }
  return strncmp(t+sa[a], p, m) == 0 ? sa[a] : -1;
}
int n,m,k;
string s;
char *sc,t[500];
int *sa,len;

ll ck(){
	ll res=0;
	for(int l=0,r=0;l<m;l++){
		while(r<l)r++;
		while(r<m){
			char tmp=t[r+1];
			t[r+1]=0;
			bool res=find(sc,len,t+l,r-l+1,sa)>=0;
			t[r+1]=tmp;
			if(!res)break;
			r++;
		}
		res+=r-l;
	}
	return res;
}

const string rec(int l,int r){
	if(l>=r)return "";
	
	if(isdigit(s[l])){
		int i,x=0,d=0;
		for(;l<r&&isdigit(s[l]);l++){
			x*=10; x+=s[l]-'0';
			x=min(x,400);
		}
		for(i=l;i<r;i++){
			if(s[i]=='(')d++;
			if(s[i]==')')d--;
			if(d==0)break;
		}
		string res="", tmp=rec(l+1,i);
		if(x==1)return tmp;
		
		rep(i,x-1){
			res+=tmp;
			if(res.size()>400)break;
		}
		const string str=res+tmp;
		if(str.size()<=800)return str+rec(i+1,r);
		const string head400=str.substr(0,min((int)str.size(),400));
		const string tail400=str.substr(max(0,(int)str.size()-400));
		
		const string tail=tmp.substr(max(0,(int)tmp.size()-400));
		const string head=tmp.substr(0,min(400,(int)tmp.size()));
		
		return head400+"@"+tail+res+head+"@"+tail400+rec(i+1,r);
	}
	return s[l]+rec(l+1,r);
}
int main(){
	cin>>n>>m>>k;
	cin>>s;
	s=rec(0,n);
	len=s.size();
	sc=(char*)malloc(len+1);
	sprintf(sc,"%s",s.c_str()); s.clear();
	sa=buildSA(sc,len);
	
	int ansi=0; ll ans=0;
	rep(i,k){
		cin>>t;
		ll tmp=ck();
		if(tmp>ans)ans=tmp, ansi=i;
	}
	cout<<ansi+1<<" "<<ans<<endl;
	
	return 0;
	
}
accuracy: 1
time_ms: 180
memory_kb: 3048
final_rank: 6