답안 #732124

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
732124	2023-04-28T13:52:49 Z	minhcool	새 집 (APIO18_new_home)	C++17	80 / 100	5000 ms	171556 KB

new_home

#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,fma,sse,sse2,sse3,sse4,bmi,abm")
#include<bits/stdc++.h>
using namespace std;
 
//#define int long long
#define fi first
#define se second
#define pb push_back
 
typedef pair<int, int> ii;
typedef pair<ii, int> iii;
typedef pair<ii, ii> iiii;
 
const int N = 3e5 + 5;
const int mod = 1e9 + 7, oo = 1e9 + 7;
 
/*
Algo (Ig)
*/
 
int n, k, q;
 
int a[N], b[N], x[N], t[N];
 
int l[N], y[N];
 
vector<int> times;
 
vector<ii> opes[1048576];
vector<int> asks[N];
multiset<int> mls[N];
 
int mini[1048576], maxi[1048576];
 
vector<int> ask_pos;
 
// get position to add/erase
ii get_pos(int l, int r){
    assert(l <= r);
    int temp1 = lower_bound(ask_pos.begin(), ask_pos.end(), l) - ask_pos.begin();
    int temp2 = upper_bound(ask_pos.begin(), ask_pos.end(), r) - ask_pos.begin();
    temp2--;
    if(temp2 < temp1){
    //	cout << "OK\n";
    //	exit(0);
	}
    //assert(temp2 >= temp1);
    return {temp1, temp2};
}
 
void build(int id, int l, int r){
    mini[id] = oo;
    maxi[id] = -oo;
    if(l == r) return;
    int mid = (l + r) >> 1;
    build(id << 1, l, mid);
    build(id << 1 | 1, mid + 1, r);
}
 
iii ope[10000005];
 
int tol = 0, itr = 0;
 
// update the minimum & maximum
void add(int id, int l, int r, int L, int R, int val, int type){
    if(l > R || r < L) return;
    if(!type){
        if(mini[id] <= val) return;
    }
    else{
        if(maxi[id] >= val) return;
    }
    if(l >= L && r <= R){
        if(!type){
//        	if(mini[id] <= val) return;
        	tol++;
        	itr++;
        	ope[itr] = {{id, 0}, mini[id]};
        	mini[id] = val;
		}
        else{
 //       	if(maxi[id] >= val) return;
        	tol++;
        	itr++;
        	ope[itr] = {{id, 1}, maxi[id]};
        	maxi[id] = val;
		}
        //tol++;
        return;
    }
    int mid = (l + r) >> 1;
    add(id << 1, l, mid, L, R, val, type);
    add(id << 1 | 1, mid + 1, r, L, R, val, type);
}
 
// erase the lasest changes
 
 /*
void er(int id, int l, int r, int L, int R, int type){
    if(l > R || r < L || l > r) return;
    if(l >= L && r <= R){
        if(!type){
//            assert(mini[id].size());
            mini[id].pop_back();
        }
        else{
  //          assert(maxi[id].size());
            maxi[id].pop_back();
        }
        return;
    }
    int mid = (l + r) >> 1;
    er(id << 1, l, mid, L, R, type);
    er(id << 1 | 1, mid + 1, r, L, R, type);
}*/
 
int answer[N];
 
ii ans_que = {oo, -oo};
 
// easy query stuff
 
void que(int id, int l, int r, int pos){
    ans_que.fi = min(ans_que.fi, mini[id]);
    ans_que.se = max(ans_que.se, maxi[id]);
    if(l == r) return;
    int mid = (l + r) >> 1;
    if(pos <= mid) que(id << 1, l, mid, pos);
    else que(id << 1 | 1, mid + 1, r, pos);
}
 
// for persistent segment tree
 
void upd(int id, int l, int r, int L, int R, ii v){
    if(l > R || r < L) return;
    if(l >= L && r <= R){
        opes[id].pb(v);
        return;
    }
    int mid = (l + r) >> 1;
    upd(id << 1, l, mid, L, R, v);
    upd(id << 1 | 1, mid + 1, r, L, R, v);
}
 
map<ii, int> answ;// b/c i'm lazy
 
void trav(int id, int l, int r){
    //cout << id << " " << l << " " << r << "\n";
    tol = 0;
    for(auto it : opes[id]){
        if(k <= 11){
            mls[it.se].erase(mls[it.se].lower_bound(it.fi));
            continue;
        }
       // cout << id << " " << l << " " << r << " " << it.fi << " " << it.se << "\n";
      if(mls[it.se].size() == 1){
            add(1, 1, ask_pos.size() - 1, 1, ask_pos.size() - 1, -oo, 0);
            add(1, 1, ask_pos.size() - 1, 1, ask_pos.size() - 1, oo, 1);
            mls[it.se].clear();
            continue;
      }
        multiset<int>::iterator itt = mls[it.se].lower_bound(it.fi), itt2 = itt, itt3;
//        mls[it.se].erase(itt);
  //      continue;
  //       if(itt == mls[it.se].end()) exit(0);
    //    assert(itt != mls[it.se].end());
        itt2++;
        bool ck1 = (itt == mls[it.se].begin()), ck2 = (itt2 == mls[it.se].end());
        if(ck1){// the left side is missing
            int pos = lower_bound(ask_pos.begin(), ask_pos.end(), (*itt2)) - ask_pos.begin();
            pos--;
            if(pos) add(1, 1, ask_pos.size() - 1, 1, pos, (*itt2), 1);
        }
        else if(ck2){// the right side is missing
            itt2--;
            itt2--;
            int pos = lower_bound(ask_pos.begin(), ask_pos.end(), (*itt2)) - ask_pos.begin();
            if(pos < ask_pos.size()) add(1, 1, ask_pos.size() - 1, pos, ask_pos.size() - 1, (*itt2), 0);
        }
        else{
            itt2 = itt3 = itt;
            itt2++; itt3--;
            int md = ((*itt2) + (*itt3)) / 2;
            int pos1 = lower_bound(ask_pos.begin(), ask_pos.end(), (*itt3)) - ask_pos.begin();
            int pos2 = upper_bound(ask_pos.begin(), ask_pos.end(), md) - ask_pos.begin();
            int pos3 = upper_bound(ask_pos.begin(), ask_pos.end(), (*itt2)) - ask_pos.begin();
            pos2--;
            pos3--;
            if(pos1 <= pos2) add(1, 1, ask_pos.size() - 1, pos1, pos2, (*itt3), 0);
            if(pos2 < pos3) add(1, 1, ask_pos.size() - 1, pos2 + 1, pos3, (*itt2), 1);
        }
        mls[it.se].erase(itt);
    }
    int temp = tol;
    if(l == r){
        if(k > 11){
            for(auto it : asks[l]){
                ans_que = {oo, -oo};
                int temp = lower_bound(ask_pos.begin(), ask_pos.end(), it) - ask_pos.begin();
                que(1, 1, ask_pos.size() - 1, temp);
                answ[{times[l], it}] = max(it - ans_que.fi, ans_que.se - it);
            }
        }
        else{
            for(auto it : asks[l]){
                int ans = -oo;
                for(int i = 1; i <= k; i++){
                    if(!mls[i].size()){
                        ans = oo;
                        break;
                    }
                    multiset<int>::iterator it2 = mls[i].lower_bound(it);
                    int mini = oo;
                    if(it2 != mls[i].end()) mini = min(mini, (*it2) - it);
                    if(it2 != mls[i].begin()){
                        it2--;
                        mini = min(mini, it - (*it2));
                    }
                    ans = max(ans, mini);
                }
                answ[{times[l], it}] = ans;
            }
        }
    }
    else{
        int mid = (l + r) >> 1;
        trav(id << 1, l, mid);
        trav(id << 1 | 1, mid + 1, r);
    }
    assert(itr >= temp);
    for(auto it : opes[id]) mls[it.se].insert(it.fi);
    if(k > 11){
        for(int i = 1; i <= temp; i++){
        	if(!ope[itr].fi.se) mini[ope[itr].fi.fi] = ope[itr].se;
        	else maxi[ope[itr].fi.fi] = ope[itr].se;
        	itr--;
        	assert(itr >= 0);
    	}
    }
    /*
    reverse(opes[id].begin(), opes[id].end());
    for(auto it : opes[id]){
        mls[it.se].insert(it.fi);
        multiset<int>::iterator itt = mls[it.se].lower_bound(it.fi), itt2 = itt, itt3;
        assert(itt != mls[it.se].end());
        itt2++;
        bool ck1 = (itt == mls[it.se].begin()), ck2 = (itt2 == mls[it.se].end());
        if(ck1 && ck2){
            er(1, 1, ask_pos.size() - 1,  1, ask_pos.size() - 1, 0);
            er(1, 1, ask_pos.size() - 1, 1, ask_pos.size() - 1, 1);
            continue;
        }
        else if(ck1){
            int pos = lower_bound(ask_pos.begin(), ask_pos.end(), (*itt2)) - ask_pos.begin();
            pos--;
            if(pos) er(1, 1, ask_pos.size() - 1, 1, pos, 1);
        }
        else if(ck2){
            itt2--;
            itt2--;
            int pos = lower_bound(ask_pos.begin(), ask_pos.end(), (*itt2)) - ask_pos.begin();
            if(pos < ask_pos.size()) er(1, 1, ask_pos.size() - 1, pos, ask_pos.size() - 1, 0);
        }
        else{
            itt2 = itt3 = itt;
            itt2++; itt3--;
            int md = ((*itt2) + (*itt3)) / 2;
            int pos1 = lower_bound(ask_pos.begin(), ask_pos.end(), (*itt3)) - ask_pos.begin();
            int pos2 = upper_bound(ask_pos.begin(), ask_pos.end(), md) - ask_pos.begin();
            int pos3 = upper_bound(ask_pos.begin(), ask_pos.end(), (*itt2)) - ask_pos.begin();
            pos2--;
            pos3--;
            if(pos1 <= pos2) er(1, 1, ask_pos.size() - 1, pos1, pos2, 0);
            if(pos2 < pos3) er(1, 1, ask_pos.size() - 1, pos2 + 1, pos3, 1);
        }
        //mls[it.se].insert(it.fi);
    }*/
}
 
void process(){
    cin >> n >> k >> q;
    for(int i = 1; i <= n; i++) cin >> x[i] >> t[i] >> a[i] >> b[i];
    for(int i = 1; i <= q; i++){
        cin >> l[i] >> y[i];
        ask_pos.pb(l[i]);
    }
    times.pb(0);
    times.pb(1);
    times.pb(1e8);
    /*
    for(int i = 1; i <= n; i++){
        if(a[i] > 2) times.pb(a[i] - 1);
        if((b[i] + 1) < 1e8) times.pb(b[i] + 1);
    }*/
    ask_pos.pb(0);
    sort(ask_pos.begin(), ask_pos.end());
    ask_pos.resize(unique(ask_pos.begin(), ask_pos.end()) - ask_pos.begin());
    // push the erase operations
    for(int i = 1; i <= q; i++) times.pb(y[i]);
    sort(times.begin(), times.end());
    times.resize(unique(times.begin(), times.end()) - times.begin());
    for(int i = 1; i <= n; i++){
        if(a[i] > 1){
            int le = 1, ri = lower_bound(times.begin(), times.end(), a[i]) - times.begin();
            ri--;
            if(le <= ri) upd(1, 1, times.size() - 1, le, ri, {x[i], t[i]});
        }
        if((b[i] + 1 < 1e8)){
            int le = lower_bound(times.begin(), times.end(), b[i] + 1) - times.begin(), ri = times.size() - 1;
            upd(1, 1, times.size() - 1, le, ri, {x[i], t[i]});
        }
    }
    //exit(0);
    // insert the queries
    for(int i = 1; i <= q; i++){
        int temp = lower_bound(times.begin(), times.end(), y[i]) - times.begin();
        asks[temp].pb(l[i]);
    }
    // initialize (not erase anything)
    for(int i = 1; i <= n; i++) mls[t[i]].insert(x[i]);
   // cout << ask_pos.size() - 1 << "\n";
//    exit(0);
    build(1, 1, ask_pos.size() - 1);
    for(int i = 1; i <= k; i++){
        if(!mls[i].size()){
            add(1, 1, ask_pos.size() - 1,  1, ask_pos.size() - 1, -oo, 0);
            add(1, 1, ask_pos.size() - 1, 1, ask_pos.size() - 1, oo, 1);
            continue;
        }
        //continue;
        int lst = -oo;
        int cnt = 0;
        for(multiset<int>::iterator it = mls[i].begin(); it != mls[i].end(); it++){
            int le = 1, ri = 1e8;
            if(it != mls[i].begin()){
                multiset<int>::iterator it2 = it;
                it2--;
                le = ((*it) + (*it2)) / 2 + 1;
            }
            multiset<int>::iterator it2 = it;
            it2++;
            if(it2 != mls[i].end()) ri = ((*it) + (*it2)) / 2;
 //           if(le > ri || le == ask_pos.size()) continue;
            if(le > ri) continue;
            if(le > ask_pos.back()) continue;
            ii temp = get_pos(le, ri);
            if(temp.fi > temp.se) continue;
            temp.se = min(temp.se, (int)ask_pos.size() - 1);
            if(temp.fi > temp.se) continue;
            int posi = lower_bound(ask_pos.begin(), ask_pos.end(), (*it)) - ask_pos.begin();
            if(temp.fi < posi) add(1, 1, ask_pos.size() - 1, temp.fi, posi - 1, (*it), 1);
            if(posi <= temp.se) add(1, 1, ask_pos.size() - 1, posi, temp.se, (*it), 0);
        }
    }
    //cout << (double)clock() / (double)CLOCKS_PER_SEC << "\n";
    //exit(0);
    trav(1, 1, times.size() - 1);
    //cout << (double)clock() / (double)CLOCKS_PER_SEC << "\n";
    for(int i = 1; i <= q; i++) cout << (answ[{y[i], l[i]}] <= 1e8 ? answ[{y[i], l[i]}] : -1) << "\n";
    //cout << (double)clock() / (double)CLOCKS_PER_SEC << "\n";
}
 
signed main(){
    ios_base::sync_with_stdio(0);
    //freopen("test_input.txt", "r", stdin);
    //freopen("test_output.txt", "w", stdout);
    cin.tie(0);
    process();
}

Compilation message

new_home.cpp: In function 'void trav(int, int, int)':
new_home.cpp:180:20: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  180 |             if(pos < ask_pos.size()) add(1, 1, ask_pos.size() - 1, pos, ask_pos.size() - 1, (*itt2), 0);
      |                ~~~~^~~~~~~~~~~~~~~~
new_home.cpp: In function 'void process()':
new_home.cpp:333:13: warning: unused variable 'lst' [-Wunused-variable]
  333 |         int lst = -oo;
      |             ^~~
new_home.cpp:334:13: warning: unused variable 'cnt' [-Wunused-variable]
  334 |         int cnt = 0;
      |             ^~~

Subtask #1

5.0 / 5.0

#	결과	실행 시간	메모리	Grader output
1	Correct	26 ms	46100 KB	Output is correct
2	Correct	28 ms	46008 KB	Output is correct
3	Correct	26 ms	46028 KB	Output is correct
4	Correct	27 ms	46132 KB	Output is correct
5	Correct	29 ms	46164 KB	Output is correct
6	Correct	30 ms	46292 KB	Output is correct
7	Correct	25 ms	46248 KB	Output is correct
8	Correct	30 ms	46220 KB	Output is correct
9	Correct	28 ms	46204 KB	Output is correct
10	Correct	35 ms	46256 KB	Output is correct
11	Correct	29 ms	46272 KB	Output is correct
12	Correct	26 ms	46232 KB	Output is correct
13	Correct	29 ms	46224 KB	Output is correct
14	Correct	28 ms	46308 KB	Output is correct
15	Correct	29 ms	46280 KB	Output is correct
16	Correct	33 ms	46192 KB	Output is correct
17	Correct	26 ms	46236 KB	Output is correct
18	Correct	28 ms	46292 KB	Output is correct
19	Correct	27 ms	46240 KB	Output is correct
20	Correct	33 ms	46288 KB	Output is correct
21	Correct	32 ms	46120 KB	Output is correct
22	Correct	30 ms	46284 KB	Output is correct
23	Correct	28 ms	46284 KB	Output is correct
24	Correct	26 ms	46288 KB	Output is correct
25	Correct	33 ms	46248 KB	Output is correct
26	Correct	27 ms	46208 KB	Output is correct
27	Correct	31 ms	46204 KB	Output is correct
28	Correct	31 ms	46204 KB	Output is correct
29	Correct	28 ms	46228 KB	Output is correct
30	Correct	28 ms	46220 KB	Output is correct

Subtask #2

7.0 / 7.0

#	결과	실행 시간	메모리	Grader output
1	Correct	26 ms	46100 KB	Output is correct
2	Correct	28 ms	46008 KB	Output is correct
3	Correct	26 ms	46028 KB	Output is correct
4	Correct	27 ms	46132 KB	Output is correct
5	Correct	29 ms	46164 KB	Output is correct
6	Correct	30 ms	46292 KB	Output is correct
7	Correct	25 ms	46248 KB	Output is correct
8	Correct	30 ms	46220 KB	Output is correct
9	Correct	28 ms	46204 KB	Output is correct
10	Correct	35 ms	46256 KB	Output is correct
11	Correct	29 ms	46272 KB	Output is correct
12	Correct	26 ms	46232 KB	Output is correct
13	Correct	29 ms	46224 KB	Output is correct
14	Correct	28 ms	46308 KB	Output is correct
15	Correct	29 ms	46280 KB	Output is correct
16	Correct	33 ms	46192 KB	Output is correct
17	Correct	26 ms	46236 KB	Output is correct
18	Correct	28 ms	46292 KB	Output is correct
19	Correct	27 ms	46240 KB	Output is correct
20	Correct	33 ms	46288 KB	Output is correct
21	Correct	32 ms	46120 KB	Output is correct
22	Correct	30 ms	46284 KB	Output is correct
23	Correct	28 ms	46284 KB	Output is correct
24	Correct	26 ms	46288 KB	Output is correct
25	Correct	33 ms	46248 KB	Output is correct
26	Correct	27 ms	46208 KB	Output is correct
27	Correct	31 ms	46204 KB	Output is correct
28	Correct	31 ms	46204 KB	Output is correct
29	Correct	28 ms	46228 KB	Output is correct
30	Correct	28 ms	46220 KB	Output is correct
31	Correct	1057 ms	68456 KB	Output is correct
32	Correct	191 ms	53380 KB	Output is correct
33	Correct	651 ms	69872 KB	Output is correct
34	Correct	946 ms	69172 KB	Output is correct
35	Correct	1077 ms	68924 KB	Output is correct
36	Correct	705 ms	69304 KB	Output is correct
37	Correct	1082 ms	71024 KB	Output is correct
38	Correct	495 ms	70044 KB	Output is correct
39	Correct	460 ms	70104 KB	Output is correct
40	Correct	469 ms	69932 KB	Output is correct
41	Correct	760 ms	69368 KB	Output is correct
42	Correct	648 ms	69048 KB	Output is correct
43	Correct	72 ms	51908 KB	Output is correct
44	Correct	699 ms	69660 KB	Output is correct
45	Correct	783 ms	70184 KB	Output is correct
46	Correct	445 ms	70360 KB	Output is correct
47	Correct	334 ms	69592 KB	Output is correct
48	Correct	368 ms	69452 KB	Output is correct
49	Correct	714 ms	70432 KB	Output is correct
50	Correct	556 ms	70336 KB	Output is correct
51	Correct	372 ms	70076 KB	Output is correct

Subtask #3

10.0 / 10.0

#	결과	실행 시간	메모리	Grader output
1	Correct	1207 ms	110540 KB	Output is correct
2	Correct	2458 ms	116052 KB	Output is correct
3	Correct	1092 ms	111368 KB	Output is correct
4	Correct	1261 ms	111672 KB	Output is correct
5	Correct	1419 ms	112992 KB	Output is correct
6	Correct	2053 ms	116952 KB	Output is correct
7	Correct	1008 ms	112556 KB	Output is correct
8	Correct	1082 ms	112876 KB	Output is correct
9	Correct	1143 ms	113396 KB	Output is correct
10	Correct	1109 ms	113648 KB	Output is correct
11	Correct	766 ms	117104 KB	Output is correct
12	Correct	828 ms	114856 KB	Output is correct

Subtask #4

23.0 / 23.0

#	결과	실행 시간	메모리	Grader output
1	Correct	4496 ms	149416 KB	Output is correct
2	Correct	1054 ms	79232 KB	Output is correct
3	Correct	4769 ms	151092 KB	Output is correct
4	Correct	1868 ms	145540 KB	Output is correct
5	Correct	3038 ms	145600 KB	Output is correct
6	Correct	2596 ms	145664 KB	Output is correct
7	Correct	3405 ms	148900 KB	Output is correct
8	Correct	3980 ms	151992 KB	Output is correct
9	Correct	1561 ms	137292 KB	Output is correct
10	Correct	2341 ms	140916 KB	Output is correct
11	Correct	2975 ms	144320 KB	Output is correct
12	Correct	4008 ms	147872 KB	Output is correct
13	Correct	1363 ms	147532 KB	Output is correct
14	Correct	1293 ms	147116 KB	Output is correct
15	Correct	2443 ms	148600 KB	Output is correct
16	Correct	2384 ms	145604 KB	Output is correct
17	Correct	1734 ms	148428 KB	Output is correct

Subtask #5

35.0 / 35.0

#	결과	실행 시간	메모리	Grader output
1	Correct	26 ms	46100 KB	Output is correct
2	Correct	28 ms	46008 KB	Output is correct
3	Correct	26 ms	46028 KB	Output is correct
4	Correct	27 ms	46132 KB	Output is correct
5	Correct	29 ms	46164 KB	Output is correct
6	Correct	30 ms	46292 KB	Output is correct
7	Correct	25 ms	46248 KB	Output is correct
8	Correct	30 ms	46220 KB	Output is correct
9	Correct	28 ms	46204 KB	Output is correct
10	Correct	35 ms	46256 KB	Output is correct
11	Correct	29 ms	46272 KB	Output is correct
12	Correct	26 ms	46232 KB	Output is correct
13	Correct	29 ms	46224 KB	Output is correct
14	Correct	28 ms	46308 KB	Output is correct
15	Correct	29 ms	46280 KB	Output is correct
16	Correct	33 ms	46192 KB	Output is correct
17	Correct	26 ms	46236 KB	Output is correct
18	Correct	28 ms	46292 KB	Output is correct
19	Correct	27 ms	46240 KB	Output is correct
20	Correct	33 ms	46288 KB	Output is correct
21	Correct	32 ms	46120 KB	Output is correct
22	Correct	30 ms	46284 KB	Output is correct
23	Correct	28 ms	46284 KB	Output is correct
24	Correct	26 ms	46288 KB	Output is correct
25	Correct	33 ms	46248 KB	Output is correct
26	Correct	27 ms	46208 KB	Output is correct
27	Correct	31 ms	46204 KB	Output is correct
28	Correct	31 ms	46204 KB	Output is correct
29	Correct	28 ms	46228 KB	Output is correct
30	Correct	28 ms	46220 KB	Output is correct
31	Correct	1057 ms	68456 KB	Output is correct
32	Correct	191 ms	53380 KB	Output is correct
33	Correct	651 ms	69872 KB	Output is correct
34	Correct	946 ms	69172 KB	Output is correct
35	Correct	1077 ms	68924 KB	Output is correct
36	Correct	705 ms	69304 KB	Output is correct
37	Correct	1082 ms	71024 KB	Output is correct
38	Correct	495 ms	70044 KB	Output is correct
39	Correct	460 ms	70104 KB	Output is correct
40	Correct	469 ms	69932 KB	Output is correct
41	Correct	760 ms	69368 KB	Output is correct
42	Correct	648 ms	69048 KB	Output is correct
43	Correct	72 ms	51908 KB	Output is correct
44	Correct	699 ms	69660 KB	Output is correct
45	Correct	783 ms	70184 KB	Output is correct
46	Correct	445 ms	70360 KB	Output is correct
47	Correct	334 ms	69592 KB	Output is correct
48	Correct	368 ms	69452 KB	Output is correct
49	Correct	714 ms	70432 KB	Output is correct
50	Correct	556 ms	70336 KB	Output is correct
51	Correct	372 ms	70076 KB	Output is correct
52	Correct	303 ms	70028 KB	Output is correct
53	Correct	336 ms	70624 KB	Output is correct
54	Correct	470 ms	70272 KB	Output is correct
55	Correct	497 ms	70492 KB	Output is correct
56	Correct	405 ms	68976 KB	Output is correct
57	Correct	591 ms	70896 KB	Output is correct
58	Correct	496 ms	71572 KB	Output is correct
59	Correct	441 ms	70560 KB	Output is correct
60	Correct	564 ms	71148 KB	Output is correct
61	Correct	65 ms	53584 KB	Output is correct
62	Correct	282 ms	69816 KB	Output is correct
63	Correct	380 ms	70220 KB	Output is correct
64	Correct	412 ms	70424 KB	Output is correct
65	Correct	519 ms	71688 KB	Output is correct
66	Correct	604 ms	70924 KB	Output is correct
67	Correct	170 ms	55856 KB	Output is correct

Subtask #6

0 / 20.0

#	결과	실행 시간	메모리	Grader output
1	Correct	26 ms	46100 KB	Output is correct
2	Correct	28 ms	46008 KB	Output is correct
3	Correct	26 ms	46028 KB	Output is correct
4	Correct	27 ms	46132 KB	Output is correct
5	Correct	29 ms	46164 KB	Output is correct
6	Correct	30 ms	46292 KB	Output is correct
7	Correct	25 ms	46248 KB	Output is correct
8	Correct	30 ms	46220 KB	Output is correct
9	Correct	28 ms	46204 KB	Output is correct
10	Correct	35 ms	46256 KB	Output is correct
11	Correct	29 ms	46272 KB	Output is correct
12	Correct	26 ms	46232 KB	Output is correct
13	Correct	29 ms	46224 KB	Output is correct
14	Correct	28 ms	46308 KB	Output is correct
15	Correct	29 ms	46280 KB	Output is correct
16	Correct	33 ms	46192 KB	Output is correct
17	Correct	26 ms	46236 KB	Output is correct
18	Correct	28 ms	46292 KB	Output is correct
19	Correct	27 ms	46240 KB	Output is correct
20	Correct	33 ms	46288 KB	Output is correct
21	Correct	32 ms	46120 KB	Output is correct
22	Correct	30 ms	46284 KB	Output is correct
23	Correct	28 ms	46284 KB	Output is correct
24	Correct	26 ms	46288 KB	Output is correct
25	Correct	33 ms	46248 KB	Output is correct
26	Correct	27 ms	46208 KB	Output is correct
27	Correct	31 ms	46204 KB	Output is correct
28	Correct	31 ms	46204 KB	Output is correct
29	Correct	28 ms	46228 KB	Output is correct
30	Correct	28 ms	46220 KB	Output is correct
31	Correct	1057 ms	68456 KB	Output is correct
32	Correct	191 ms	53380 KB	Output is correct
33	Correct	651 ms	69872 KB	Output is correct
34	Correct	946 ms	69172 KB	Output is correct
35	Correct	1077 ms	68924 KB	Output is correct
36	Correct	705 ms	69304 KB	Output is correct
37	Correct	1082 ms	71024 KB	Output is correct
38	Correct	495 ms	70044 KB	Output is correct
39	Correct	460 ms	70104 KB	Output is correct
40	Correct	469 ms	69932 KB	Output is correct
41	Correct	760 ms	69368 KB	Output is correct
42	Correct	648 ms	69048 KB	Output is correct
43	Correct	72 ms	51908 KB	Output is correct
44	Correct	699 ms	69660 KB	Output is correct
45	Correct	783 ms	70184 KB	Output is correct
46	Correct	445 ms	70360 KB	Output is correct
47	Correct	334 ms	69592 KB	Output is correct
48	Correct	368 ms	69452 KB	Output is correct
49	Correct	714 ms	70432 KB	Output is correct
50	Correct	556 ms	70336 KB	Output is correct
51	Correct	372 ms	70076 KB	Output is correct
52	Correct	1207 ms	110540 KB	Output is correct
53	Correct	2458 ms	116052 KB	Output is correct
54	Correct	1092 ms	111368 KB	Output is correct
55	Correct	1261 ms	111672 KB	Output is correct
56	Correct	1419 ms	112992 KB	Output is correct
57	Correct	2053 ms	116952 KB	Output is correct
58	Correct	1008 ms	112556 KB	Output is correct
59	Correct	1082 ms	112876 KB	Output is correct
60	Correct	1143 ms	113396 KB	Output is correct
61	Correct	1109 ms	113648 KB	Output is correct
62	Correct	766 ms	117104 KB	Output is correct
63	Correct	828 ms	114856 KB	Output is correct
64	Correct	4496 ms	149416 KB	Output is correct
65	Correct	1054 ms	79232 KB	Output is correct
66	Correct	4769 ms	151092 KB	Output is correct
67	Correct	1868 ms	145540 KB	Output is correct
68	Correct	3038 ms	145600 KB	Output is correct
69	Correct	2596 ms	145664 KB	Output is correct
70	Correct	3405 ms	148900 KB	Output is correct
71	Correct	3980 ms	151992 KB	Output is correct
72	Correct	1561 ms	137292 KB	Output is correct
73	Correct	2341 ms	140916 KB	Output is correct
74	Correct	2975 ms	144320 KB	Output is correct
75	Correct	4008 ms	147872 KB	Output is correct
76	Correct	1363 ms	147532 KB	Output is correct
77	Correct	1293 ms	147116 KB	Output is correct
78	Correct	2443 ms	148600 KB	Output is correct
79	Correct	2384 ms	145604 KB	Output is correct
80	Correct	1734 ms	148428 KB	Output is correct
81	Correct	303 ms	70028 KB	Output is correct
82	Correct	336 ms	70624 KB	Output is correct
83	Correct	470 ms	70272 KB	Output is correct
84	Correct	497 ms	70492 KB	Output is correct
85	Correct	405 ms	68976 KB	Output is correct
86	Correct	591 ms	70896 KB	Output is correct
87	Correct	496 ms	71572 KB	Output is correct
88	Correct	441 ms	70560 KB	Output is correct
89	Correct	564 ms	71148 KB	Output is correct
90	Correct	65 ms	53584 KB	Output is correct
91	Correct	282 ms	69816 KB	Output is correct
92	Correct	380 ms	70220 KB	Output is correct
93	Correct	412 ms	70424 KB	Output is correct
94	Correct	519 ms	71688 KB	Output is correct
95	Correct	604 ms	70924 KB	Output is correct
96	Correct	170 ms	55856 KB	Output is correct
97	Correct	2375 ms	171556 KB	Output is correct
98	Correct	1099 ms	85496 KB	Output is correct
99	Execution timed out	5091 ms	169568 KB	Time limit exceeded
100	Halted	0 ms	0 KB	-