Jak wybrać wszystkie możliwe pary z 2 wektorów z powtórzeniami

Witam,
Posiadając dwa identycznej wielkości zestawy pól, w jaki sposób wybrać wszystkie możliwe kombinacje par:
Np:
mając dane pola x1,x2,x3 oraz y1,y2,y3
otrzymać wyniki:

zbiór pierwszy:
x1-y1
x2-y2
x3-y3

zbiór drugi:
x1-y2
x2-y3
x3-y1

zbiór trzeci:
x1-y3
x2-y1
x3-y2

zbiór czwarty
x1-y1
x2-y3
x3-y2

itd.
przy założeniu że liczba par jest zmienna.

Wygenerowałem sobie wszystkie możliwe pary do wektora ale nie wiem co dalej...

@Sevet Ajak: wszystkich możliwych Twoich zbiorów będzie tyle ile permutacji, n!.

Tak samo jak to rozpisałeś -> nie ruszasz X, a z Y bierzesz wszystkie możliwe permutacje i potem sklejasz sobie wyniki. Potrzebujesz wygenerować wszystkie permutacje zbioru Y.

@Shalom to mi się udało zrobić już wcześniej( przynajmniej tak mi się wydaje) - w metodzie generujPary.
Kod ogólnie ma ogarniać problem najmniejszej ilości ruchów dla skoczków szachowych z pól a[] na pola b[] (tylko wypisać najmniejszą ilość ruchów) przy czym najpierw będę miał podane N pozycji startowych a później N pozycji końcowych przy czym żadne pole nie jest sztywno przypisane do drugiego tylko ma zostać wybrana najlepsza kombinacja. Napisałem już kod dla 1 skoczka, algorytm tworzący wszystkie możliwe pary również, ale się zaciąłem i nie mam pojęcia co dalej :(. Chyba powinienem zrobić jakąś metodę rekurencyjną biorącą pod uwagę coraz to mniejszy zbiór par??? Ale nie wiem jak to ugryźć. Tu zamieszczam kod(proszę nie patrzeć na main'a bo nie jest istotny):

#include <bits/stdc++.h>
#include <vector>
using namespace std;

struct Pole{
    int x;
    int y;
    int odl;

    Pole() {}
    Pole(int x, int y, int odl) {
        this->x = x;
        this->y = y;
        this->odl = odl;
    }
};

struct Para{
    int x;
    int y;

    Para() {}

    Para(int x, int y) {
        this->x = x;
        this->y = y;
    }
};

bool operator==(const Pole& lhs, const Pole& rhs)
    {
    return (lhs.x == rhs.x) && (lhs.y == rhs.y);
    }

int odlegloscDlaJednegoSkoczka(Pole poleStartowe, Pole poleKoncowe){

    int ruchyX[] = { -2, -1, 1, 2, -2, -1, 1, 2 };
    int ruchyY[] = { -1, -2, -2, -1, 1, 2, 2, 1 };

    queue<Pole> stosik;
    vector<Pole> odwiedzone;
    Pole pole;
    int x,y;

    stosik.push(poleStartowe);

    odwiedzone.push_back(Pole(pole.x,pole.y,0));

    while(!stosik.empty()){
        pole = stosik.front();
        stosik.pop();

        if(pole.x == poleKoncowe.x && pole.y == poleKoncowe.y){
            return pole.odl;
        }

        for (int i = 0; i < 8; i++) {
            x = pole.x + ruchyX[i];
            y = pole.y + ruchyY[i];

            if (count(odwiedzone.begin(),odwiedzone.end(), Pole(x,y,0)) == 0) {
                odwiedzone.push_back(Pole(x,y,0));
                stosik.push(Pole(x, y, pole.odl + 1));
            }
        }
    }
    return 0;
}

void generujPary(vector<Para> *pary, int n){
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            pary->push_back(Para(i,j));
        }
    }
}


void generujWyniki(vector<int> *wyniki, vector<Para> pary){

    vector<Para> wybrane;
    
}

void wypiszNajkrotsza(vector<int> wyniki){}

int main()
{
    int n=10;
    vector<Para> pary;
    generujPary(&pary, n/2);
    vector<int> wyniki;
    generujWyniki(&wyniki, pary);
    wypiszNajkrotsza(wyniki);
    return 0;
}

Ale JAKI PROBLEM próbujesz rozwiazać? Od tego należy zacząć. Bo teraz mamy klasyczne https://xyproblem.info/

Pytasz o jakieś tworzenie wszystkich kombinacji par, a w rzeczywistości chcesz zrobić https://pl.wikipedia.org/wiki/Algorytm_Floyda-Warshalla
Tworzysz graf na podstawie szachownicy, zgodnie z ruchem skoczka, a następnie wyliczasz tym algorytmem najkrótsze ścieżki pomiędzy dowolną parą wierzchołków.
Jeśli na wejściu możliwych wierzchołków startowych jest bardzo mało to ewentualnie można też użyć https://pl.wikipedia.org/wiki/Algorytm_Dijkstry i puścić z każdego początkowego wierzchołka, albo, skoro i tak graf jest nieważony, to nawet trywialne https://pl.wikipedia.org/wiki/Przeszukiwanie_wszerz

Twój pomysł z parami nie ma żadnego sensu, bo co jeśli daje ci na wejściu 2 wierzchołki, takie że jednym ruchem można przejść z jednego do drugiego. Twój pomysł będzie wszystko przeliczać 2 razy o_O

@Shalom: Cały problem brzmi następująco :

Rozważmy nieograniczoną szachownicę, na której stoi pewna liczba skoczków i na której
wyróżniono taką samą liczbę pól docelowych. Po wykonaniu pewnej liczby ruchów
(opisanych powyżej) skoczki powinny znaleźć się na polach docelowych. Jak to zrobić
wykonując minimalną liczbę ruchów? Napisz program, który dla zadanego rozmieszczenia wyjściowego N skoczków i N pól docelowych znajdzie minimalną liczbę ruchów, po których skoczki znajdą się na polach docelowych.

Ja najpierw stworzyłem algorytm wyliczający dla pojedynczego skoczka z punktu A do B, następnie wygenerowałem wszystkie możliwe pary, ale potrzebuję teraz algorytmu który znajdzie wszystkie możliwe kombinacje tych par, obliczę w ten sposób sumy wszystkich kombinacji i wypiszę na wyjściu najmniejszą. które będą parami mnie nie obchodzi ponieważ wg treści potrzebuję tylko minimalną ilość ruchów.
Jeśli chodzi o wejście to rekordów ma być pomiędzy 1 a 1000, do tego szachownica ma być nie ograniczona dlatego uznałem to za dobre podejście.
Po krótkiej lekturze algorytm Floyda Warshalla potrzebuje zdefiniowanej wielkości szachownicy, a u mnie ma ona być nie ograniczona - co jeśli na wejściu będą współrzędne np 99999,99999 ?
Kod wstawiłem ponieważ łatwiej wtedy zobrazować mój problem, celowo zostawiłem puste funkcje które muszę uzupełnić o algorytmy.

Ale chyba algorytm przeszukiwania wszerz mi pomoże, spróbuję i dam znać
Dzięki!

a u mnie ma ona być nie ograniczona

To akurat nie ma specjalnie znaczenia, bo nigdy nie będziesz potrzebować skoczyć dalej niż 2 ruchy od pozycji docelowej, więc twoje pole startowe i końcowe określają ci wymiary szachownicy.
BFS moim zdaniem wystarczy, ale sugeruje być sprytnym i nie liczyć tego samego wielokrotnie. ;)