Ho tenuto conto del consiglio dato da Scara95, dicendo di far variare l'ultimo elemento e via via retrocedere fino alla prima colonna.
Con questo sistema, sono riuscito a risolvere le prime due parti del problema.
Il codice qui riportato, permette di creare le disposizioni con ripetione, di due gruppi di elementi, di numeri diversi da raggruppare in due numeri diversi: se qualcuno ha miglioramenti da fare, ben accetti.
Con un esempio spero di essere piu' chiaro:
significa che posso creare le n1^k1 * n2^k2 disposizioni con ripetizione dei parametri passati alla funzione.
se n1 = 2 e i valori sono 'a' e 'b', e k1=3,
se n2 = 3 e i valori sono '0' , '1' e '2', e k2=2,
le disposizione che dovrei ottenere sono 2^3 * 3^2 = 8 * 9 = 72
(me le appiccica tutte assieme, ma vanno lette a gruppi di 5 (k1+k2) )
a a a 0 0 // a a b 0 0 // a b a 0 0
a a a 0 1 // a a b 0 1 // a b a 0 1
a a a 0 2 // a a b 0 2 // a b a 0 1
a a a 1 0 // a a b 1 0 // a b a 1 0
a a a 1 1 // a a b 1 1 // a b a 1 1
a a a 1 2 // a a b 1 2 // a b a 1 2
a a a 2 0 // a a b 2 0 // a b a 2 0
a a a 2 1 // a a b 2 1 // a b a 2 1
a a a 2 2 // a a b 2 2 // a b a 2 2
a b b 0 0 // b a a 0 0 // b a b 0 0
a b b 0 1 // b a a 0 1 // b a b 0 1
a b b 0 2 // b a a 0 2 //b a b 0 1
a b b 1 0 // b a a 1 0 // b a b 1 0
a b b 1 1 // b a a 1 1 // b a b 1 1
a b b 1 2 // b a a 1 2 //b a b 1 2
a b b 2 0 // b a a 2 0 // b a b 2 0
a b b 2 1 // b a a 2 1 // b a b 2 1
a b b 2 2 // b a a 2 2 // b a b 2 2
b b a 0 0 // b b b 0 0
b b a 0 1 // b b b 0 1
b b a 0 2 // b b b 0 1
b b a 1 0 // b b b 1 0
b b a 1 1 // b b b 1 1
b b a 1 2 // b b b 1 2
b b a 2 0 // b b b 2 0
b b a 2 1 // b b b 2 1
b b a 2 2 // b b b 2 2
codice:
template<class T>
std::vector<std::vector<T>> makeDispositionWithRepetitions_multi(std::vector<T>& value1, const unsigned int& k1, std::vector<T>& value2, const unsigned int& k2)
{
std::vector<std::vector<T>> matrix;
//mettere controllo che il vettore degli elementi value sia valido, cioè non sia vuoto
//mettere controllo che k sia di valore maggiore o uguale a 1
//se le condizioni sono rispettate, vado avanti
unsigned int k = k1 + k2;
std::vector<int> temp(k,0);
unsigned int n = value1.size();//numero degli elementi che daranno origine alle disposizioni
//do per scontato che il numero di valori sia identico per entrambi i vettori
unsigned int n1 = value1.size();
unsigned int n2 = value2.size();
std::vector<T> new_row;
//cilco for per inizializzare la prima riga coi primi k1 valori uguali a value1[0], gli altri k2 valori uguali a value2[0]
for(unsigned int pippo = 0; pippo< k; pippo++)
{
if(pippo<k1)
{
new_row.push_back(value1[0]);
}
else
{
new_row.push_back(value2[0]);
}
}
bool condizione = true;//diventa false quando l'elemento della prima colonna viene messo a zero
matrix.push_back(new_row);//inserisco la prima riga nella matrice
while (condizione)
{
if(temp[k-1] + 1 == n2)
{
temp[k-1] = 0;//rimetto a zero l'indice dell'elemento dell'ultima colonna
//std::cout<<"Ho messo a zero l'ultima colonna";
bool stop = true;
unsigned int j = 1;
while(stop)
{
if(j<k2)
{
if(temp[k-1-j] + 1 == n2)
{
if(j + 1 == k)
{
condizione = false;
stop = false;
}
else
{
temp[k-1-j] = 0;
j = j + 1;
}
}
else
{
temp[k-1-j] = temp[k-1-j] + 1;
stop = false;
}
}
else if(j>=k2)
{
if(temp[k-1-j] + 1 == n1)
{
if(j + 1 == k)
{
condizione = false;
stop = false;
}
else
{
temp[k-1-j] = 0;
j = j + 1;
}
}
else
{
temp[k-1-j] = temp[k-1-j] + 1;
stop = false;
}
}
}
}
else
{
temp[k-1] = temp[k-1] + 1;
}
for(unsigned int t = 0; t<k; t++)
{
if(t<k1)
{
new_row[t] = value1[temp[t]];
}
else
{
new_row[t] = value2[temp[t]];
}
}
if(condizione)
{
matrix.push_back(new_row);
}
/*for(unsigned int i=0; i<matrix.size(); i++)
{
for(unsigned int j=0; j<matrix[0].size(); j++)
{
//std::cout<<std::setprecision(2);
std::cout<<matrix[i][j]<<" ";
}
std::cout<<std::endl;
}
getchar();*/
}
return matrix;
}