Rezumat problemă

Joc5

#1109

Costel are o mare pasiune pentru rezolvarea cubului Rubik, atât de mare încât a început să facă cercetări și calcule diverse pornind de la acest joc. Ultima lui idee, inspirată de cubul Rubik, folosește un cub de latură 2 unități, compus din 8 cuburi cu latura de o unitate (cub unitate), având fețele exterioare colorate. Fiecare cub unitate are 3 fețe exterioare şi fiecare dintre acestea este colorată cu una din cele 10 culori disponibile, codificate prin cifrele de la 0 la 9.

Figura 1	Figura 2

Identificarea cuburilor unitate se face conform specificaţiilor din Figura 1. Cubul care nu este vizibil în Figura 1 are coordonatele (1, 1, 2). Cubul lui Costel permite efectuarea următoarelor tipuri de mutări, asemănătoare cu cele din cubul Rubik:

M1: Paralelipipedul 1 conține cuburile unitate de coordonate: (1, 1, 1); (1, 2, 1); (2, 1, 1); (2, 2, 1). Acesta este un disc așezat orizontal și poate fi rotit cu 90 de grade către dreapta, în sensul acelor de ceasornic.
M2: Paralelipipedul 2 conține cuburile unitate de coordonate: (1, 1, 2); (1, 2, 2); (2, 1, 2); (2, 2, 2). Acesta este un disc așezat orizontal și poate fi rotit cu 90 de grade către dreapta, în sens invers acelor de ceasornic.
M3: Paralelipipedul 3 conține cuburile unitate de coordonate: (1, 1, 1); (2, 1, 1); (1, 1, 2); (2, 1, 2). Acesta este un disc așezat vertical și poate fi rotit cu 90 de grade către planul îndepărtat, în sens invers acelor de ceasornic.
M4: Paralelipipedul 4 conține cuburile unitate de coordonate: (1, 2, 1); (2, 2, 1); (1, 2, 2); (2, 2, 2). Acesta este un disc așezat vertical și poate fi rotit cu 90 de grade către planul îndepărtat, în sensul acelor de ceasornic.

Prin configurație se înțelege memorarea culorii fiecărei fețe exterioare a celor 8 cuburi unitate, deci culorile celor 24 de feţe exterioare. Aplicând o succesiune validă de mutări se obține o altă configurație.

Pentru ușurința memorării unei configurații, Costel utilizează desfășurarea în plan a celor 6 fețe ale cubului său după modelul din Figura 2, care ilustrează modul în care sunt dispuse fețele în desfăşurare. Fiecare faţă a cubului conţine patru feţe exterioare ale cuburilor unitate având, în ordine, coordonatele specificate în figură.

Fiind date o configuraţie iniţială şi o configuraţie finală ale jocului, determinați numărul minim de mutări prin care se poate ajunge de la configurația inițială la configurația finală şi succesiunea corespunzătoare de mutări prin care se poate obţine configuraţia finală.

ONI 2014, Clasa a X-a

Fișiere Candale Silviu (silviu) Alin Burta concurs

Clasa 10 Structuri de date liniare Coada

Rezolvă

Detalii

Problema	Joc5	Operații I/O	joc5.in/joc5.out
Limita timp	0.1 secunde	Limita memorie	Total: 64 MB / Stivă 8 MB
Id soluție	#58435962	Utilizator	Alecu Alexandru (Alecu_Alexandru)
Fișier	joc5.cpp	Dimensiune	2.67 KB
Data încărcării	04 Iunie 2025, 11:00	Scor / rezultat	Eroare de compilare

Evaluare

Mesaj compilare

joc5.cpp: In function 'void bfs(cub)':
joc5.cpp:63:25: error: no matching function for call to 'std::unordered_map<std::basic_string<char>, std::basic_string<char> >::insert(std::string&, const char [1])'
     mul.insert(st.sir,"")

                         ^
joc5.cpp:63:25: note: candidates are:
In file included from /usr/include/c++/4.8/unordered_map:48:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:115,
                 from joc5.cpp:2:
/usr/include/c++/4.8/bits/unordered_map.h:362:7: note: std::pair<typename std::_Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc, std::__detail::_Select1st, _Pred, _Hash, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<std::__not_<std::__and_<std::__is_fast_hash<_Hash>, std::is_default_constructible<_Hash>, std::is_copy_assignable<_Hash>, std::__detail::__is_noexcept_hash<_Key, _Hash> > >::value, false, true> >::iterator, bool> std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(const value_type&) [with _Key = std::basic_string<char>; _Tp = std::basic_string<char>; _Hash = std::hash<std::basic_string<char> >; _Pred = std::equal_to<std::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::basic_string<char>, std::basic_string<char> > >; typename std::_Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc, std::__detail::_Select1st, _Pred, _Hash, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<std::__not_<std::__and_<std::__is_fast_hash<_Hash>, std::is_default_constructible<_Hash>, std::is_copy_assignable<_Hash>, std::__detail::__is_noexcept_hash<_Key, _Hash> > >::value, false, true> >::iterator = std::__detail::_Node_iterator<std::pair<const std::basic_string<char>, std::basic_string<char> >, false, true>; std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::value_type = std::pair<const std::basic_string<char>, std::basic_string<char> >]
       insert(const value_type& __x)
       ^
/usr/include/c++/4.8/bits/unordered_map.h:362:7: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/4.8/bits/unordered_map.h:369:2: note: template<class _Pair, class> std::pair<typename std::_Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc, std::__detail::_Select1st, _Pred, _Hash, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<std::__not_<std::__and_<std::__is_fast_hash<_Hash>, std::is_default_constructible<_Hash>, std::is_copy_assignable<_Hash>, std::__detail::__is_noexcept_hash<_Key, _Hash> > >::value, false, true> >::iterator, bool> std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_Pair&&) [with _Pair = _Pair; <template-parameter-2-2> = <template-parameter-1-2>; _Key = std::basic_string<char>; _Tp = std::basic_string<char>; _Hash = std::hash<std::basic_string<char> >; _Pred = std::equal_to<std::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::basic_string<char>, std::basic_string<char> > >]
  insert(_Pair&& __x)
  ^
/usr/include/c++/4.8/bits/unordered_map.h:369:2: note:   template argument deduction/substitution failed:
joc5.cpp:63:25: note:   candidate expects 1 argument, 2 provided
     mul.insert(st.sir,"")

                         ^
In file included from /usr/include/c++/4.8/unordered_map:48:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:115,
                 from joc5.cpp:2:
/usr/include/c++/4.8/bits/unordered_map.h:396:7: note: std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator, const value_type&) [with _Key = std::basic_string<char>; _Tp = std::basic_string<char>; _Hash = std::hash<std::basic_string<char> >; _Pred = std::equal_to<std::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::basic_string<char>, std::basic_string<char> > >; std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator = std::__detail::_Node_iterator<std::pair<const std::basic_string<char>, std::basic_string<char> >, false, true>; std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator = std::__detail::_Node_const_iterator<std::pair<const std::basic_string<char>, std::basic_string<char> >, false, true>; std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::value_type = std::pair<const std::basic_string<char>, std::basic_string<char> >]
       insert(const_iterator __hint, const value_type& __x)
       ^
/usr/include/c++/4.8/bits/unordered_map.h:396:7: note:   no known conversion for argument 1 from 'std::string {aka std::basic_string<char>}' to 'std::unordered_map<std::basic_string<char>, std::basic_string<char> >::const_iterator {aka std::__detail::_Node_const_iterator<std::pair<const std::basic_string<char>, std::basic_string<char> >, false, true>}'
/usr/include/c++/4.8/bits/unordered_map.h:403:2: note: template<class _Pair, class> std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator, _Pair&&) [with _Pair = _Pair; <template-parameter-2-2> = <template-parameter-1-2>; _Key = std::basic_string<char>; _Tp = std::basic_string<char>; _Hash = std::hash<std::basic_string<char> >; _Pred = std::equal_to<std::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::basic_string<char>, std::basic_string<char> > >]
  insert(const_iterator __hint, _Pair&& __x)
  ^
/usr/include/c++/4.8/bits/unordered_map.h:403:2: note:   template argument deduction/substitution failed:
joc5.cpp:63:25: note:   cannot convert 'st.cub::sir' (type 'std::string {aka std::basic_string<char>}') to type 'std::unordered_map<std::basic_string<char>, std::basic_string<char> >::const_iterator {aka std::__detail::_Node_const_iterator<std::pair<const std::basic_string<char>, std::basic_string<char> >, false, true>}'
     mul.insert(st.sir,"")

                         ^
In file included from /usr/include/c++/4.8/unordered_map:48:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:115,
                 from joc5.cpp:2:
/usr/include/c++/4.8/bits/unordered_map.h:418:2: note: template<class _InputIterator> void std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator, _InputIterator) [with _InputIterator = _InputIterator; _Key = std::basic_string<char>; _Tp = std::basic_string<char>; _Hash = std::hash<std::basic_string<char> >; _Pred = std::equal_to<std::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::basic_string<char>, std::basic_string<char> > >]
  insert(_InputIterator __first, _InputIterator __last)
  ^
/usr/include/c++/4.8/bits/unordered_map.h:418:2: note:   template argument deduction/substitution failed:
joc5.cpp:63:25: note:   deduced conflicting types for parameter '_InputIterator' ('std::basic_string<char>' and 'const char*')
     mul.insert(st.sir,"")

                         ^
In file included from /usr/include/c++/4.8/unordered_map:48:0,
                 from /usr/include/i386-linux-gnu/c++/4.8/bits/stdc++.h:115,
                 from joc5.cpp:2:
/usr/include/c++/4.8/bits/unordered_map.h:429:7: note: void std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(std::initializer_list<typename std::_Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc, std::__detail::_Select1st, _Pred, _Hash, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<std::__not_<std::__and_<std::__is_fast_hash<_Hash>, std::is_default_constructible<_Hash>, std::is_copy_assignable<_Hash>, std::__detail::__is_noexcept_hash<_Key, _Hash> > >::value, false, true> >::value_type>) [with _Key = std::basic_string<char>; _Tp = std::basic_string<char>; _Hash = std::hash<std::basic_string<char> >; _Pred = std::equal_to<std::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::basic_string<char>, std::basic_string<char> > >; typename std::_Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc, std::__detail::_Select1st, _Pred, _Hash, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<std::__not_<std::__and_<std::__is_fast_hash<_Hash>, std::is_default_constructible<_Hash>, std::is_copy_assignable<_Hash>, std::__detail::__is_noexcept_hash<_Key, _Hash> > >::value, false, true> >::value_type = std::pair<const std::basic_string<char>, std::basic_string<char> >]
       insert(initializer_list<value_type> __l)
       ^
/usr/include/c++/4.8/bits/unordered_map.h:429:7: note:   candidate expects 1 argument, 2 provided
joc5.cpp:64:5: error: expected ';' before 'q'
     q.push({st,""});

     ^
joc5.cpp:64:19: error: expected primary-expression before ')' token
     q.push({st,""});

                   ^
joc5.cpp:64:19: error: expected ';' before ')' token

Cum funcționează evaluarea?