Набор максимально гармоничного состава для ансамбля

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
    int N1, N2, N3, N4, candidate_weight;
    cin >> N1;
    vector <int> v1(N1);
    for (int i = 0; i < N1; ++i) {
        cin >> candidate_weight;
        v1[i] = candidate_weight;
    }
    sort(v1.begin(), v1.end());
    cin >> N2;
    vector <int> v2(N2);
    for (int i = 0; i < N2; ++i) {
        cin >> candidate_weight;
        v2[i] = candidate_weight;
    }
    sort(v2.begin(), v2.end());
    cin >> N3;
    vector <int> v3(N3);
    for (int i = 0; i < N3; ++i) {
        cin >> candidate_weight;
        v3[i] = candidate_weight;
    }
    sort(v3.begin(), v3.end());
    cin >> N4;
    vector <int> v4(N4);
    for (int i = 0; i < N4; ++i) {
        cin >> candidate_weight;
        v4[i] = candidate_weight;
    }
    sort(v4.begin(), v4.end());
    for (int i = v1.size()-1, j = 0, k = 0, z = 0; ;) {
            if (v1[i] <= v2[k] && v2[k] <= v3[z] && v3[z] <= v4[j]) {
                cout << v1[i] << " " << v2[k] << " " << v3[z] << " " << v4[j] << endl;
                return 0;
            } else {
                if (v1[i] > v2[k] && k < v2.size() - 1 ) {
                    ++k;
                }
                if (v1[i] > v2[k] && k == v2.size() - 1) {
                    --i;
                    k = 0;
                }
                if (v1[i] <= v2[k] && v2[k] > v3[z] && z < v3.size() - 1) {
                    ++z;
                }
                if (v1[i] <= v2[k] && v2[k] > v3[z] && z == v3.size() - 1) {
                    --i;
                    k = 0;
                    z = 0;
                }
                if (v1[i] <= v2[k] && v2[k] <= v3[z] && v3[z] > v4[j] && j < v4.size() - 1) {
                    ++j;
                }
                if (v1[i] <= v2[k] && v2[k] <= v3[z] && v3[z] > v4[j] && j == v4.size() - 1) {
                    --i;
                    k = 0;
                    z = 0;
                    j = 0;
                }
            }
    }
}

//Ансамбль песни и пляски «Четверочка» проводит очередной кастинг, в котором традиционно
//участвуют представители четырех городов. В итоговый состав должно войти 4 человека —
//по одному из каждого города. Организаторы кастинга всегда стараются набрать как можно
//более гармоничную группу. В их представлении группа тем более гармонична, чем меньше
//разница в весе участников (т.е. разница между самым тяжелым и самым легким участником
//                           группы).
//В кастинге участвует N1 человек из 1-ого города, N2 из 2-ого, N3 из 3-его и N4 из 4-ого .
//Про каждого кандидата известен его вес (целое число от 1 до 100 000).
//Помогите ансамблю набрать максимально гармоничный состав, то есть состав с минимальной
//разницей весов.
//Формат ввода
 
//Для каждого города i (i = 1, 2, 3, 4) сначала вводится число Ni кандидатов из этого города,
//далее в следующей строке — последовательность из Ni целых чисел, описывающих веса
//кандидатов. Информация обо всех четырех городах подается на вход последовательно,
//начиная с 1-ого и заканчивая 4-ым. Все вводимые числа целые, положительные и
//не превосходят 100 000.
//Формат вывода
 
//Выведите четыре целых числа — веса кандидатов из соответствующих городов, которых
//следует выбрать, чтобы получить наиболее гармоничный состав. Если ответов несколько,
//выведите любой.
 
//Пример 1
 
//Ввод
//3
//1 2 3
//2
//1 3
//2
//3 4
//2
//2 3
//Вывод
//3 3 3 3
 
 
//Пример 2
//Ввод
//1
//5
 
//4
//3 6 7 10
 
//4
//18 3 9 11
 
//1
//20
//Вывод
//5 6 9 20
 
//set() запрещен
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
const   int     CITIES_TOTAL    =   4;
const   int     WEIGHT_MAX      =   100000;
///////////////////////////////////////////////////////////////////////////////
typedef std::pair       < int,  int             >   T_w_c_pair;
typedef std::vector     < T_w_c_pair            >   T_w_c_pairs;
typedef std::array      < int,  CITIES_TOTAL    >   T_group;
///////////////////////////////////////////////////////////////////////////////
void    print_harmonious_group( T_w_c_pairs     const   &   w_c_pairs )
{
    T_group     group_min{0};
    int         diff_min    =   WEIGHT_MAX;
    T_group     group{0};
 
 
    for( auto   &   w_c     :   w_c_pairs )
    {
        group[ w_c.second ]     =   w_c.first;
 
        if  (
                    std::find
                        (
                            group.begin     (),
                            group.end       (),
                            0
                        )
 
                ==  group.end()
            )
        {
            int     diff    =       *std::max_element
                                        (
                                            group.begin     (),
                                            group.end       ()
                                        )
 
                                -   *std::min_element
                                        (
                                            group.begin     (),
                                            group.end       ()
                                        );
 
            if  (
                        diff
                    <   diff_min
                )
            {
                diff_min    =   diff;
                group_min   =   group;
            }
        }
    }//for
 
    std::sort
        (
                group_min.begin                 (),
                group_min.end                   ()
        );
 
    std::copy
        (
            group_min.begin                 (),
            group_min.end                   (),
            std::ostream_iterator< int >    ( std::cout,    "\t" )
        );
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_w_c_pairs     w_c_pairs;
 
    for( int  i{}; i < CITIES_TOTAL; ++i )
    {
        int     n{};
        std::cin    >>  n;
 
        for( int  j{}; j < n; ++j )
        {
            int     w{};
            std::cin    >>  w;
            w_c_pairs.push_back( {w, i} );
        }//for
    }//for
 
    std::sort
        (
            w_c_pairs.begin     (),
            w_c_pairs.end       ()
        );
 
    print_harmonious_group( w_c_pairs );
}