Ошибка выполнения

#include <iostream> 
#include <algorithm> 
#include <vector> 
#define ll long long 
using namespace std;
int main() { 
    ll w, h; int n, m; ll k; 
    cin >> w >> h >> n >> m >> k;
    vector<ll> len; vector<ll> arr;
    ll last = 0; ll line;
    for (int i = 0; i < n; i++) {
        cin >> line;
        len.push_back(line - last); 
        last = line;
    }
    len.push_back(w - last);
    last = 0; 
    for (int i = 0; i <= m; i++) {
        if (i < m) cin >> line;
        else line = h;
        ll curl = line - last; 
        for (ll j : len) {
            arr.push_back(curl * j);
        }
        last = line;
    }
    sort(arr.rbegin(), arr.rend()); 
    cout << arr[k - 1] << " " << arr[0] << endl;
}

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
 
using namespace std;
 
int main() {
    // Чтение входных данных
    int w, h;
    cin >> w >> h;
    
    int n, m;
    cin >> n >> m;
    
    int k;
    cin >> k;
    
    vector<int> x(n), y(m);
    for (int i = 0; i < n; ++i) {
        cin >> x[i];
    }
    for (int i = 0; i < m; ++i) {
        cin >> y[i];
    }
    
    // Добавление границ королевства
    x.push_back(w);
    y.push_back(h);
    
    // Вычисление размеров графств
    vector<long long> widths(n + 1), heights(m + 1);
    for (int i = 0; i <= n; ++i) {
        if (i == 0) {
            widths[i] = x[i];
        } else {
            widths[i] = x[i] - x[i - 1];
        }
    }
    
    for (int i = 0; i <= m; ++i) {
        if (i == 0) {
            heights[i] = y[i];
        } else {
            heights[i] = y[i] - y[i - 1];
        }
    }
    
    // Использование priority queue для хранения k самых больших площадей
    priority_queue<long long, vector<long long>, greater<long long>> pq;
    
    for (int i = 0; i <= n; ++i) {
        for (int j = 0; j <= m; ++j) {
            long long area = widths[i] * heights[j];
            if (pq.size() < k) {
                pq.push(area);
            } else if (area > pq.top()) {
                pq.pop();
                pq.push(area);
            }
        }
    }
    
    // Получение k самых больших площадей
    vector<long long> largest_areas;
    while (!pq.empty()) {
        largest_areas.push_back(pq.top());
        pq.pop();
    }
    
    // Сортировка вектор largest_areas по возрастанию
    sort(largest_areas.begin(), largest_areas.end());
    
    // Вывод площадей графств для младшего и старшего сыновей
    cout << largest_areas[0] << " " << largest_areas[k - 1] << endl;
    
    return 0;
}

#include <vector>
#include <set>
#include <numeric>
#include <algorithm>
#include <iostream>
 
int main()
{
  unsigned w, h, n, m; 
  unsigned long long k;
  std::cin >> w >> h >> n >> m >> k;
  
  std::vector<unsigned> ws(n + 2);
  for (unsigned i = 1; i <= n; ++i)
    std::cin >> ws[i];
    
  ws.front() = 0;
  ws.back() = w;
  std::sort(ws.begin() + 1, ws.end() - 1);
  std::adjacent_difference(ws.begin(), ws.end(), ws.begin());
 
  std::vector<unsigned> hs(m + 2);
  for (unsigned j = 1; j <= m; ++j)
    std::cin >> hs[j];
    
  hs.front() = 0;
  hs.back() = h;
  std::sort(hs.begin() + 1, hs.end() - 1);
  std::adjacent_difference(hs.begin(), hs.end(), hs.begin());
  
  std::multiset<unsigned long long> as;
  
  for (unsigned i = 1; i <= n + 1; ++i)
    for (unsigned j = 1; j <= m + 1; ++j)
    {
      as.insert((unsigned long long) ws[i] * hs[j]);
      if (as.size() > k)
        as.erase(as.begin());
    }
  
  std::cout << *as.begin() << " " << *std::prev(as.end()) << std::endl;
}

#include <iostream>
#include <cstdint>
#include <map>
#include <vector>
#include <functional>
 
int main() {
    using ull_t = std::uint64_t;
    ull_t w, h, n, m, k;
    std::cin >> w >> h >> n >> m >> k;
    std::map<ull_t, unsigned, std::greater<ull_t>> areas;
    // input grid section
 
    {
        std::vector<ull_t> widths(n+1);
        ull_t m_prev = 0, n_prev = 0;
        for(ull_t i = 0, xn; i != n; ++i){
            std::cin >> xn;
            widths[i] = xn - n_prev;
            n_prev = xn;
        }
        widths[n] = w - n_prev;
 
        for(ull_t j = 0, xm; j != m; ++j){
            std::cin >> xm;
            for(ull_t i = 0; i <= n; ++i){
               ull_t height = xm - m_prev; 
               ++areas[height * widths[i]];
            }
            m_prev = xm;
        }
        for(ull_t i = 0, height = h - m_prev; i <= n; ++i)
           ++areas[height * widths[i]];     
    }
    // end input dection
    
    ull_t max{areas.begin()->first}, min{max};
 
    for(const auto &data : areas) {
        if (k <= data.second){
         min = data.first;
         break;
        }
      k -= data.second;
    }
    std::cout << min << ' ' << max << std::endl;
}

#include <iostream>
#include <map>
#define ll long long
#define quan second
#define val first
using namespace std;
struct Compare {
    bool operator()(const ll& a, const ll& b) const {
        return a > b; 
    }
};
int main() { 
    int w, h, n, m, k; 
    cin >> w >> h >> n >> m >> k;
    map<ll, ll, Compare> sq; 
    int len[n+1];
    int last, line, ind = 0;
    for (int i = 0; i < n; i++) {
        cin >> line;
        len[ind++] = line - last; 
        last = line;
    }
    len[n] = w - last;
    last = 0;
    ll curl;
    for (int i = 0; i <= m; i++) {
        if (i < m) cin >> line;
        else line = h;
        curl = line - last; 
        for (ll j : len) {
            sq[curl * j]++;
        }
        last = line;
    }
    ll cnt = 0, older = -1, junior = -1;
    for (auto i: sq) {
        if (older == -1) {
            older = i.val;
        }
        if (cnt < k && k <= cnt + i.quan) {
            junior = i.val; 
            break;
        }
        cnt += i.quan; 
    }
    cout << junior << " " << older << endl;
}

#include <iostream>     
   
int main() {
    int w, h, n, m, k;
 
    std::cin >> w >> h; // ширина и высота 3х3
    std::cin >> n >> m; // вертикальных и горизонтальных делений 2 и 2
    std::cin >> k; // сыновья
    int *x = new int[n + 2];
    int *y = new int[w + 2];
    x[0] = 0; y[0] = 0;
    x[n + 1] = w; y[m + 1] = h;
    for (int i = 1; i <= n; i++) 
        std::cin >> x[i]; // координата х[1]=1 и x[2]=2
    for (int i = 1; i <= m; i++)
        std::cin >> y[i]; // координата у[1]=1 и y[2]=2
    int *arr = new int[(n + 1)*(m + 1)]; // площадь i-того графства (в примере будет 9 площадей)
 
    for (int i = 1; i <= n + 1; i++)
        for (int j = 1; j <= m + 1; j++)
            
            std::cout <<(arr[i]= (x[i] - x[i - 1])*(y[j] - y[j - 1])) << "  ";
}

#include <iostream> 
#include <algorithm> 
#include <vector> 
#define ll long long 
using namespace std;
int main() { 
    ll w, h; int n, m; ll k; 
    cin >> w >> h >> n >> m >> k;
    vector<ll> len; vector<ll> arr;
    ll last = 0; ll line;
    for (int i = 0; i < n; i++) {
        cin >> line;
        len.push_back(line - last); 
        last = line;
    }
    len.push_back(w - last);
    last = 0; 
    for (int i = 0; i <= m; i++) {
        if (i < m) cin >> line;
        else line = h;
        ll curl = line - last; 
        for (ll j : len) {
            arr.push_back(curl * j);
        }
        last = line;
    }
    sort(arr.rbegin(), arr.rend()); 
    cout << arr[k - 1] << " " << arr[0] << endl;
}

#include <cassert>
#include <vector>
#include <map>
#include <numeric>
#include <algorithm>
#include <iostream>
 
using TSizes = std::vector<unsigned>;
using TAreas = std::map<unsigned long long, unsigned>; 
 
TSizes read_sizes(unsigned n, unsigned max)
{
  TSizes szs(1 + n + 1);
  
  for (unsigned i = 1; i <= n; ++i)
  {
    std::cin >> szs[i];
    assert(szs[i - 1] < szs[i]);
  }
  
  assert(szs[n] < max);
  szs[n + 1] = max;
 
  std::adjacent_difference(szs.begin(), szs.end(), szs.begin());
  assert(szs.front() == 0);
  szs.erase(szs.begin());
  
  std::sort(szs.begin(), szs.end());
  return szs;
}
 
void add_areas(TAreas &as, unsigned h, const TSizes &ws)
{
  for (unsigned w : ws)
    ++as[(unsigned long long) w * h];
}
 
void remove_areas(TAreas &as, unsigned long long &k, unsigned long long min_a)
{
  while (k > 0 && !as.empty() && as.begin()->first < min_a)
  {
    assert(as.begin()->second > 0);
    if (as.begin()->second > k)
      k = 0;
    else
    {
      k -= as.begin()->second;
      as.erase(as.begin());
    }
  }
}
 
int main()
{
  unsigned w = 0, h = 0, n = 0, m = 0; 
  std::cin >> w >> h >> n >> m;
  assert(w > 0 && h > 0);
 
  unsigned long long k = 0;
  std::cin >> k;
  assert(k >= 1);
 
  TSizes ws = read_sizes(n, w), hs = read_sizes(m, h);
 
  ++n; ++m;
  assert(ws.size() == n && hs.size() == m);
 
  assert(k <= (unsigned long long) n * m);
  k = (unsigned long long) n * m - k; 
  // Теперь это индекс от 0 
  
  TAreas as;
  add_areas(as, hs[0], ws);
  // Начальный набор площадей
 
  for (unsigned j = 1; j < m && k > 0; ++j)
  {
    unsigned long long min_a = (unsigned long long) ws[0] * hs[j];
    // Новый гарантированный минимум
 
    // Выбрасываем площади ниже минимума
    remove_areas(as, k, min_a);
 
    // Добавляем новые площади
    add_areas(as, hs[j], ws);
  }
 
  remove_areas(as, k, -1ull);
  
  assert(!as.empty());
  std::cout << as.begin()->first << " " << (unsigned long long) ws.back() * hs.back() << std::endl;
}

#include <cassert>
#include <map>
#include <iostream>
 
using TSizes = std::map<unsigned, unsigned>;
using TAreas = std::map<unsigned long long, unsigned long long>;
 
TSizes read_sizes(unsigned n, unsigned max)
{
  TSizes szs;
 
  unsigned prev_line = 0, line = 0;
  for (unsigned i = 0; i < n; ++i, prev_line = line)
  {
    std::cin >> line;
    assert(prev_line < line);
    ++szs[line - prev_line];
  }
 
  assert(prev_line < max);
  ++szs[max - prev_line];
 
  return szs;
}
 
void add_areas(TAreas& as, const TSizes::value_type &h, const TSizes& ws)
{
  for (auto &w : ws)
    as[(unsigned long long) w.first * h.first] += 
      (unsigned long long) w.second * h.second;
}
 
void remove_areas(TAreas& as, unsigned long long& k, unsigned long long min_a)
{
  while (k > 0 && !as.empty() && as.begin()->first < min_a)
  {
    assert(as.begin()->second > 0);
    if (as.begin()->second > k)
      k = 0;
    else
    {
      k -= as.begin()->second;
      as.erase(as.begin());
    }
  }
}
 
int main()
{
  unsigned w = 0, h = 0, n = 0, m = 0;
  std::cin >> w >> h >> n >> m;
  assert(w > 0 && h > 0);
 
  unsigned long long k = 0;
  std::cin >> k;
  assert(k >= 1);
 
  TSizes ws = read_sizes(n, w), hs = read_sizes(m, h);
 
  assert(k <= (unsigned long long) (n + 1) * (m + 1));
  k = (unsigned long long) (n + 1) * (m + 1) - k;
  // Теперь это индекс от 0 
 
  TAreas as;
 
  auto it_h = hs.cbegin();
  add_areas(as, *it_h, ws);
  // Начальный набор площадей
 
  for (++it_h; it_h != hs.cend(); ++it_h)
  {
    if (k == 0)
      break;
 
    unsigned long long min_a = (unsigned long long) ws.begin()->first * it_h->first;
    // Новый гарантированный минимум
 
    // Выбрасываем площади ниже минимума
    remove_areas(as, k, min_a);
 
    // Добавляем новые площади
    add_areas(as, *it_h, ws);
  }
 
  remove_areas(as, k, -1ull);
 
  assert(!as.empty());
  std::cout << 
    as.begin()->first << " " << 
    (unsigned long long) std::prev(ws.cend())->first * std::prev(hs.cend())->first << 
    std::endl;
}

using TAreas = std::map<unsigned long long, unsigned long long>;