Submission #346710

#	Submission time	Handle	Problem	Language	Result	Execution time	Memory
346710	2021-01-10T19:14:46 Z	ant101	Airline Route Map (JOI18_airline)	C++14	37 / 100	843 ms	29512 KB

Alice

#include "Alicelib.h"
#include <iostream>
#include <algorithm>
#include <cstring>
#include <iomanip>
#include <fstream>
#include <cmath>
#include <vector>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <map>
#include <stack>
#include <queue>
#include <assert.h>
#include <limits>
#include <cstdio>
#include <complex>
using namespace std;

typedef long long ll;
typedef long double ld;
typedef double db;
typedef string str;

typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
#define mp make_pair
#define f first
#define s second

typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<ld> vd;
typedef vector<str> vs;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<pd> vpd;

#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define rsz resize
#define ins insert
#define ft front()
#define bk back()
#define pf push_front
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)

const int MOD = 1e9+7; // 998244353; // = (119<<23)+1
const int MX = 2e2+5;
const ll INF = 1e18;
const ld PI = 4*atan((ld)1);
const int dx[4] = {0,1,0,-1}, dy[4] = {1,0,-1,0};


namespace io {
    void setIn(string s) { freopen(s.c_str(),"r",stdin); }
    void setOut(string s) { freopen(s.c_str(),"w",stdout); }
    void setIO(string s = "") {
        ios_base::sync_with_stdio(0); cin.tie(0); // fast I/O
        // cin.exceptions(cin.failbit); // ex. throws exception when you try to read letter into int
        if (sz(s)) {
            setIn(s+".in");
            setOut(s+".out");
        } // for USACO
    }
}

using namespace io;

namespace input {
    template<class T> void re(complex<T>& x);
    template<class T1, class T2> void re(pair<T1,T2>& p);
    template<class T> void re(vector<T>& a);
    template<class T, size_t SZ> void re(array<T,SZ>& a);
    
    template<class T> void re(T& x) { cin >> x; }
    void re(double& x) { string t; re(t); x = stod(t); }
    void re(ld& x) { string t; re(t); x = stold(t); }
    template<class Arg, class... Args> void re(Arg& first, Args&... rest) {
        re(first); re(rest...);
    }
    
    template<class T> void re(complex<T>& x) { T a,b; re(a,b); x = cd(a,b); }
    template<class T1, class T2> void re(pair<T1,T2>& p) { re(p.f,p.s); }
    template<class T> void re(vector<T>& a) { F0R(i,sz(a)) re(a[i]); }
    template<class T, size_t SZ> void re(array<T,SZ>& a) { F0R(i,SZ) re(a[i]); }
}

namespace output {
    template<class T1, class T2> void pr(const pair<T1,T2>& x);
    template<class T, size_t SZ> void pr(const array<T,SZ>& x);
    template<class T> void pr(const vector<T>& x);
    template<class T> void pr(const set<T>& x);
    template<class T1, class T2> void pr(const map<T1,T2>& x);
    
    template<class T> void pr(const T& x) { cout << x; }
    template<class Arg, class... Args> void pr(const Arg& first, const Args&... rest) {
        pr(first); pr(rest...);
    }
    
    template<class T1, class T2> void pr(const pair<T1,T2>& x) {
        pr("{",x.f,", ",x.s,"}");
    }
    template<class T> void prContain(const T& x) {
        pr("{");
        bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0; // const needed for vector<bool>
        pr("}");
    }
    template<class T, size_t SZ> void pr(const array<T,SZ>& x) { prContain(x); }
    template<class T> void pr(const vector<T>& x) { prContain(x); }
    template<class T> void pr(const set<T>& x) { prContain(x); }
    template<class T1, class T2> void pr(const map<T1,T2>& x) { prContain(x); }
    
    void ps() { pr("\n"); }
    template<class Arg> void ps(const Arg& first) {
        pr(first); ps(); // no space at end of line
    }
    template<class Arg, class... Args> void ps(const Arg& first, const Args&... rest) {
        pr(first," "); ps(rest...); // print w/ spaces
    }
}

using namespace output;

using namespace input;

ll add(ll a, ll b) {
    a += b;
    if(a >= MOD) {
        a -= MOD;
    }
    return a;
}
ll sub(ll a, ll b) {
    a -= b;
    if(a < 0) {
        a += MOD;
    }
    return a;
}

ll mul(ll a, ll b) {
    return (a * b)%MOD;
}

void add_self(ll& a, ll b) {
    a = add(a, b);
}
void sub_self(ll& a, ll b) {
    a = sub(a, b);
}
void mul_self(ll& a, ll b) {
    a = mul(a, b);
}


bool isOn(int i, int m) { return ((1<<i)&m) != 0 ; }

void Alice(int N, int M, int A[], int B[] ){
    
    if(N == 1)
    {
        InitG(1,0) ;
        return ;
    }
    
    int _log = 10 ;
    
    vector< pair<int,int> > edge ;
    
    for(int i = 0 ; i< M ; i++ ) edge.push_back( make_pair(A[i] , B[i]) ) ;
    
    for(int i = 0 ; i <= _log ; i++ )
        for(int j = 0 ; j < N ; j++ )
            if(isOn(i,j+1)) edge.push_back( make_pair(i+N, j) ) ;
    
    for(int i = 0 ; i < _log ; i++ ) edge.push_back(make_pair(i+N, i+1+N)) ;
    
    for(int i = 0 ; i < N ; i++ ) edge.push_back( make_pair(N+_log+1, i) ) ;
    for(int i = 0 ; i < N+_log ; i++ ) edge.push_back( make_pair(N+_log+2 , i  ) ) ;
    
    //for(auto e : edge ) cout << e.first << " " << e.second << endl ;
    
    InitG(N+_log+3, sz(edge)) ;
    for(int i = 0 ; i < sz(edge) ; i++ ) MakeG( i, edge[i].first, edge[i].second );
    
}

Bob

#include "Boblib.h"
#include <iostream>
#include <algorithm>
#include <cstring>
#include <iomanip>
#include <fstream>
#include <cmath>
#include <vector>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <map>
#include <stack>
#include <queue>
#include <assert.h>
#include <limits>
#include <cstdio>
#include <complex>
#include <cassert>
#include <numeric>
using namespace std;

typedef long long ll;
typedef long double ld;
typedef double db;
typedef string str;

typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
#define mp make_pair
#define f first
#define s second

typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<ld> vd;
typedef vector<str> vs;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<pd> vpd;

#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define rsz resize
#define ins insert
#define ft front()
#define bk back()
#define pf push_front
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)

const int MOD = 1e9+7; // 998244353; // = (119<<23)+1
const int MX = 2e2+5;
const ll INF = 1e18;
const ld PI = 4*atan((ld)1);
const int dx[4] = {0,1,0,-1}, dy[4] = {1,0,-1,0};


namespace io {
    void setIn(string s) { freopen(s.c_str(),"r",stdin); }
    void setOut(string s) { freopen(s.c_str(),"w",stdout); }
    void setIO(string s = "") {
        ios_base::sync_with_stdio(0); cin.tie(0); // fast I/O
        // cin.exceptions(cin.failbit); // ex. throws exception when you try to read letter into int
        if (sz(s)) {
            setIn(s+".in");
            setOut(s+".out");
        } // for USACO
    }
}

using namespace io;

namespace input {
    template<class T> void re(complex<T>& x);
    template<class T1, class T2> void re(pair<T1,T2>& p);
    template<class T> void re(vector<T>& a);
    template<class T, size_t SZ> void re(array<T,SZ>& a);
    
    template<class T> void re(T& x) { cin >> x; }
    void re(double& x) { string t; re(t); x = stod(t); }
    void re(ld& x) { string t; re(t); x = stold(t); }
    template<class Arg, class... Args> void re(Arg& first, Args&... rest) {
        re(first); re(rest...);
    }
    
    template<class T> void re(complex<T>& x) { T a,b; re(a,b); x = cd(a,b); }
    template<class T1, class T2> void re(pair<T1,T2>& p) { re(p.f,p.s); }
    template<class T> void re(vector<T>& a) { F0R(i,sz(a)) re(a[i]); }
    template<class T, size_t SZ> void re(array<T,SZ>& a) { F0R(i,SZ) re(a[i]); }
}

namespace output {
    template<class T1, class T2> void pr(const pair<T1,T2>& x);
    template<class T, size_t SZ> void pr(const array<T,SZ>& x);
    template<class T> void pr(const vector<T>& x);
    template<class T> void pr(const set<T>& x);
    template<class T1, class T2> void pr(const map<T1,T2>& x);
    
    template<class T> void pr(const T& x) { cout << x; }
    template<class Arg, class... Args> void pr(const Arg& first, const Args&... rest) {
        pr(first); pr(rest...);
    }
    
    template<class T1, class T2> void pr(const pair<T1,T2>& x) {
        pr("{",x.f,", ",x.s,"}");
    }
    template<class T> void prContain(const T& x) {
        pr("{");
        bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0; // const needed for vector<bool>
        pr("}");
    }
    template<class T, size_t SZ> void pr(const array<T,SZ>& x) { prContain(x); }
    template<class T> void pr(const vector<T>& x) { prContain(x); }
    template<class T> void pr(const set<T>& x) { prContain(x); }
    template<class T1, class T2> void pr(const map<T1,T2>& x) { prContain(x); }
    
    void ps() { pr("\n"); }
    template<class Arg> void ps(const Arg& first) {
        pr(first); ps(); // no space at end of line
    }
    template<class Arg, class... Args> void ps(const Arg& first, const Args&... rest) {
        pr(first," "); ps(rest...); // print w/ spaces
    }
}

using namespace output;

using namespace input;

ll add(ll a, ll b) {
    a += b;
    if(a >= MOD) {
        a -= MOD;
    }
    return a;
}
ll sub(ll a, ll b) {
    a -= b;
    if(a < 0) {
        a += MOD;
    }
    return a;
}

ll mul(ll a, ll b) {
    return (a * b)%MOD;
}

void add_self(ll& a, ll b) {
    a = add(a, b);
}
void sub_self(ll& a, ll b) {
    a = sub(a, b);
}
void mul_self(ll& a, ll b) {
    a = mul(a, b);
}





using namespace std ;

void Bob( int V, int U, int C[], int D[] ){
    
    if(V == 1)
    {
        InitMap(1,0) ;
        return ;
    }
    
    int cnt = 0 ;
    
    vector<int> deg( V, 0 ) ;
    vector<vector<int> > adj(V, vector<int>()) ;
    
    for(int i = 0 ; i < U ; i++ )
    {
        deg[ C[i] ]++ ;
        deg[ D[i] ]++ ;
        
        adj[ C[i] ].push_back(D[i]) ;
        adj[ D[i] ].push_back(C[i]) ;
        
    }
    
    vector<int> idx(V);
    iota(all(idx), 0);
    sort(all(idx) ,[&](int i, int j) { return deg[i] < deg[j]; }) ;
    
    vector<bool> mark(V, false) ;
    mark[ idx[V-1] ] = true ;
    
    for(auto e : adj[ idx[V-1] ])
        mark[e] = true ;
    
    int indicador ;
    for(int i = V-1 ; i >= 0 ; i-- )
        if( !mark[ idx[i] ] )
        {
            indicador = idx[i] ;
            mark[idx[i]] = true ;
            break ;
        }
    
    vector<bool> isBoring(V, false) ;
    vector<int> soma(V, 0) ;
    
    for(auto e : adj[indicador]) isBoring[e] = true , cnt++ ;
    
    //for(int i = 0 ; i < V ; i++ ) cout << idx[i] << " " << deg[idx[i]] << " " << isBoring[idx[i]] << endl ;
    
    int curLast ;
    for(int i = 0 ; i < V ; i++ )
        if(!mark[i]) curLast = i ;
    
    for(int i = 0 ; i < V ; i++ ) mark[i] = false ;
    mark[ idx[V-1] ] = true ;
    
    int curBit = V - cnt - 2 - 1 ;
    while(curLast != -1)
    {
        
        mark[curLast] = true ;
        
        int nxt = -1 ;
        
        for(auto e : adj[curLast])
        {
            if(isBoring[e])
                soma[e] += (1<<curBit) ;
            else if(!mark[e]) nxt = e ;
        }
        
        curBit--;
        curLast = nxt ;
        
    }
    
    vector< pair<int,int> > edge ;
    
    for(int i = 0 ; i < U ; i++ )
    {
        int a = C[i] ;
        int b = D[i] ;
        
        if( !isBoring[a] || !isBoring[b] ) continue ;
        
        edge.push_back( make_pair( soma[a]-1, soma[b]-1 ) ) ;
        
    }
    //cout <<"edges" << endl ;
    //for(auto e : edge ) cout << e.first << " " << e.second << endl ;
    
    InitMap(cnt, sz(edge)) ;
    for(auto e : edge ) MakeMap(e.first, e.second ) ;
    
}

Compilation message

Alice.cpp: In function 'void io::setIn(std::string)':
Alice.cpp:68:35: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
   68 |     void setIn(string s) { freopen(s.c_str(),"r",stdin); }
      |                            ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
Alice.cpp: In function 'void io::setOut(std::string)':
Alice.cpp:69:36: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
   69 |     void setOut(string s) { freopen(s.c_str(),"w",stdout); }
      |                             ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

Bob.cpp: In function 'void io::setIn(std::string)':
Bob.cpp:70:35: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
   70 |     void setIn(string s) { freopen(s.c_str(),"r",stdin); }
      |                            ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
Bob.cpp: In function 'void io::setOut(std::string)':
Bob.cpp:71:36: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
   71 |     void setOut(string s) { freopen(s.c_str(),"w",stdout); }
      |                             ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~
Bob.cpp: In function 'void Bob(int, int, int*, int*)':
Bob.cpp:236:21: warning: 'curLast' may be used uninitialized in this function [-Wmaybe-uninitialized]
  236 |         mark[curLast] = true ;
      |                     ^
Bob.cpp:221:31: warning: 'indicador' may be used uninitialized in this function [-Wmaybe-uninitialized]
  221 |     for(auto e : adj[indicador]) isBoring[e] = true , cnt++ ;
      |                               ^

Subtask #1

22.0 / 22.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	5 ms	4928 KB	Output is correct
2	Correct	5 ms	4832 KB	Output is correct
3	Correct	5 ms	4832 KB	Output is correct
4	Correct	5 ms	4892 KB	Output is correct
5	Correct	7 ms	4928 KB	Output is correct
6	Correct	5 ms	4832 KB	Output is correct
7	Correct	5 ms	4832 KB	Output is correct
8	Correct	5 ms	4832 KB	Output is correct
9	Correct	5 ms	4832 KB	Output is correct
10	Correct	5 ms	4936 KB	Output is correct
11	Correct	5 ms	4832 KB	Output is correct
12	Correct	6 ms	4832 KB	Output is correct
13	Correct	5 ms	4832 KB	Output is correct
14	Correct	5 ms	4984 KB	Output is correct
15	Correct	5 ms	4928 KB	Output is correct
16	Correct	5 ms	4960 KB	Output is correct
17	Correct	5 ms	4832 KB	Output is correct
18	Correct	5 ms	4832 KB	Output is correct
19	Correct	5 ms	4832 KB	Output is correct
20	Correct	5 ms	4832 KB	Output is correct
21	Correct	5 ms	5048 KB	Output is correct
22	Correct	5 ms	4928 KB	Output is correct
23	Correct	5 ms	4932 KB	Output is correct
24	Correct	6 ms	4936 KB	Output is correct
25	Correct	5 ms	5056 KB	Output is correct
26	Correct	5 ms	4832 KB	Output is correct
27	Correct	5 ms	4832 KB	Output is correct
28	Correct	5 ms	4832 KB	Output is correct
29	Correct	8 ms	4928 KB	Output is correct
30	Correct	5 ms	4996 KB	Output is correct
31	Correct	5 ms	4948 KB	Output is correct
32	Correct	5 ms	4832 KB	Output is correct
33	Correct	5 ms	4832 KB	Output is correct
34	Correct	5 ms	4980 KB	Output is correct
35	Correct	6 ms	4832 KB	Output is correct
36	Correct	5 ms	4832 KB	Output is correct
37	Correct	5 ms	4984 KB	Output is correct
38	Correct	5 ms	4832 KB	Output is correct
39	Correct	5 ms	4920 KB	Output is correct
40	Correct	5 ms	4832 KB	Output is correct
41	Correct	5 ms	4832 KB	Output is correct
42	Correct	5 ms	4928 KB	Output is correct
43	Correct	6 ms	4900 KB	Output is correct
44	Correct	5 ms	4832 KB	Output is correct
45	Correct	5 ms	4832 KB	Output is correct
46	Correct	5 ms	4972 KB	Output is correct
47	Correct	5 ms	4832 KB	Output is correct
48	Correct	5 ms	4924 KB	Output is correct
49	Correct	5 ms	4932 KB	Output is correct
50	Correct	5 ms	4832 KB	Output is correct
51	Correct	5 ms	5072 KB	Output is correct
52	Correct	7 ms	4980 KB	Output is correct
53	Correct	5 ms	4832 KB	Output is correct
54	Correct	5 ms	4776 KB	Output is correct
55	Correct	5 ms	4832 KB	Output is correct
56	Correct	5 ms	4832 KB	Output is correct
57	Correct	5 ms	4832 KB	Output is correct
58	Correct	5 ms	4832 KB	Output is correct

Subtask #2

15.0 / 15.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	5 ms	4928 KB	Output is correct
2	Correct	5 ms	4832 KB	Output is correct
3	Correct	5 ms	4832 KB	Output is correct
4	Correct	5 ms	4892 KB	Output is correct
5	Correct	7 ms	4928 KB	Output is correct
6	Correct	5 ms	4832 KB	Output is correct
7	Correct	5 ms	4832 KB	Output is correct
8	Correct	5 ms	4832 KB	Output is correct
9	Correct	5 ms	4832 KB	Output is correct
10	Correct	5 ms	4936 KB	Output is correct
11	Correct	5 ms	4832 KB	Output is correct
12	Correct	6 ms	4832 KB	Output is correct
13	Correct	5 ms	4832 KB	Output is correct
14	Correct	5 ms	4984 KB	Output is correct
15	Correct	5 ms	4928 KB	Output is correct
16	Correct	5 ms	4960 KB	Output is correct
17	Correct	5 ms	4832 KB	Output is correct
18	Correct	5 ms	4832 KB	Output is correct
19	Correct	5 ms	4832 KB	Output is correct
20	Correct	5 ms	4832 KB	Output is correct
21	Correct	5 ms	5048 KB	Output is correct
22	Correct	5 ms	4928 KB	Output is correct
23	Correct	5 ms	4932 KB	Output is correct
24	Correct	6 ms	4936 KB	Output is correct
25	Correct	5 ms	5056 KB	Output is correct
26	Correct	5 ms	4832 KB	Output is correct
27	Correct	5 ms	4832 KB	Output is correct
28	Correct	5 ms	4832 KB	Output is correct
29	Correct	8 ms	4928 KB	Output is correct
30	Correct	5 ms	4996 KB	Output is correct
31	Correct	5 ms	4948 KB	Output is correct
32	Correct	5 ms	4832 KB	Output is correct
33	Correct	5 ms	4832 KB	Output is correct
34	Correct	5 ms	4980 KB	Output is correct
35	Correct	6 ms	4832 KB	Output is correct
36	Correct	5 ms	4832 KB	Output is correct
37	Correct	5 ms	4984 KB	Output is correct
38	Correct	5 ms	4832 KB	Output is correct
39	Correct	5 ms	4920 KB	Output is correct
40	Correct	5 ms	4832 KB	Output is correct
41	Correct	5 ms	4832 KB	Output is correct
42	Correct	5 ms	4928 KB	Output is correct
43	Correct	6 ms	4900 KB	Output is correct
44	Correct	5 ms	4832 KB	Output is correct
45	Correct	5 ms	4832 KB	Output is correct
46	Correct	5 ms	4972 KB	Output is correct
47	Correct	5 ms	4832 KB	Output is correct
48	Correct	5 ms	4924 KB	Output is correct
49	Correct	5 ms	4932 KB	Output is correct
50	Correct	5 ms	4832 KB	Output is correct
51	Correct	5 ms	5072 KB	Output is correct
52	Correct	7 ms	4980 KB	Output is correct
53	Correct	5 ms	4832 KB	Output is correct
54	Correct	5 ms	4776 KB	Output is correct
55	Correct	5 ms	4832 KB	Output is correct
56	Correct	5 ms	4832 KB	Output is correct
57	Correct	5 ms	4832 KB	Output is correct
58	Correct	5 ms	4832 KB	Output is correct
59	Correct	6 ms	4832 KB	Output is correct
60	Correct	6 ms	4832 KB	Output is correct
61	Correct	5 ms	4920 KB	Output is correct
62	Correct	6 ms	4832 KB	Output is correct
63	Correct	7 ms	4832 KB	Output is correct
64	Correct	6 ms	4916 KB	Output is correct
65	Correct	7 ms	4900 KB	Output is correct
66	Correct	6 ms	4832 KB	Output is correct
67	Correct	6 ms	4832 KB	Output is correct
68	Correct	5 ms	4920 KB	Output is correct
69	Correct	6 ms	4928 KB	Output is correct
70	Correct	6 ms	4832 KB	Output is correct
71	Correct	6 ms	4904 KB	Output is correct
72	Correct	7 ms	4832 KB	Output is correct
73	Correct	6 ms	4832 KB	Output is correct
74	Correct	5 ms	4992 KB	Output is correct
75	Correct	5 ms	4832 KB	Output is correct
76	Correct	5 ms	4832 KB	Output is correct
77	Correct	7 ms	4832 KB	Output is correct
78	Correct	7 ms	4832 KB	Output is correct
79	Correct	5 ms	4832 KB	Output is correct
80	Correct	5 ms	4916 KB	Output is correct
81	Correct	5 ms	4832 KB	Output is correct
82	Correct	5 ms	4832 KB	Output is correct
83	Correct	5 ms	4928 KB	Output is correct
84	Correct	5 ms	4832 KB	Output is correct
85	Correct	7 ms	4832 KB	Output is correct
86	Correct	6 ms	5036 KB	Output is correct
87	Correct	5 ms	4832 KB	Output is correct
88	Correct	5 ms	4896 KB	Output is correct
89	Correct	5 ms	5088 KB	Output is correct
90	Correct	5 ms	4832 KB	Output is correct
91	Correct	5 ms	4832 KB	Output is correct
92	Correct	5 ms	4932 KB	Output is correct
93	Correct	6 ms	4932 KB	Output is correct
94	Correct	7 ms	4868 KB	Output is correct
95	Correct	7 ms	4832 KB	Output is correct
96	Correct	6 ms	4908 KB	Output is correct
97	Correct	6 ms	4832 KB	Output is correct
98	Correct	7 ms	4832 KB	Output is correct
99	Correct	5 ms	4832 KB	Output is correct
100	Correct	5 ms	4924 KB	Output is correct
101	Correct	5 ms	4920 KB	Output is correct
102	Correct	5 ms	4832 KB	Output is correct
103	Correct	5 ms	4928 KB	Output is correct
104	Correct	5 ms	4832 KB	Output is correct
105	Correct	6 ms	4832 KB	Output is correct
106	Correct	5 ms	4832 KB	Output is correct
107	Correct	6 ms	4928 KB	Output is correct
108	Correct	6 ms	4832 KB	Output is correct
109	Correct	7 ms	4832 KB	Output is correct
110	Correct	5 ms	4832 KB	Output is correct
111	Correct	5 ms	4924 KB	Output is correct
112	Correct	5 ms	4832 KB	Output is correct
113	Correct	5 ms	4920 KB	Output is correct
114	Correct	5 ms	4920 KB	Output is correct
115	Correct	6 ms	4832 KB	Output is correct
116	Correct	5 ms	4832 KB	Output is correct
117	Correct	6 ms	4832 KB	Output is correct
118	Correct	6 ms	4832 KB	Output is correct

Subtask #3

0 / 63.0

#	Verdict	Execution time	Memory	Grader output
1	Partially correct	720 ms	29380 KB	Output is partially correct : V - N = 13
2	Partially correct	547 ms	26108 KB	Output is partially correct : V - N = 13
3	Partially correct	212 ms	14244 KB	Output is partially correct : V - N = 13
4	Partially correct	14 ms	5392 KB	Output is partially correct : V - N = 13
5	Partially correct	159 ms	10188 KB	Output is partially correct : V - N = 13
6	Partially correct	542 ms	24040 KB	Output is partially correct : V - N = 13
7	Partially correct	744 ms	29472 KB	Output is partially correct : V - N = 13
8	Partially correct	731 ms	27700 KB	Output is partially correct : V - N = 13
9	Partially correct	392 ms	16300 KB	Output is partially correct : V - N = 13
10	Partially correct	54 ms	6492 KB	Output is partially correct : V - N = 13
11	Partially correct	88 ms	7636 KB	Output is partially correct : V - N = 13
12	Partially correct	368 ms	18756 KB	Output is partially correct : V - N = 13
13	Partially correct	628 ms	28436 KB	Output is partially correct : V - N = 13
14	Partially correct	729 ms	29232 KB	Output is partially correct : V - N = 13
15	Partially correct	432 ms	22888 KB	Output is partially correct : V - N = 13
16	Partially correct	127 ms	8656 KB	Output is partially correct : V - N = 13
17	Partially correct	23 ms	5980 KB	Output is partially correct : V - N = 13
18	Partially correct	286 ms	15444 KB	Output is partially correct : V - N = 13
19	Partially correct	643 ms	27140 KB	Output is partially correct : V - N = 13
20	Partially correct	683 ms	29512 KB	Output is partially correct : V - N = 13
21	Partially correct	181 ms	12500 KB	Output is partially correct : V - N = 13
22	Partially correct	215 ms	10672 KB	Output is partially correct : V - N = 13
23	Partially correct	71 ms	7400 KB	Output is partially correct : V - N = 13
24	Partially correct	8 ms	5088 KB	Output is partially correct : V - N = 13
25	Partially correct	49 ms	6364 KB	Output is partially correct : V - N = 13
26	Partially correct	135 ms	10252 KB	Output is partially correct : V - N = 13
27	Partially correct	198 ms	11476 KB	Output is partially correct : V - N = 13
28	Partially correct	209 ms	11284 KB	Output is partially correct : V - N = 13
29	Partially correct	109 ms	8096 KB	Output is partially correct : V - N = 13
30	Partially correct	13 ms	5544 KB	Output is partially correct : V - N = 13
31	Partially correct	12 ms	5376 KB	Output is partially correct : V - N = 13
32	Partially correct	11 ms	5248 KB	Output is partially correct : V - N = 13
33	Partially correct	12 ms	5088 KB	Output is partially correct : V - N = 13
34	Partially correct	12 ms	5216 KB	Output is partially correct : V - N = 13
35	Partially correct	14 ms	5088 KB	Output is partially correct : V - N = 13
36	Incorrect	843 ms	26360 KB	Wrong Answer [10]
37	Halted	0 ms	0 KB	-