Оптимизация кода, не проходит по времени

#include <iostream>
#include <vector>
#include <string>
#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
 
    int t, n, greh;
    int p;
    cin >> t;
    vector<int> a, b,pose;
    for (int i = 0; i < t; ++i)
    {
        cin >> n >> greh;
        for (int g = 0; g < n; g++)
        {
            cin >> p;
            a.push_back(p);
        }
        for (int j = 0; j < n; j++)
        {
            cin >> p;
            b.push_back(p);
        }
        pose = a;
        sort(a.begin(),a.end());
        sort(b.begin(),b.end());
        while ((int)pose.size()>0)
        {
            for(int u = 0; u<(int)a.size();++u)
            {
                if (a[u] == pose[0])
                {
                    cout<<b[u]<<" ";
                    a.erase(a.begin()+u);
                    b.erase(b.begin()+u);
                    pose.erase(pose.begin());
                    break;
                }
            }
        }
cout<<"\n";
 
 
}
}

#include <vector>
#include <algorithm>
#include <iostream>
#include <iterator>
 
template <typename IT> class ItDeref
{
public:
  using iterator_category = typename std::iterator_traits<IT>::iterator_category;
  using difference_type = typename std::iterator_traits<IT>::difference_type;
  using value_type = std::remove_reference_t<decltype(**std::declval<IT>())>;
  using pointer = value_type *;
  using reference = value_type &;
 
  ItDeref() {}
  ItDeref(const IT &it) : it(it) {}
 
  reference operator *() const 
    { return **it; }                                                     
  pointer operator ->() const 
    { return *it; }
    
  ItDeref &operator ++()
    { ++it; return *this; }
 
  ItDeref operator ++(int)
    { ItDeref old = *this; ++it; return old; }
 
  ItDeref &operator --()
    { --it; return *this; }
 
  ItDeref operator --(int)
    { ItDeref old = *this; --it; return old; }
 
  ItDeref &operator +=(difference_type rhs)
    { it += rhs; return *this; }
 
  ItDeref &operator -=(difference_type rhs)
    { it -= rhs; return *this; }
 
  friend difference_type operator -(const ItDeref &lhs, const ItDeref &rhs)
    { return lhs.it - rhs.it; }
  friend ItDeref operator +(const ItDeref &lhs, difference_type rhs)
    { return ItDeref(lhs) += rhs;  }
  friend ItDeref operator -(const ItDeref &lhs, difference_type rhs)
    { return ItDeref(lhs) -= rhs;  }
 
  friend auto operator <=>(const ItDeref &, const ItDeref &) = default;
  friend bool operator ==(const ItDeref &, const ItDeref &) = default;
 
protected:
  IT it;
};
 
int main()
{
  unsigned t = 0;
  std::cin >> t;
  for (; t > 0; --t)
  {
    // Читаем входные данные
    unsigned n = 0, k = 0;
    std::cin >> n >> k;
    
    // Читаем входные данные - пока только массив `a`
    std::vector<int> a(n);
    std::copy_n(std::istream_iterator<int>(std::cin), n, a.begin());
    
    // Строим индекcный массив для массива `a` из указателей
    std::vector<int *> ptrs;
    ptrs.reserve(n);
    for (int &ra : a)
      ptrs.push_back(&ra);
      
    // Сортируем индекcный массив по значениям из `a`
    std::sort(ptrs.begin(), ptrs.end(), [&](const int *lhs, const int *rhs) { return *lhs < *rhs; });
    
    // Читаем данные массива `b` в массив `a`
    std::copy_n(std::istream_iterator<int>(std::cin), n, a.begin());
    
    // Сортируем массив `a`, смотря на него сквозь массив `ptrs`    
    std::sort(ItDeref(ptrs.begin()), ItDeref(ptrs.end()));
    
    // Выводим `a` в полученном порядке
    for (int v : a)
      std::cout << v << " ";
    std::cout << std::endl;  
  }
}

#include <iostream>
#include <vector>
#include <algorithm>
 
struct s_item
{
    int prognosis{};
    int reality{};
    size_t pos{};
};
 
int main()
{
    int tasks; std::cin >> tasks;
    
    std::vector<s_item> list;
    std::vector<int> reality;
    for (int task=0; task!= tasks; task++)
    {
        int days,diff; std::cin>>days>>diff;
        
        list.resize(days);
        reality.resize(days);
 
        size_t pos=0;
        for(auto& item:list){std::cin>>item.prognosis; item.pos=pos++;}
        
        for(auto& к:reality){std::cin>>к;}
        
        std::sort(list.begin(), list.end(), [](const auto& l, const auto& r)noexcept
        {return l.prognosis<r.prognosis;});
 
        std::sort(reality.begin(), reality.end());
 
        auto it_r=reality.begin();
        for(auto& item:list){item.reality=*it_r; it_r++;};
        
        std::sort(list.begin(), list.end(), [](const auto& l, const auto& r)noexcept
        {return l.pos<r.pos;});
        
        for(const auto& item:list){std::cout<<item.reality<<' ';}
        
        std::cout<<'\n';
    }
}