[Risolto] [c++] Problema con matrici allocate dinamicamente.

[armar]

Salve, avrei un problema sull'allocazione dinamica delle matrici. In pratica, è come se una volta richiamata la funzione che crea la matrice, al suo ritorno nel main, la matrice non viene per niente creata.... vi posto il codice, ci sto impazzendo :S

Codice: Seleziona tutto

#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;

void Crea_matrice(int , int ,int **);
void Crea_percorso(int ,int , int **);
int minimo_tra_2(int, int );
int minimo_tra_3(int ,int ,int );
int Scelta_percorso(int **,int , int , int, int );

int main()
{
    srand(time(0));
    cout<<"Inserisci il numero di catene di montaggio: ";
    int K;
    cin>>K;
    cout<<endl<<"Inserisci il numero di stazioni per ogni catena di montaggio: ";
    int L;
    cin>>L;
    L+=3;//+3 perchè ci servono ulteriori colonne per tempo iniziale, tempo finale e tempo di passaggio da una catena ad un'altra
    cout<<endl;
    int **stabilimento;
    Crea_matrice(K,L,stabilimento);
    int **percorso;
    Crea_percorso(K,(L-3),percorso);
    for(int i=0; i<K; i++)
    {
        for (int j=0;j<(L-3); j++)
        {
            percorso[i][j]=Scelta_percorso(stabilimento,i,j,K,L);
        }
    }
    return 0;
}


void Crea_matrice(int righe, int colonne,int **stabilimento) //funzione che alloca dinamicamente una matrice con il numero di righe( catene di montaggio dello stabilimento) e di
//colonne (numero di postazioni per ogni catena) date in input
{
    stabilimento= new int * [righe]; //allochiamo le righe della matrice
    for(int i=0;i<righe;i++)
    {
        stabilimento[i]= new int [(colonne)]; //con questo for, per ogni riga della matrice, allochiamo n colonne quante sono le righe
    }
    for(int i=0;i<righe;i++)
    {
        for (int j=0;j<(colonne);j++)
        {
            stabilimento[i][j]=1+rand()%21;//con questi for, azzeriamo tutte le caselle della matrice
        }
    }
    for(int i=0;i<colonne;i++)
        {
        if(i==0) cout<<"I\t";
        else if(i==colonne-2) cout<<"U\t";
        else if(i==colonne-1) cout<<"T";
        else cout<<"S\t";
        }
    cout<<endl;
    for (int i=0;i<righe;i++)
    {
        for(int j=0;j<colonne;j++)
        {
            cout<<stabilimento[i][j]<<" \t";
        }
        cout<<endl;
    }
}

void Crea_percorso(int righe, int colonne,int **percorso) //funzione che alloca dinamicamente una matrice con il numero di righe( catene di montaggio dello stabilimento) e di
//colonne (numero di postazioni per ogni catena) date in input
{
    percorso= new int * [righe]; //allochiamo le righe della matrice
    for(int i=0;i<righe;i++)
    {
        percorso[i]= new int [(colonne)]; //con questo for, per ogni riga della matrice, allochiamo n colonne quante sono le righe
    }
}

int minimo_tra_2(int a, int b)
{
    if (a<b) return a;
    else return b;
}

int minimo_tra_3(int a, int b,int c)
{
    if((a<b)&&(b<c)) return b;
    else
    {
        if((a<b)&&(a<c)) return a;
        else return c;
    }
}

int Scelta_percorso(int **stabilimento,int righe, int colonne, int last_riga, int last_colonna)
{
    if((righe==0)|| (righe==last_riga))
    {
        if(colonne==1){
        return stabilimento[righe][0]+stabilimento[righe][1];
        }
        else
        {
        return minimo_tra_2((Scelta_percorso(stabilimento,righe,colonne-1, last_riga,last_colonna)+stabilimento[righe][colonne]), (Scelta_percorso(stabilimento,righe+1,colonne-1,last_riga,last_colonna)+stabilimento[righe][colonne]+stabilimento[righe+1][colonne]));
        }
    }
    else
    {
        return minimo_tra_3((Scelta_percorso(stabilimento,righe,colonne-1,last_riga,last_colonna)+stabilimento[righe][colonne]),(Scelta_percorso(stabilimento,righe+1,colonne-1,last_riga,last_colonna)+stabilimento[righe][colonne]+stabilimento[righe+1][colonne]),(Scelta_percorso(stabilimento,righe-1,colonne-1,last_riga,last_colonna)+stabilimento[righe][colonne]+stabilimento[righe-1][colonne]));
    }
}


[l3on4rdo]

quindi supponi che il problema sia in questa funzione?

Codice: Seleziona tutto

void Crea_matrice(int righe, int colonne,int **stabilimento) //funzione che alloca dinamicamente una matrice con il numero di righe( catene di montaggio dello stabilimento) e di
//colonne (numero di postazioni per ogni catena) date in input
{
    stabilimento= new int * [righe]; //allochiamo le righe della matrice
    for(int i=0;i<righe;i++)
    {
        stabilimento[i]= new int [(colonne)]; //con questo for, per ogni riga della matrice, allochiamo n colonne quante sono le righe
    }
    for(int i=0;i<righe;i++)
    {
        for (int j=0;j<(colonne);j++)
        {
            stabilimento[i][j]=1+rand()%21;//con questi for, azzeriamo tutte le caselle della matrice
        }
    }
    for(int i=0;i<colonne;i++)
        {
        if(i==0) cout<<"I\t";
        else if(i==colonne-2) cout<<"U\t";
        else if(i==colonne-1) cout<<"T";
        else cout<<"S\t";
        }
    cout<<endl;
    for (int i=0;i<righe;i++)
    {
        for(int j=0;j<colonne;j++)
        {
            cout<<stabilimento[i][j]<<" \t";
        }
        cout<<endl;
    }
}

[armar]

Anche nella funzione Crea_percorso... non so piu che fare

[1001001]

il problema è che tu chiami la funzione Crea_matrice con un doppio puntatore passato per copia. Cioè quando chiami la funzione, si crea un secondo doppio puntatore di valore uguale a stabilimento (quello del main) (cioè punta alla zona di memoria puntata da stabilimento nel main). Ma quando tu fai new, il puntatore nella funzione cambia, mentre quello nel main no, perchè sono due diverse variabili (che alla chiamata della funzione hanno valore uguale), e il fatto di cambiare l'indirizzo della zona di memoria puntata da stabilimento nella funzione non si ripercuote in un cambio dell'indirizzo della zona di memoria puntata da stabilimento nel main.

La soluzione è questa:
header:

Codice: Seleziona tutto

void Crea_matrice(int , int ,int ***);

chiamata nel main:

Codice: Seleziona tutto

Crea_matrice(K, L, &stabilimento);

prototipo della funzione:

Codice: Seleziona tutto

void Crea_matrice(int righe, int colonne,int ***stabilimento)

e nella funzione stessa devi sostituire stabilimento con (*stabilimento):

Codice: Seleziona tutto

void Crea_matrice(int righe, int colonne,int ***stabilimento) //funzione che alloca dinamicamente una matrice con il numero di righe( catene di montaggio dello stabilimento) e di
//colonne (numero di postazioni per ogni catena) date in input
{
    (*stabilimento)= new int * [righe]; //allochiamo le righe della matrice
    for(int i=0;i<righe;i++)
    {
        (*stabilimento)[i]= new int [(colonne)]; //con questo for, per ogni riga della matrice, allochiamo n colonne quante sono le righe
    }
    for(int i=0;i<righe;i++)
    {
        for (int j=0;j<(colonne);j++)
        {
            (*stabilimento)[i][j]=1+rand()%21;//con questi for, azzeriamo tutte le caselle della matrice
        }
    }
    for(int i=0;i<colonne;i++)
        {
        if(i==0) cout<<"I\t";
        else if(i==colonne-2) cout<<"U\t";
        else if(i==colonne-1) cout<<"T";
        else cout<<"S\t";
        }
    cout<<endl;
    for (int i=0;i<righe;i++)
    {
        for(int j=0;j<colonne;j++)
        {
            cout<<(*stabilimento)[i][j]<<" \t";
        }
        cout<<endl;
    }
}


e la stessa cosa con Crea_percorso.



poi c'è anche un errore nella ricorsione, che entra in loop infinito, ma non sapendo cosa deve fare la funzione ricorsiva non riesco a trovare l'errore

[armar]

Innanzitutto ti ringrazio :)
in pratica la ricorsione deve fare questo:

f[k][j]=
e[k] + a [k][1]    se    j=1
minimo tra : f[k][j-1]+a[k][j]    e    f[k+1][j-1]+ S[k+1]+ a[k][j]

dove:
f è la mia funzione stabilimento;
K=numero di righe
L=numero di colonne
e[k] sarebbe la mia colonna I
a[k][1] è la mia prima colonna S
S[k+1] è la colonna T

e la stessa formula, devo adattarla nel caso in cui i percorsi adiacenti siano 3... è il problema della catena di montaggio per intenderci... praticamente lo stabilimento ha K catene di montaggio con L postazioni, e la macchina deve decidere il percorso da seguire seguendo quella formula... solo che quella formula è valida solo se sono 2 le catene, io devo farla  generica che valga per il caso in cui K>2...
ti ringrazio ancora per l'aiuto che mi hai dato

[1001001]

un paio di cose:
1) se f è la funzione stabilimento, perchè chiami la funzione ricorsiva nell'assegnamento a percorso[ i ][ j ]? O la funzione ricorsiva è ricorsiva, e allora la chiami su stabilimento[ i ][ j ] oppure non è ricorsiva, e semplicemente puoi calcolare percorso[ i ][ j ] con la formula sopra, usando un paio di if
2) secondo me, da quello che capisco di questo problema, la funzione non è ricorsiva, perchè (come tu hai fatto) deve calcolare un percorso a partire da stabilimento...però se ce l'hai potresti postare il testo dell'esercizio?
3) tralasciando i punti sopra, il nome delle variabili è importante non sai quanto ci ho messo a capire che righe (nella funzione ricorsiva) era in realtà l'indice di riga (e uguale per colonne). Parlo per esperienza personale, anch'io ho appena fatto un pezzo di un programma (che dobbiamo fare in gruppo per l'università) in cui ho messo un nome infelice di una variabile e nessuno ha più capito niente...lo so che i professori dicono sempre che le variabili le puoi chiamare anche pippo, pluto e topolino (chissà perchè, hanno tutti una fissa con la Disney ), ma un nome esplicativo spesso facilita la lettura

[armar]

non posso che darti ragione sul fatto del nome delle variabili... comunque si ci stavo pensando nel fatto di farlo iterativo, ragionandoci un po' meglio, alla fine è cosi che deve essere fatto... il testo dell'esercizio comunque è:

Codice: Seleziona tutto

La Fiat per la produzione della Nuova Panda ha installato nello sta-
bilimento di Pomigliano d’ Arco K catene di montaggio, con K > 1.
Ogni catena di montaggio ha L stazioni di lavoro. Ogni stazione di
lavoro ha un tempo di lavorazione differente T . Inoltre il telaio della
Nuova Panda impiega un tempo iniziale I per entrare nella catena
di montaggio ed un tempo U per uscire, tempi differenti per ogni
 catena di montaggio. Infine, per fornire all’ impianto la massima
flessibilit ́ si prevede la possibilit ́ che la Nuova Panda possa migrare
da una catena di montaggio ad un’ altra e tale operazione impieghi
un tempo, differente per ogni catena, pari a S. Si implementi, un pro-
gramma, utilizzando la programmazione dinamica, che individui per
ogni vettura il percorso pi ́ rapido. Si verifichi la correttezza dell’ im-
plementazione su una serie di configurazioni possibili dell’ impianto


mi correggo comunque, f non è la  funzione stabilimento... ci sono arrivato ora o.o

[1001001]

così su due piedi, io farei una funzione iterativa che crea tutti i possibili percorsi e poi alla fine sceglierei il minimo con un ciclo for su tutti i valori dei vari percorsi...

[armar]

allora, ecco gli sviluppi... solo che non mi trovo con i calcoli che fa >_<

Codice: Seleziona tutto


#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;

void Crea_matrice(int , int ,int ***);
void Crea_percorso(int ,int , int ***);
int minimo_tra_2(int, int );
int minimo_tra_3(int ,int ,int );
void visualizza(int , int , int ***);
void Fast_way(int ***, int ***, int , int);//percorso + rapido
//void percorso_ottimo(int ***,int, int, int **);

int main()
{
    srand(time(0));
    cout<<"Inserisci il numero di catene di montaggio: ";
    int K;
    cin>>K;
    cout<<endl<<"Inserisci il numero di stazioni per ogni catena di montaggio: ";
    int L;
    cin>>L;
    L+=3;//+3 perchè ci servono ulteriori colonne per tempo iniziale, tempo finale e tempo di passaggio da una catena ad un'altra
    cout<<endl;
    int **stabilimento;
    Crea_matrice(K, L, &stabilimento);
    int **f;//matrice secondaria x fast way
    Crea_percorso(K,(L-3),&f);
    int **percorso_ott;
    Crea_percorso(K,(L-3),&percorso_ott);
    Fast_way(&f,&stabilimento,K,L);
    visualizza(K,(L-3),&f);
    /*percorso_ottimo(&f,K,(L-3),&array);
    cout<<"Stampa del percorso ottimo: "<<endl;
    for(int w=0;w<(L-3);w++)
    {
        cout<<array[w]<<" \t";
    }*/
    //delete array;
    delete percorso_ott;
    delete stabilimento;
    delete f;
    return 0;
}


/*void percorso_ottimo(int ***f,int K, int L, int **array)
{
    for(int i=0;i<L;i++)
    {
        if((*f)[0][i]<=(*f)[1][i])
            (*array)[i]=1;
        else
            (*array)[i]=2;
    }
}*/

void Fast_way(int ***f, int ***stabilimento, int K, int L)
{
    int j=1;
    int colonnef=(L-3);//indica il numero di col sll ql andiamo ad operare
    int righe=K;
    int colonne=L;
    while(j<=colonnef)
        {
        if(j==1)
        {
        for(int k=0; k<righe; k++)
        {
        (*f)[k][0]=(*stabilimento)[k][0]+(*stabilimento)[k][1];
        }
        }

        else
        {

        (*f)[0][j-1]=minimo_tra_2( ((*f)[0][j-2]+(*stabilimento)[0][j]) , ((*f)[1][j-2]+(*stabilimento)[0][colonne-1]+(*stabilimento)[0][j]) );
        (*f)[1][j-1]=minimo_tra_2( ((*f)[1][j-2]+(*stabilimento)[1][j]) , ((*f)[0][j-2]+(*stabilimento)[1][colonne-1]+(*stabilimento)[1][j]) );
        }
        j++;
        }
        cout<<endl;
}

void Crea_matrice(int righe, int colonne,int ***stabilimento) //funzione che alloca dinamicamente una matrice con il numero di righe( catene di montaggio dello stabilimento) e di
//colonne (numero di postazioni per ogni catena) date in input
{
    (*stabilimento)= new int * [righe]; //allochiamo le righe della matrice
    for(int i=0;i<righe;i++)
    {
        (*stabilimento)[i]= new int [(colonne)]; //con questo for, per ogni riga della matrice, allochiamo n colonne quante sono le righe
    }
    for(int i=0;i<righe;i++)
    {
        for (int j=0;j<(colonne);j++)
        {
            (*stabilimento)[i][j]=1+rand()%21;//con questi for, azzeriamo tutte le caselle della matrice
        }
    }
    for(int i=0;i<colonne;i++)
        {
        if(i==0) cout<<"I\t";
        else if(i==colonne-2) cout<<"U\t";
        else if(i==colonne-1) cout<<"T";
        else cout<<"S\t";
        }
    cout<<endl;
    for (int i=0;i<righe;i++)
    {
        for(int j=0;j<colonne;j++)
        {
            cout<<(*stabilimento)[i][j]<<" \t";
        }
        cout<<endl;
    }
}

void Crea_percorso(int righe, int colonne,int ***percorso) //funzione che alloca dinamicamente una matrice con il numero di righe( catene di montaggio dello stabilimento) e di
//colonne (numero di postazioni per ogni catena) date in input
{
    (*percorso)= new int * [righe]; //allochiamo le righe della matrice
    for(int i=0;i<righe;i++)
    {
        (*percorso)[i]= new int [(colonne)]; //con questo for, per ogni riga della matrice, allochiamo n colonne quante sono le righe
    }
}

int minimo_tra_2(int a, int b)
{
    if (a<b) return a;
    else return b;
}

int minimo_tra_3(int a, int b,int c)
{
    if((a<b)&&(b<c)) return b;
    else
    {
        if((a<b)&&(a<c)) return a;
        else return c;
    }
}

void visualizza(int righe, int colonne, int ***f)
{
    for (int i=0;i<righe;i++)
    {
        for(int j=0;j<colonne;j++)
        {
            cout<<(*f)[i][j]<<" \t";
        }
        cout<<endl;
    }
}


[1001001]

in realtà penso che tu abbia fatto un po' di confusione :)

1) ogni riga della matrice stabilimento rappresenta una catena di montaggio giusto? Ma questa catena di montaggio dovrebbe avere L stazioni, ognuna con un suo tempo di lavorazione T, mentre tu hai un solo T. Se poi S è il tempo di passaggio da una catena all'altra, ci dovrebbero essere K - 1 colonne S (K è il numero di catene di montaggio) perchè non ha senso definire il tempo di passaggio da una catena a se stessa.

2) perchè rappresenti la variabile percorso come una matrice? cioè, percorso dovrebbe essere secondo me un vettore che ti dice quale catena di montaggio usi per ogni stazione. Una cosa tipo (se K = 3, L = 2, ad es): 1 3 2 3
che vuol dire:
ingresso ---> catena 1
stazione 1 ---> catena 3
stazione 2 ---> catena 2
uscita ----> catena 3

quando dopo aver fatto fast_way fai:

Codice: Seleziona tutto

visualizza(K,(L-3),&f);

e ti fai stampare la matrice f, questa cosa dovrebbe rappresentare?

quindi non riesco a capire il senso anche di

Codice: Seleziona tutto

f[k][j]=
e[k] + a [k][1]     se    j=1
minimo tra : f[k][j-1]+a[k][j]    e     f[k+1][j-1]+ S[k+1]+ a[k][j]


perchè non vedo come questo possa crearti il percorso più veloce. Da dove l'hai preso questo algoritmo?

3) supponendo che il calcolo di f come sopra sia giusto, questo:

Codice: Seleziona tutto

f[k][j]=minimo tra : f[k][j-1]+a[k][j]    e     f[k+1][j-1]+ S[k+1]+ a[k][j] se j != 1


e questo:

Codice: Seleziona tutto

(*f)[0][j-1]=minimo_tra_2( ((*f)[0][j-2]+(*stabilimento)[0][j]) , ((*f)[1][j-2]+(*stabilimento)[0][colonne-1]+(*stabilimento)[0][j]) );
(*f)[1][j-1]=minimo_tra_2( ((*f)[1][j-2]+(*stabilimento)[1][j]) , ((*f)[0][j-2]+(*stabilimento)[1][colonne-1]+(*stabilimento)[1][j]) );


non sono la stessa cosa, perchè nel primo caso c'è k e nel secondo solo 0 e 1, e comunque avendo f anche a destra dovrebbe essere una chiamata ricorsiva, ma allora torniamo al discorso di qualche post più su, e cioè che questa cosa secondo me non fa quello che vuoi tu

4) la parte su percorso_ottimo è commentata perchè la fast way fa la stessa cosa? E perchè hai creato la variabile percorso_ott che poi non usi?



detto questo, non riesco a capire bene cosa voglia l'esercizio, quando dice:

Codice: Seleziona tutto

Si implementi, un programma, utilizzando la programmazione dinamica, che individui per ogni vettura il percorso più rapido

nel senso, una volta che i vari tempi sono fissati, il percorso più rapido è unico no?

PS:
Nota: quando passi a una funzione un valore che deve essere modificato devi passarlo con la referenza, cioè un puntatore a quel valore, così come fai nella Crea_matrice o nella crea_percorso. Ma se il valore non deve essere modificato non serve dereferenziarlo, puoi passarlo per copia. Quindi ad esempio nella funzione visualizza, non serve passare &f, e dichiarare un int *** nell'header, basta dichiarare int ** e passare f. Funziona comunque anche come hai fatto tu, ma è più rischioso, perchè ad esempio potresti per sbaglio cambiare il valore di *stabilimento e questo si ripercuoterebbe anche nel main, e tu non vuoi dare a una funzione di stampa la possibilità di cambiare la tua struttura dati.

pps: scusa il papiro

ppps: io potrei non avere capito niente di niente e stare facendo la figura del gradasso, nel qual caso mi scuso moltissimo

[armar]

Ti ringrazio per il tempo che mi stai dedicando
ti rispondo facendoti un esempio di quello che dovrebbe fare il programma:
I  T  T T  U  S  (si, ho sbagliato qui, ho invertito la T con la S, errore di distrazione  )
3  2  5  1  5  8  (questa è la matrice stabilimento)
4  1  6  3  3  1

ora io, dovrei applicare la formula di sopra... ossia:
(f1 e f2 vanno riempite l'una dopo l'altra, ogni [ ] rappresenta una casella, contemporaneamente, a seconda del minimo che scegliamo, riempiamo l'array p1 e p2, p1[0] e p2[0] sono nulli)
F[1]= [3+2]  [min(3+2+5 , 4+1+8+5)](quindi scriviamo [10])
F[2]= [4+1]  [min(4+1+6 , 3+2+1+6)](quindi scriviamo [11])
p1= [/](nullo) [1](perchè rimaniamo sulla stessa catena)
p2= [/](nullo) [2](sempre perchè rimaniamo sulla stessa catena)
adesso, ricapitolando abbiamo:

F[1]= [5] [10]  p1=[/] [1]
F[2]= [5] [11]  p2=[/] [2]

Continuando avremo:
F[1]= [5] [10] [min(10+1 , 11+8+1)](quindi 11) e in p1=[/] [1] [1]
F[2]= [5] [11]  [min(11+3 , 10+1+3)](indifferente ma prendo il secondo 11 per dare l'esempio della variazione di p2 che diventa): p2= [/] [2] [1]

A questo punto, dato che le colonne T sono terminate, devo sommare e memorizzare in 2 variabili temp1 e temp2 i valori finali delle catene + il costo di uscita di ciascuna... ossia:
temp1=f[1][3]+U= 11+5=16
temp2=f[2][3]+U= 11+3=14

A questo punto, creo un vettore p_ottimo, che si andrà a riempire dall'ultimo elemento fino al primo con questo criterio:
temp2temp2-U[prima catena]=14-5=9. siccome 9 non è contenuto ne nell'ultimo elemento di f1, ne nell'ultmo di f2, ne segue che il nostro array p_ottimo, dovrà avere come ultimo valore, 2, in quanto temp2-U[seconda catena]=14-3=11, ossia l'ultimo valore di f[2].

il nostro p_ottimo inizia a rimepirsi  -  p_ottimo =                  [2] -
ora procedendo a ritroso nell'array p2, troviamo 1, quindi scriviamo 1 in p_ottimo, e saliamo in p1:
p_ottimo=        [1]  [2]
sempre procedendo a ritroso in p1, troviamo 1, quindi scriviamo 1 e rimaniamo in p1:
p_ottimo = [1]  [1]  [2]
adesso, troviamo la casella nulla in p1, quindi l'algoritmo termina...
infatti, cosi facendo, p_ottimo rappresenta il miglior percorso per risparmiare in termini di tempo per l'assemblaggio di una Panda

spero di essermi espresso chiaramente questa volta

[1001001]

sì, ho capito

secondo me allora la Fast_way così modficata:

Codice: Seleziona tutto

void Fast_way(int ***f, int ***stabilimento, int K, int L)
{
    int j=0;
    int colonnef=(L-3);//indica il numero di col sll ql andiamo ad operare
    int righe=K;
    int colonne=L;
    while(j<colonnef)
    {
        if(j==0)
        {
           for(int k=0; k<righe; k++)
           {
              (*f)[k][0]=(*stabilimento)[k][0]+(*stabilimento)[k][1];
           }
        }

        else
        {
           (*f)[0][j]=minimo_tra_2 ( ((*f)[0][j-1]+(*stabilimento)[0][j+1]) ,
                       ((*f)[1][j-1]+(*stabilimento)[0][colonne-1]+(*stabilimento)[1][j+1]) );
                       
           (*f)[1][j]=minimo_tra_2 ( ((*f)[1][j-1]+(*stabilimento)[1][j+1]) ,
                       ((*f)[0][j-1]+(*stabilimento)[1][colonne-1]+(*stabilimento)[0][j+1]) );
       }
       
        j++;
    }
        cout<<endl;
}

dovrebbe funzionare, per quanto riguarda la matrice f.

Nota che però dovresti anche passare una matrice p in cui salvare, in ogni riga i, i vettori p_i di cui parlavi

[armar]

allora ho risolto cosi, passando la matrice in minimo_tra_2, solo che non riesco a creare p_ottimo che si riempie ricorsivamente :s posto il codice:

Codice: Seleziona tutto

#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;

void Crea_matrice(int , int ,int ***);
void Crea_percorso(int ,int , int ***);
int minimo_tra_2(int, int , int, int , int ***);
void visualizza(int , int , int ***);
void Fast_way(int ***, int ***, int ***, int , int);//percorso + rapido
void More_faster(int ***, int **, int);

int main()
{
    srand(time(0));
    cout<<"Inserisci il numero di catene di montaggio: ";
    int K;
    cin>>K;
    cout<<endl<<"Inserisci il numero di stazioni per ogni catena di montaggio: ";
    int L;
    cin>>L;
    L+=3;//+3 perchè ci servono ulteriori colonne per tempo iniziale, tempo finale e tempo di passaggio da una catena ad un'altra
    cout<<endl;
    int **stabilimento;
    Crea_matrice(K, L, &stabilimento);
    int **f;//matrice secondaria x fast way
    Crea_percorso(K,(L-3),&f);
    int **p;
    Crea_percorso(K,(L-3),&p);
    Fast_way(&f,&stabilimento,&p,K,L);
    visualizza(K,(L-3),&f);
    for(int w=0; w<2;w++)
    {
        for(int z=0;z<(L-3);z++)
        {
            cout<<p[w][z]<<" ";
        }
        cout<<endl;
    }
    delete p;
    delete stabilimento;
    delete f;
    return 0;
}

/*void More_faster(int ***p; int **p_star, int len) //p_ottimo sarebbe p_star... e non ho idea di come crearlo
{
    while(((*p)[0][len]==0) || ((*p)[1][len]==0))
    {

    }
}*/

void Fast_way(int ***f, int ***stabilimento, int ***p, int K, int L)
{
    int j=1;
    int colonnef=(L-3);//indica il numero di col sll ql andiamo ad operare
    int righe=K;
    int colonne=L;
    while(j<=colonnef)
        {
        if(j==1)
        {
        for(int k=0; k<righe; k++)
        {
        (*f)[k][0]=(*stabilimento)[k][0]+(*stabilimento)[k][1];
        }
        }

        else
        {

        (*f)[0][j-1]=minimo_tra_2( ((*f)[0][j-2]+(*stabilimento)[0][j]) , ((*f)[1][j-2]+(*stabilimento)[0][colonne-1]+(*stabilimento)[0][j]) ,0,j-1,&(*p));
        (*f)[1][j-1]=minimo_tra_2( ((*f)[1][j-2]+(*stabilimento)[1][j]) , ((*f)[0][j-2]+(*stabilimento)[1][colonne-1]+(*stabilimento)[1][j]) ,1,j-1,&(*p));
        }
        j++;
        }
        cout<<endl;
}

void Crea_matrice(int righe, int colonne,int ***stabilimento) //funzione che alloca dinamicamente una matrice con il numero di righe( catene di montaggio dello stabilimento) e di
//colonne (numero di postazioni per ogni catena) date in input
{
    (*stabilimento)= new int * [righe]; //allochiamo le righe della matrice
    for(int i=0;i<righe;i++)
    {
        (*stabilimento)[i]= new int [(colonne)]; //con questo for, per ogni riga della matrice, allochiamo n colonne quante sono le righe
    }
    for(int i=0;i<righe;i++)
    {
        for (int j=0;j<(colonne);j++)
        {
            (*stabilimento)[i][j]=1+rand()%21;//con questi for, azzeriamo tutte le caselle della matrice
        }
    }
    for(int i=0;i<colonne;i++)
        {
        if(i==0) cout<<"I\t";
        else if(i==colonne-2) cout<<"U\t";
        else if(i==colonne-1) cout<<"T";
        else cout<<"S\t";
        }
    cout<<endl;
    for (int i=0;i<righe;i++)
    {
        for(int j=0;j<colonne;j++)
        {
            cout<<(*stabilimento)[i][j]<<" \t";
        }
        cout<<endl;
    }
}

void Crea_percorso(int righe, int colonne,int ***percorso) //funzione che alloca dinamicamente una matrice con il numero di righe( catene di montaggio dello stabilimento) e di
//colonne (numero di postazioni per ogni catena) date in input
{
    (*percorso)= new int * [righe]; //allochiamo le righe della matrice
    for(int i=0;i<righe;i++)
    {
        (*percorso)[i]= new int [(colonne)]; //con questo for, per ogni riga della matrice, allochiamo n colonne quante sono le righe
    }
}

int minimo_tra_2(int a, int b, int indice, int indice2, int ***p)
{
    if (a<b)
    {   (*p)[indice][indice2]=1;
        return a;}
    else
    {
        (*p)[indice][indice2]=2;
        return b;
    }
}


void visualizza(int righe, int colonne, int ***f)
{
    for (int i=0;i<righe;i++)
    {
        for(int j=0;j<colonne;j++)
        {
            cout<<(*f)[i][j]<<" \t";
        }
        cout<<endl;
    }
}

[1001001]

l'idea che mi è venuta è questa (è iterativa, non ricorsiva...come avrai capito, la ricorsione per me è l'ultima spiaggia, mi rassegno a usarla solo quando tutto il resto fallisce :) )

diciamo che p sia, come nell'esempio sopra:
/ 1 1
/ 2 1

e che tu debba partire da 2 con p_ottimo

allora basta fare un ciclo sulle colonne all'indietro:

Codice: Seleziona tutto

p_ottimo = new int [3]; //sono sempre nel caso particolare dell'esempio
p_ottimo [2] = 2;

for (int k = 1; k >= 0; k++)
{
     int prev_index = p_ottimo [k+1] - 1;
     p_ottimo [k] = p[prev_index] [k+1]
}


tornando all'esempio:
p_ottimo [2] = 2
k = 1 -----> prev_index = p_ottimo [2] - 1 = 2 - 1 = 1
               p_ottimo [1] = p [1][2] = 1

k = 0 ------>  prev_index = p_ottimo [1] - 1 = 1 - 1 = 0
               p_ottimo [1] = p [ 0 ][1] = 1


=> p_ottimo = 1 1 2

[armar]

Fatto, e implementato anche per un numero di catene > 2 GRAZIE!!! 

[1001001]

di nulla!

[Ntanitime]

Un consiglio che ormai ti servirà a poco!
Quando fai una matrice in C++ non usare i puntatori usa i vettori (quelli della libreria standard) così risparmi tempo ed eviti moltissimi errori. 
Usando i vettori non perdi efficienza e guadagni in leggibilità e sicurezza!