Detalii evaluare: ~41821546

Detalii evaluare #41821546

Rezumat problema
Detalii
Evaluare
Ajutor

Rezumat problemă

`#2127` ninjago

După ce eroii ninja l-au învins pe Nadakhan, de ziua celor dispăruți Zane trebuia să păzească cele n păpuși din muzeu. Între aceste păpuși există m coridoare pe care se poate circula în ambele sensuri. Se garantează faptul că pe cele m coridoare Zane poate ajunge la fiecare dintre cele n păpuși. Skulkiu, având la dispoziție 5 tipuri de obstacole A, B, C, D, E, încearcă să-l oprească pe Zane punând pe fiecare coridor câte 4 obstacole. Zane poate distruge obstacolele de tip A, B, C și D, dar nu poate să distrugă obstacolele de tipul E. Pentru a distruge un obstacol de tipul A arma lui Zane are nevoie de 1 unitate de energie, pentru a distruge un obstacol de tipul B de 2 unități de energie, pentru a distruge un obstacol de tipul C de 3 unități de energie, iar pentru a distruge un obstacol de tipul D de 4 unități de energie. Datorită dispozitivului cu care Skulkiu amplasează obstacolele pe coridor, cele patru obstacole de pe acelaşi coridor au o adâncime din ce în ce mai mare, ceea ce implică faptul că pentru a distruge al doilea obstacol amplasat pe coridor este nevoie de 5 ori mai multă energie decât cea obișnuită, pentru a distruge cel de-al treilea obstacol amplasat pe coridor este nevoie de 25 ori mai multă energie decât cea obișnuită, iar pentru a distruge al patrulea obstacol amplasat pe acelaşi coridor este nevoie de 125 de ori mai multă energie decât cea obișnuită. Indiferent de sensul de parcurgere al coridorului de către Zane pentru a înlătura obstacolele, energia consumată este aceeaşi, aceasta depinzând doar de ordinea în care au fost amplasate obstacolele de către Skulkiu. Zane nu va înlătura obstacolele de pe toate coridoarele ci doar strictul necesar pentru a avea acces la fiecare păpușă. Zane dorește să-i lase pe ceilalți ninja să se antreneze așa că face în așa fel încât ajutorul pentru distrugerea obstacolelor de tip E să fie minim și apoi ca el să utilizeze un număr minim de unități de energie. Pentru coridoarele pe care se află obstacole de tip E Zane consumă energie doar pentru obstacolele de tip A, B, C şi D. Inițial Zane se află lângă păpușa 1.

Cerințe:

Precizați la câte dintre cele n păpuși poate ajunge Zane înainte de a cere ajutorul celorlalți ninja.
Precizați pentru eliberarea câtor coridoare trebuie să ceară ajutor extern pentru a reuși să ajungă la toate cele n păpuși și câte obstacole de tip E sunt în total pe aceste coridoare.
Precizați care este numărul minim de unități de energie utilizate.

OJI 2017, Clasele XI-XII

Fișiere
Candale Silviu (silviu)
Muresan Codruta
concurs

Rezolvă

Detalii

Problema	ninjago	Operații I/O	`ninjago.in`/`ninjago.out`
Limita timp	1 secunde	Limita memorie	Total: `64 MB` / Stivă `32 MB`
Id soluție	`#41821546`	Utilizator	Răgman Andrei (andrei81)
Fișier	ninjago.cpp	Dimensiune	2.66 KB
Data încărcării	05 Februarie 2023, 18:47	Scor / rezultat	Eroare de compilare

Evaluare

Mesaj compilare

ninjago.cpp: In function 'void kruskal(std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > >&)':
ninjago.cpp:49:37: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     for ( int i = 0; i < edges.size() && EdgesInTree < n - 1; i++ )

                                     ^
ninjago.cpp: In function 'int main()':
ninjago.cpp:102:48: error: parameter declared 'auto'
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                ^
ninjago.cpp:102:56: error: parameter declared 'auto'
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                        ^
ninjago.cpp: In lambda function:
ninjago.cpp:102:66: error: request for member 'first' in 'a', which is of non-class type 'int'
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                                  ^
ninjago.cpp:102:83: error: request for member 'first' in 'b', which is of non-class type 'int'
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                                                   ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h: In instantiation of 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]':
/usr/include/c++/4.8/bits/stl_algo.h:2226:70:   required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:5500:55:   required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
ninjago.cpp:102:123:   required from here
/usr/include/c++/4.8/bits/stl_algo.h:2159:29: error: no match for call to '(main()::__lambda4) (std::pair<std::pair<int, int>, std::pair<int, int> >&, std::pair<std::pair<int, int>, std::pair<int, int> >&)'
    if (__comp(*__i, *__first))
                             ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:2159:29: note: int (*)() <conversion>
    if (__comp(*__i, *__first))
                             ^
/usr/include/c++/4.8/bits/stl_algo.h:2159:29: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h: In instantiation of 'void std::__heap_select(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]':
/usr/include/c++/4.8/bits/stl_algo.h:5349:59:   required from 'void std::partial_sort(_RAIter, _RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:2332:68:   required from 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Size = int; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:5499:44:   required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
ninjago.cpp:102:123:   required from here
/usr/include/c++/4.8/bits/stl_algo.h:1948:27: error: no match for call to '(main()::__lambda4) (std::pair<std::pair<int, int>, std::pair<int, int> >&, std::pair<std::pair<int, int>, std::pair<int, int> >&)'
  if (__comp(*__i, *__first))
                           ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:1948:27: note: int (*)() <conversion>
  if (__comp(*__i, *__first))
                           ^
/usr/include/c++/4.8/bits/stl_algo.h:1948:27: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h: In instantiation of 'void std::__move_median_to_first(_Iterator, _Iterator, _Iterator, _Iterator, _Compare) [with _Iterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]':
/usr/include/c++/4.8/bits/stl_algo.h:2295:13:   required from '_RandomAccessIterator std::__unguarded_partition_pivot(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:2337:62:   required from 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Size = int; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:5499:44:   required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
ninjago.cpp:102:123:   required from here
/usr/include/c++/4.8/bits/stl_algo.h:114:28: error: no match for call to '(main()::__lambda4) (std::pair<std::pair<int, int>, std::pair<int, int> >&, std::pair<std::pair<int, int>, std::pair<int, int> >&)'
       if (__comp(*__a, *__b))
                            ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:114:28: note: int (*)() <conversion>
       if (__comp(*__a, *__b))
                            ^
/usr/include/c++/4.8/bits/stl_algo.h:114:28: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:116:25: error: no match for call to '(main()::__lambda4) (std::pair<std::pair<int, int>, std::pair<int, int> >&, std::pair<std::pair<int, int>, std::pair<int, int> >&)'
    if (__comp(*__b, *__c))
                         ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:116:25: note: int (*)() <conversion>
    if (__comp(*__b, *__c))
                         ^
/usr/include/c++/4.8/bits/stl_algo.h:116:25: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:118:30: error: no match for call to '(main()::__lambda4) (std::pair<std::pair<int, int>, std::pair<int, int> >&, std::pair<std::pair<int, int>, std::pair<int, int> >&)'
    else if (__comp(*__a, *__c))
                              ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:118:30: note: int (*)() <conversion>
    else if (__comp(*__a, *__c))
                              ^
/usr/include/c++/4.8/bits/stl_algo.h:118:30: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:123:33: error: no match for call to '(main()::__lambda4) (std::pair<std::pair<int, int>, std::pair<int, int> >&, std::pair<std::pair<int, int>, std::pair<int, int> >&)'
       else if (__comp(*__a, *__c))
                                 ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:123:33: note: int (*)() <conversion>
       else if (__comp(*__a, *__c))
                                 ^
/usr/include/c++/4.8/bits/stl_algo.h:123:33: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:125:33: error: no match for call to '(main()::__lambda4) (std::pair<std::pair<int, int>, std::pair<int, int> >&, std::pair<std::pair<int, int>, std::pair<int, int> >&)'
       else if (__comp(*__b, *__c))
                                 ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:125:33: note: int (*)() <conversion>
       else if (__comp(*__b, *__c))
                                 ^
/usr/include/c++/4.8/bits/stl_algo.h:125:33: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h: In instantiation of '_RandomAccessIterator std::__unguarded_partition(_RandomAccessIterator, _RandomAccessIterator, const _Tp&, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Tp = std::pair<std::pair<int, int>, std::pair<int, int> >; _Compare = main()::__lambda4]':
/usr/include/c++/4.8/bits/stl_algo.h:2296:78:   required from '_RandomAccessIterator std::__unguarded_partition_pivot(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:2337:62:   required from 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Size = int; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:5499:44:   required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
ninjago.cpp:102:123:   required from here
/usr/include/c++/4.8/bits/stl_algo.h:2263:35: error: no match for call to '(main()::__lambda4) (std::pair<std::pair<int, int>, std::pair<int, int> >&, const std::pair<std::pair<int, int>, std::pair<int, int> >&)'
    while (__comp(*__first, __pivot))
                                   ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:2263:35: note: int (*)() <conversion>
    while (__comp(*__first, __pivot))
                                   ^
/usr/include/c++/4.8/bits/stl_algo.h:2263:35: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:2266:34: error: no match for call to '(main()::__lambda4) (const std::pair<std::pair<int, int>, std::pair<int, int> >&, std::pair<std::pair<int, int>, std::pair<int, int> >&)'
    while (__comp(__pivot, *__last))
                                  ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h:2266:34: note: int (*)() <conversion>
    while (__comp(__pivot, *__last))
                                  ^
/usr/include/c++/4.8/bits/stl_algo.h:2266:34: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/bits/stl_algo.h:61:0,
                 from /usr/include/c++/4.8/algorithm:62,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_heap.h: In instantiation of 'void std::__adjust_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Distance = int; _Tp = std::pair<std::pair<int, int>, std::pair<int, int> >; _Compare = main()::__lambda4]':
/usr/include/c++/4.8/bits/stl_heap.h:448:15:   required from 'void std::make_heap(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:1946:47:   required from 'void std::__heap_select(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:5349:59:   required from 'void std::partial_sort(_RAIter, _RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:2332:68:   required from 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Size = int; _Compare = main()::__lambda4]'
/usr/include/c++/4.8/bits/stl_algo.h:5499:44:   required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]'
ninjago.cpp:102:123:   required from here
/usr/include/c++/4.8/bits/stl_heap.h:313:40: error: no match for call to '(main()::__lambda4) (std::pair<std::pair<int, int>, std::pair<int, int> >&, std::pair<std::pair<int, int>, std::pair<int, int> >&)'
        *(__first + (__secondChild - 1))))
                                        ^
ninjago.cpp:102:41: note: candidates are:
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                         ^
In file included from /usr/include/c++/4.8/bits/stl_algo.h:61:0,
                 from /usr/include/c++/4.8/algorithm:62,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_heap.h:313:40: note: int (*)() <conversion>
        *(__first + (__secondChild - 1))))
                                        ^
/usr/include/c++/4.8/bits/stl_heap.h:313:40: note:   candidate expects 1 argument, 3 provided
ninjago.cpp:102:57: note: main()::__lambda4
     sort(EEdges.begin(), EEdges.end(), [](auto a, auto b){if ( a.first.second < b.first.second ) return 1; else return 0;});

                                                         ^
ninjago.cpp:102:57: note:   candidate expects 0 arguments, 2 provided
In file included from /usr/include/c++/4.8/algorithm:62:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_algo.h: At global scope:
/usr/include/c++/4.8/bits/stl_algo.h:2110:5: error: 'void std::__unguarded_linear_insert(_RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]', declared using local type 'main()::__lambda4', is used but never defined [-fpermissive]
     __unguarded_linear_insert(_RandomAccessIterator __last,
     ^
In file included from /usr/include/c++/4.8/bits/stl_algo.h:61:0,
                 from /usr/include/c++/4.8/algorithm:62,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:64,
                 from ninjago.cpp:1:
/usr/include/c++/4.8/bits/stl_heap.h:331:5: error: 'void std::__pop_heap(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Compare = main()::__lambda4]', declared using local type 'main()::__lambda4', is used but never defined [-fpermissive]
     __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     ^
/usr/include/c++/4.8/bits/stl_heap.h:178:5: error: 'void std::__push_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::pair<std::pair<int, int>, std::pair<int, int> >*, std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > >; _Distance = int; _Tp = std::pair<std::pair<int, int>, std::pair<int, int> >; _Compare = main()::__lambda4]', declared using local type 'main()::__lambda4', is used but never defined [-fpermissive]
     __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
     ^

Cum funcționează evaluarea?

www.pbinfo.ro permite evaluarea a două tipuri de probleme:

probleme la care rezolvarea presupune scrierea unui program complet
probleme la care rezolvarea presupune scrierea unei secvențe de program - câteva instrucțiuni, o listă de declarații, una sau mai multe funcții, etc.

Problema ninjago face parte din prima categorie. Soluția propusă de tine va fi evaluată astfel:

Programul sursă este compilat folosind compilatorul corespunzător. Dacă în urma compilării se obțin erori sau avertismente, acestea sunt afișate în această pagină.
Dacă programul a fost compilat, executabilul obținut va fi rulat, furnizându-i-se unul sau mai multe seturi de date de intrare, în concordanță cu restricțiile specifice problemei. Pentru fiecare set de date se obține un anumit punctaj, în raport cu corectitudinea soluției tale.

Suma punctajelor acordate pe testele utilizate pentru verificare este 100. Astfel, soluția ta poate obține cel mult 100 de puncte, caz în care se poate considera corectă.