oj.uz

답안 #346710

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
346710 2021-01-10T19:14:46 Z ant101 항공 노선도 (JOI18_airline) C++14
37 / 100
 843 ms 29512 KB 
#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 );
    
}

#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

# 결과 실행 시간 메모리 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

# 결과 실행 시간 메모리 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

# 결과 실행 시간 메모리 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 -