Language: C++

#include<iostream>
#include<cmath>
#include<vector>
#include<map>
#include<queue>
#include<cassert>
#include<string>
#include<cstring>
#include<cstdio>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define inf (1<<29)

using namespace std;

struct P
{
  int suit,value;
  P(int suit=inf,int value=inf):suit(suit),value(value){}
  bool operator < (const P& a)const
  { return (suit!=a.suit?suit<a.suit:value<a.value); }
  bool operator == (const P& a)const
  { return suit == a.suit && value == a.value; }
};

typedef vector<P> vP;
typedef vector<vP> vvP;
typedef vector<int> vi;
typedef vector<vi> vvi;
map<vvP,int> mincost;
/*
void print(vector<vP> &vvp)
{
  cout << "print-----" << endl;
  rep(i,vvp.size())
    {
      rep(j,vvp[i].size())
	{
	  if(vvp[i][j] == P(inf,inf))
	    cout << "(x,x) "; 
	  else 
	  cout << "(" << vvp[i][j].suit << "," << vvp[i][j].value << ") ";
	}
      cout << endl;
    }
  cout << endl;
}
*/
bool check(vvP &v)
{
  rep(y,4)
    {
      rep(x,8)
	{
	  if(x == 7)
	    {
	      if(!(v[y][x] == P(inf,inf))) return false;
	      continue;
	    }
	  if(!(v[y][x].suit == y+1 && v[y][x].value == x+1)) return false;
	}
    }
  return true;
}


struct Pox
{
  vvP state;
  int cost;
  vi gap;
  Pox(vvP state=vvP(),int cost=inf):state(state),cost(cost){ gap.clear(); }
  bool operator < (const Pox& a)const
  { return cost > a.cost; }
};


void bfs(vvP &vec)
{
  priority_queue<Pox> Q;
  Pox poxas7 = Pox(vec,0);

  rep(y,4)rep(x,8)if(vec[y][x] == P(inf,inf))poxas7.gap.push_back(x+y*8);

  Q.push(poxas7);
  mincost.clear();
  mincost[vec] = 0;

  while(!Q.empty())
    {
      Pox pox = Q.top(); Q.pop();

      if(check(pox.state))
	{
	  cout << pox.cost << endl;
	  return;
	}


      int pos[5][8];
      rep(y,4)rep(x,8)if(pox.state[y][x] == P(inf,inf)){}
      else pos[pox.state[y][x].suit][pox.state[y][x].value] = x + y * 8;

      rep(i,4)
	{
	  vi gaps = pox.gap;
	  int x = pox.gap[i] % 8;
	  int y = pox.gap[i] / 8;
	  P p = pox.state[y][x-1];

	  p.value++;
	  if(p.value >= 8)continue;
	  assert(x-1 >= 0);
	  int nx = pos[p.suit][p.value] % 8;
	  int ny = pos[p.suit][p.value] / 8;

	  vvP np = pox.state;
	  //swap(np[y][x],np[ny][nx]);
	  P store = np[y][x];
	  np[y][x] = np[ny][nx];
	  np[ny][nx] = store;

	  Pox npox = Pox(np,pox.cost+1);

	  gaps[i] = nx + ny  * 8;
	  npox.gap = gaps;
	  
	  if(mincost.find(np) == mincost.end())
	    {
	      mincost[np] = pox.cost + 1;
	      Q.push(npox);
	    }		  
	  else if(mincost[np] > pox.cost + 1)
	    {
	      mincost[np] = pox.cost + 1;
	      Q.push(npox);
	    }
	}
    }
  cout << -1 << endl;
}

void compute(vvP &vec)
{
  bfs(vec);
}

int main()
{
  int T;
  while(cin >> T)
    {
      while(T--)
	{
	  mincost.clear();
	  vvP vec(4,8);
	  int ps[5][2];
	  rep(i,4)
	    {
	      rep(j,7)
		{
		  int num;
		  scanf("%d",&num);
		  vec[i][j+1].suit = floor(num/10.0);
		  vec[i][j+1].value = num%10;
		  if(vec[i][j+1].value == 1)
		    {
		      ps[vec[i][j+1].suit][0] = j+1;
		      ps[vec[i][j+1].suit][1] = i;
		    }
		}
	    }
	  
	  REP(i,1,5)
	    {
	      int x = ps[i][0], y = ps[i][1];
	      //swap(vec[i-1][0],vec[y][x]);
	      P p = vec[i-1][0];
	      vec[i-1][0] = vec[y][x];
	      vec[y][x] = p;
	    }      
	  
	  compute(vec);
	}
    }
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:157:22: error: no matching function for call to 'std::vector<std::vector<P> >::vector(int, int)'
  157 |           vvP vec(4,8);
      |                      ^
In file included from /usr/include/c++/14/vector:66,
                 from a.cc:3:
/usr/include/c++/14/bits/stl_vector.h:707:9: note: candidate: 'template<class _InputIterator, class> std::vector<_Tp, _Alloc>::vector(_InputIterator, _InputIterator, const allocator_type&) [with <template-parameter-2-2> = _InputIterator; _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >]'
  707 |         vector(_InputIterator __first, _InputIterator __last,
      |         ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:707:9: note:   template argument deduction/substitution failed:
In file included from /usr/include/c++/14/bits/stl_iterator_base_funcs.h:66,
                 from /usr/include/c++/14/string:47,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_iterator_base_types.h: In substitution of 'template<class _InIter> using std::_RequireInputIter = std::__enable_if_t<((bool)std::is_convertible<typename std::iterator_traits< <template-parameter-1-1> >::iterator_category, std::input_iterator_tag>::value)> [with _InIter = int]':
/usr/include/c++/14/bits/stl_vector.h:705:9:   required from here
  705 |                typename = std::_RequireInputIter<_InputIterator>>
      |                ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator_base_types.h:252:57: error: no type named 'iterator_category' in 'struct std::iterator_traits<int>'
  252 |                                    input_iterator_tag>::value>;
      |                                                         ^~~~~
/usr/include/c++/14/bits/stl_vector.h:678:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::initializer_list<_Tp>, const allocator_type&) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >; allocator_type = std::allocator<std::vector<P> >]'
  678 |       vector(initializer_list<value_type> __l,
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:678:43: note:   no known conversion for argument 1 from 'int' to 'std::initializer_list<std::vector<P> >'
  678 |       vector(initializer_list<value_type> __l,
      |              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_vector.h:659:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>&&, std::__type_identity_t<_Alloc>&) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >; std::__type_identity_t<_Alloc> = std::allocator<std::vector<P> >]'
  659 |       vector(vector&& __rv, const __type_identity_t<allocator_type>& __m)
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:659:23: note:   no known conversion for argument 1 from 'int' to 'std::vector<std::vector<P> >&&'
  659 |       vector(vector&& __rv, const __type_identity_t<allocator_type>& __m)
      |              ~~~~~~~~~^~~~
/usr/include/c++/14/bits/stl_vector.h:640:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>&&, const allocator_type&, std::false_type) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >; allocator_type = std::allocator<std::vector<P> >; std::false_type = std::false_type]'
  640 |       vector(vector&& __rv, const allocator_type& __m, false_type)
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:640:7: note:   candidate expects 3 arguments, 2 provided
/usr/include/c++/14/bits/stl_vector.h:635:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>&&, const allocator_type&, std::true_type) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >; allocator_type = std::allocator<std::vector<P> >; std::true_type = std::true_type]'
  635 |       vector(vector&& __rv, const allocator_type& __m, true_type) noexcept
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:635:7: note:   candidate expects 3 arguments, 2 provided
/usr/include/c++/14/bits/stl_vector.h:624:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(const std::vector<_Tp, _Alloc>&, std::__type_identity_t<_Alloc>&) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >; std::__type_identity_t<_Alloc> = std::allocator<std::vector<P> >]'
  624 |       vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:624:28: note:   no known conversion for argument 1 from 'int' to 'const std::vector<std::vector<P> >&'
  624 |       vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
      |              ~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_vector.h:620:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>&&) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >]'
  620 |       vector(vector&&) noexcept = default;
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:620:7: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_vector.h:601:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(const std::vector<_Tp, _Alloc>&) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >]'
  601 |       vector(const vector& __x)
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:601:7: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_vector.h:569:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(size_type, const value_type&, const allocator_type&) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >; size_type = long unsigned int; value_type = std::vector<P>; allocator_type = std::allocator<std::vector<P> >]'
  569 |       vector(size_type __n, const value_type& __value,
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:569:47: note:   no known conversion for argument 2 from 'int' to 'const std::vector<std::vector<P> >::value_type&' {aka 'const std::vector<P>&'}
  569 |       vector(size_type __n, const value_type& __value,
      |                             ~~~~~~~~~~~~~~~~~~^~~~~~~
/usr/include/c++/14/bits/stl_vector.h:556:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(size_type, const allocator_type&) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >; size_type = long unsigned int; allocator_type = std::allocator<std::vector<P> >]'
  556 |       vector(size_type __n, const allocator_type& __a = allocator_type())
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:556:51: note:   no known conversion for argument 2 from 'int' to 'const std::vector<std::vector<P> >::allocator_type&' {aka 'const std::allocator<std::vector<P> >&'}
  556 |       vector(size_type __n, const allocator_type& __a = allocator_type())
      |                             ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:542:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(const allocator_type&) [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >; allocator_type = std::allocator<std::vector<P> >]'
  542 |       vector(const allocator_type& __a) _GLIBCXX_NOEXCEPT
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:542:7: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_vector.h:531:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector() [with _Tp = std::vector<P>; _Alloc = std::allocator<std::vector<P> >]'
  531 |       vector() = default;
      |       ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:531:7: note:   candidate expects 0 arguments, 2 provided