code:

Per un numero abbastanza grande di contenitori non è detto che nella memoria ci sia abbastanza spazio (consecutivo)
 per l'allocazione della memoria necessaria per contenere l'intero array...

Originally posted by arfish
Ragazzi ma se i risultati del sono identici a quelli del prof. ma non nello stesso ordine??? Va bene lo stesso???

Originally posted by francescoo
ciao,
dpo tutto mi sono accorto ora di avere un problema all'inizio..
nell'inserimento delle capacità io ho utilizzato un
while(getchar()!='\n')
{
se diverso da ' ' inserisco il valore nel vett
}

il problema è che usando il getchar il valore è un carattere che vado a inserire in un vett di caratteri che poi trasformo in intero..
il problema è che cosi facendo prende numero <10
perche se inserisco 10 il getchar me li prende come 2 numeri diversi..
quindi mi fa un cont da 1 e un cont da 0..
ho provato a fare sempre il while con il getchar e poi all'interno lo scanf ma si blocca..
help me..

code:

leggi_input(vett *v){
	int n,c;
	v->i=(int *)malloc(sizeof(int));
	v->dim=0;

	while((c=getchar()) != '\n')
	{
	 	scanf ("%d", &n);
		v->i=(int *)realloc(v->i,(v->dim+1)*sizeof(int));
		v->i[v->dim]=n;
		v->dim++;
	}
}

struct vett{
 int dim;
 int i*;
}

code:

- pericolosa(a)
  Dato un vettore a = (a1 , a2 , . . . , an ) di interi positivi, dichiara “pericolosa” la configurazione 
in cui il contenitore i ha livello ai . Questo implica che questa configurazione 
non potrà più essere utilizzata nel calcolo di altre operazioni (quali ad esempio contenenti(k) o mosse(k)) 
fino a quando non sia nuovamente dichiarata come innocua con l’operazione innocua(a) descritta sotto. 
In particolare se una operazione elementare trasforma la configurazione attuale in una configurazione pericolosa,
l’operazione non deve essere eseguita, e deve essere stampato il messaggio OPERAZIONE PERICOLOSA.

code:

>w 2
(3[3],2[5])
(0[3],2[5])
(2[3],0[5])
(2[3],5[5])
>p 2 0
>w 2
(2[3],5[5])

code:

le configurazioni pericolose al momento di eseguire il secondo w 2
sono:
    (0[3],5[5])
    (3[3],5[5])
    (2[3],0[5])

Quindi tre delle quattro configurazioni contenenti un 2 non
sono piu' raggiungibile, mentre rimane raggiungibile,
attraverso una strada che non passa per (2[3],0[5]),
la configurazione (2[3],5[5]).

Originally posted by gek
scusate qualcuno è riuscito a implementare la funzione mosse(k) in tempo accettabile? più ci penso e più mi sembra np-completo...
grazie

Originally posted by ste182
np-completo?? ma no: se implementi tutto con un grafo, ogni arco avrà peso 1, quindi una visita in ampiezza ti fornisce il sottografo(albero) dei cammini minimi...
:D

Originally posted by palaz
beh.. se non ti crei tutte le soluzioni non puoi fare nulla.. io mi sono creato tutte le possibili soluzioni e da li facevo i calcoli...

Originally posted by palaz
ma no.. non è cosi malato.. a me ha dato 26 in questo progetto solo perche creavo le soluzioni mano a mano che svolgevo le funzioni.. mentre lui avrebbe voluto che rimanessero sempre in memoria per non sprecare il tempo dedicato a generarle dato che son sempre quelle... è impossibile non occupare della memoria... l'importante è non occuparla a cazzo...

Originally posted by palaz
beh ho messo tutto il codice commentato... e una veloce relazione di 4 paginette dove descrivo come prendo l'input come gestisco i comandi e molto sommariamente alcuni costi.. tipo usavo una coda e dicevo che le operazioni costano 1.... ma non me ne ha manco parlato il prof....

Originally posted by francescoo
per ste182:

non so se hai gia risolto..
comunque ha ragione il prof..
perche prima di arrivare li tu hai gia dichiarato altre configurazioni come pericolose..che sono appunto
p 0 5
p 3 0(che pero poi togli facendo - i 3 0)
p 3 5
p 2 0

Originally posted by palaz
beh studi dal libro anche...
tipo: la mia prima domanda è stata: parlami del merge sort... sono partito con lo spiegare come è l'algoritmo...e lui appena ha visto che lo sapevo mi ha fermato e ha iniziato a chiedermi tempi... se ci sono problemi con la memoria.. di quanto cresce.. se è asintotico e perche..
insomma cose di questo tipo...

Originally posted by francescoo
@palaz:
quindi se ho capito bene per deallocare la matrice:
ad esempio ho una matrice di 2 righe e n colonne io l'ho allocata cosi:
matr = malloc ( 2 * sizeof ( int * ) );
for ( r = 0; r < 2; r++ )
{
*(m+r) = malloc ( n * sizeof ( int ) );
}

quindi per deallocarla:

if(mat!=NULL)
{
for ( r = 0; r < 2; r++ )
{
free(mat+r);
}
free(mat);
}

giusto?e un modo per verificare se l'ho deallocata?

Originally posted by francescoo
@ste182:
mi sta venendo un dubbio:

io ho fatto piu o meno come avevi detti tu alla pagina 6..intendo per trovare tutte le possibili configurazioni..
il mio grafo pero alla fine è una lista contenente tutte le configurazioni, ed è come se avessi fatto una visita per ampiezza.
pero non sono liste di adiacenza è un unica lista che ha tutte le configurazioni quindi ad es se io parto da 0[3]0[5] la mia lista sarà composta cosi:
0[3]0[5] ->3[3]0[5]->0[3]5[5]->3[3]5[5]->0[3]3[5]->...
in ogni campo della lista oltre alla matrice con la configurazione relative ci sono due campi int num e int padre quindi poi cosi riesco a trovare secondo le varie richieste anche di stampare il cammino ecc..
funziona tutto perfettamente..
pero secondo te è accettabile?questo puo definirsi come grafo?

Originally posted by willyrs
Ragazzi, ma come l'avete fatto mosse(k)? Io ho fatto un grafo orientato e non pesato, e sia Prim che Dijkstra richiedono il peso...

Originally posted by ste182
orientato? quindi duplichi i nodi contenenti configurazioni uguali?
in quanto ai pesi non servono, ogni arco ha peso 1, quindi il cammino minimo si trova con una visita in ampiezza che ti genera il sottografo dei cammini

Originally posted by ste182
sinceramente non so dirti se si può considerare un grafo in quel modo.. però credo di no perchè un grafo per definizione è un insieme di vertici collegati fra loro con archi.
mettendo tutto su un unica lista è un pò come se dicessi che il primo nodo è adiacente direttamente a tutti gli altri.. però potrebbe anche andare bene eh.. non saprei..

Originally posted by francescoo
quindi dici di implementarlo tramite liste di adiacenza?
o come?
perchè come l'ho fatto io è una lista concatenata effettivamente..
e non riesco a capire ad es come l'ho fatta io il costo quale sarebbe?
n perchè nel caso peggiore la devo scorrere tutta?

Originally posted by asterix07
Torno un attimo sull argomento configurazioni.
Ho la configurazione di partenza memorizzata in una lista bidirezionale:

struct intlist {
struct contenitore c;
struct intlist *next, *prev;
};

(La struttura contenitore è formata da 3 campi int ovvero ID,stato,capacita);

Ora qualcuno mi puo spiegare come posso generare tutte le possibili configurazioni?

Originally posted by BeppeGoal
Ragazzi, vi posto i miei dubbi notturni...
1) Comando configurazione: ho trovato un modo per trovare le 16 combinazioni possibili con 2 contenitori. L'ordine di estrazione è importante? C'è un ordine fisso in cui se li aspetta il prof?
2) nel 1' esempio a pag. 7, quando fa il comando "c 2", non mi tornano la riga 7, 9 e 10. In questo caso partendo da una situazione in cui tutti i contenitori sono pieni, come possono uscire i punti precedenti?
3) nell'istruzione "esiste" ho provato a generare tutte le possibili combinazioni partendo da 2 contenitori, ne ho trovate 16. Con n vasi quante se ne possono trovare? Pensavo, nel caso di 2 contenitori, a 2^2^2, ma mi sembra proprio un azzardo, c'è una regola per capire quante combinazioni è possibile estrarre da n contenitori?

Originally posted by asterix07
@ste182

Quando nel punto 1 dici "se è stato riempito crei un nuovo nodo": il nuovo nodo lo aggiungo alla lista duplicata oppure ad una nuova lista apposita?

code:

    nodi              lista adiacenze
(0[3],0[5])      (3[3],0[5]) (0[3],5[5]) 
(3[3],0[5])      (3[3],5[5]) (0[3],0[5]) (0[3],3[5]) 
(0[3],5[5])      (3[3],5[5]) (0[3],0[5]) (3[3],2[5]) 
(3[3],5[5])      (0[3],5[5]) (3[3],0[5]) 
(0[3],3[5])      (3[3],3[5]) (0[3],5[5]) (0[3],0[5]) (3[3],0[5]) 
(3[3],2[5])      (3[3],5[5]) (0[3],2[5]) (3[3],0[5]) (0[3],5[5]) 
(3[3],3[5])      (3[3],5[5]) (0[3],3[5]) (3[3],0[5]) (1[3],5[5]) 
(0[3],2[5])      (3[3],2[5]) (0[3],5[5]) (0[3],0[5]) (2[3],0[5]) 
(1[3],5[5])      (3[3],5[5]) (0[3],5[5]) (1[3],0[5]) (3[3],3[5]) 
(2[3],0[5])      (3[3],0[5]) (2[3],5[5]) (0[3],0[5]) (0[3],2[5]) 
(1[3],0[5])      (3[3],0[5]) (1[3],5[5]) (0[3],0[5]) (0[3],1[5]) 
(2[3],5[5])      (3[3],5[5]) (0[3],5[5]) (2[3],0[5]) (3[3],4[5]) 
(0[3],1[5])      (3[3],1[5]) (0[3],5[5]) (0[3],0[5]) (1[3],0[5]) 
(3[3],4[5])      (3[3],5[5]) (0[3],4[5]) (3[3],0[5]) (2[3],5[5]) 
(3[3],1[5])      (3[3],5[5]) (0[3],1[5]) (3[3],0[5]) (0[3],4[5]) 
(0[3],4[5])      (3[3],4[5]) (0[3],5[5]) (0[3],0[5]) (3[3],1[5])

Originally posted by loreste
#ste82 potresti spiegarmi come fai i seguenti passi della lista?
(0[3],0[5]) situazione inizile questo è chiaro
(3[3],0[5]) R1 prima operazione elementare
(0[3],5[5]) qua esegui S1 e R2??? sono 2 operazioni
(3[3],5[5]) qua esegui R1

non capisco se partendo da (0[3],0[5]) il successivo deve essere l'aggiunta di una sola operazione elementare, quindi non mi è chiaro come da (3[3],0[5]) arrivi a (0[3],5[5]) con una sola operazione elementare