Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- -grafo
- 25-06-2012
- 11-09-2015
- 22-09-2011
- 20-02-2015
- 24-06-2013
- 14-02-2013
- 17-07-2015
- -albero
- 01-31-2013
- 11-09-2015
- 14-02-2013
- 14-06-2013
- prova asd 2011-09
- Albero
- Algo2(t,x,p,k1,k2)
- int u=0,v=0;
- if(t)
- if(t.k >= k1 and t.k <= t.k)
- u=Algo(t.sx,x,t,k1,k2)
- v=Algo(t.dx,x,t,k1,k2)
- if( (u+v)>=x and (t.k%2==0) )
- if(p)
- if(p.sx==t)
- p.sx=cancella(t)
- else p.dx=cancella(t)
- else return -1;
- return u+v+1
- return u+v;
- endAlgo2
- Algo1(x,k1,k2,t)
- if(Algo2(t,null,x,k1,k2)==-1)//cancella la radice dell'albero
- t=cancella(t)
- endAlgo1
- Grafo
- DSF(G:grafo)
- bool prosegui=false
- for each vertice u E V
- do colore[u]= Bianco
- pred[u]= NIL
- for each vertice u E V and !prosegui
- if colore[u]= Bianco
- prosegui=DFS-Visita(G,u,pred);
- if(prosegui)
- stampaPercorso(G,s,v,pred)
- endDsf
- DSF-Visita(G:grafo,u:vertice,pred[]:vertice) : bool
- bool cicloTrovato=false;
- colore[u]=Grigio
- for each vertice v E Adiac[u] and !cicloTrovato
- if colore[v]= Bianco
- pred[v]= u
- cicloTrovato=DFS-Visit(G,v,pred)
- else if(colore[v]=grigio)
- return true;
- colore[u]=Nero
- return cicloTrovato
- endDfsVisit
- stampaPercorso(G:grafo,s:vertice,v:vertice,pred[]:vertice
- if(v==s)
- print s
- else
- stampaPercorso(G,s,pred[v],pred)
- print v
- grafo 26-06-2014
- Grafo
- DSF(G:grafo,v:vertice)
- //Crea e alloca Grafo G'
- for each vertice u E V
- do colore[u]= Bianco
- G'.V'=G.V
- DFS-Visita(G,v,G');
- endDsf
- DSF-Visita(G:grafo,u:vertice,G':Grafo)
- colore[u]=Grigio
- for each vertice v E Adiac[u]
- if (colore[v]= Bianco or colore[v] = Nero)
- G'.Adj[u]=Insert(u,v);
- if(colore[v]= Bianco)
- DFS-Visit(G,v,G')
- colore[u]=Nero
- endDfsVisit
- grafo 11-09-2015
- DFS(G,r)
- boolean continua = true
- int n = r.size,i;
- i=n-1
- foreach v in V
- c[v]=nero
- foreach v in r
- c[v]=bianco
- while(i>=0 and continua==true){
- if(c[r[i]]==bianco)
- dfs_visit(G,r[i])
- else
- continua = false
- i=i-1;
- }
- if(continua==true)
- print("r è ordinamento topologico)
- else print("r non è ordinamento topologico)
- end DFS
- dfs_visit(G,v)
- c[v]=grigio
- foreach u in Adj(v)
- if(c[u]==bianco)
- dfs_visit(G,u)
- c[v]=nero
- endDfs
- albero 25-06-2012
- algo(t,x,k1,k2,p)
- int sx=0,dx=0,h=0
- if(t)
- if(t.k<=k1)
- sx=algo(t.sx,x,k1,k2,t)
- dx=algo(t.dx,x,k1,k2,t)
- else if(t.k<=k2)
- sx=algo(t.sx,x,k1,k2,t)
- dx=algo(t.dx,x,k1,k2,t)
- h=sx+sx+1
- if(h<=x)
- if(p)
- if(p.sx=t)
- p.sx=cancella(t)
- else p.dx=cancella(t)
- return h
- albero 2013 01 31
- algo(t,k1,k2,a[],x)
- i=0;
- if(t)
- if(t.k>=k1)
- i=algo(t.sx,k1,k2,a[],x)
- if(t.k>=k1 and t.k<=k2)
- a[i]=t.k
- i=i+1
- x=i;
- i=algo(t.dx,k1,k2,a[],i)
- return x;
- grafo 20-02-2015
- SUCCO : Trasponi grafo,color i vertici di X neri cosi da non andarci a finire sopra.
- Fai BFS per ogni vertice di X, quando incontri vertice bianco se la sua
- distanza dalla sorgente è < k allora signfica che esiste un percorso tale
- che non rispetti la proprietà di essere lungo > k, quindi inserisce in lista
- solamente quei vertici che quando vengono scoperti(bianchi) hanno dist[k]>k
- Algo(G,X,k)
- //Crea lista array L
- GT=TrasponiGrafo(G)
- foreach x in V
- c[v]=b
- foreach x in X
- c[x]=n
- foreach x in X
- L=BFS(G,x,k,L)
- end Algo
- BFS(G,s,k,L) : List
- //crea array distanze dist[]
- dist[s]=0
- Q=ins(s)
- while(Q){
- u=estrai(Q)
- foreach i in V
- if(c[i]=b)
- c[i]=g;
- dist[i]=dist[u]+1;
- if(dist[i]>k)
- L=ins(i)
- }
- return L;
- endBFS
- albero 11-09-2012
- main(h1,h2,n1,n2)
- int n = algo(t,null,h1,h2,n1,n2,k,0)
- if((n1<=n<=n2) and (h1<=0<h2) and (t.k%2==0))
- t=cancella(t)
- end main
- Algo(t,p,h1,h2,n1,n2,k,depth)
- int sx=0,dx=0,d=0;
- if(t)
- if(t.k>=k)
- sx=Algo(t.sx,t,h1,h2,k,x+1)
- else
- sx=Algo(t.sx,t,h1,h2,k,x+1)
- dx=Algo(t.dx,t,h1,h2,k,x+1)
- d=sx+dx
- if((h1<= x <=h2) and (n1<= d <= n2) and (t.k%2==0))
- if(p)
- if(p.sx=t)
- p.sx=cancella(t)
- else p.dx=cancella(t)
- d=d+1
- return d
- end algo
- 25-06-2012
- IDEA : Marcare di colore rosso i vertici di A che NON vengono raggiunti da nessun
- vrtice di B tramite un percorso lungo più di K. Al termine dell'algoritmo
- se c'è almeno un vertice di A ancora rosso allora la distanza di A da B non è k
- Nello specifico ,sia k la distanza data in input:
- Trasponi il grafo, colora A di verde all'iniziio,B di nero e il resto bianco.
- Lancia una bfs su ogni vertice di B. Durante una qualsiasi visita da un vertice
- x di B appena
- trovo un vertice di A la prima volta (sarà verde) succede che:
- 1)lo coloro di rosso se dista da x meno di k e lo inserisco in coda
- Q.Questo
- vertice verrà confrontato con gli altri di B al fine di verificare se
- almeno
- uno dei B lo raggiunge in un percorso >k.
- altrimenti
- 2)se dista >k da x ho verificato la proprietà (esiste un b per a tale
- che D(a,b)>k)
- quindi lo coloro di grigio e tale vertice prosegue normale la sua vita
- fino a diventare nero.
- Mentre data un'altra qualsiasi iterazione con un altro vertice x' di B,se
- incontro un vertice di A
- già visitato in passato (quindi rosso) si ha che Grazie al punto 1) il vertice
- da verde è passato a rosso ed è stato inserito in coda,
- dunque i suoi adiacenti sono stati già controllati (grazie a questo giochetto
- dei 2 colori evito reiserimenti inutili) e quindi
- può succedere che :
- 3)se stavolta la distanza dai lui ad x' è >k, esso viene colorato
- direttamente di nero e finisce la sua vita.
- altrimenti
- 4)resta rosso, in attesa di un successivo controllo sulla distanza tra
- lui ed un altro vertice di B
- Per qualsiasi altro vertice di A invece, esso viene trattato
- normalmente,colorato di grigio e inserito in coda per
- esplorare i suoi vertici.
- Al termine viene fatto uno scorrimento della lista di A, se c'è ancora un rosso
- allora nessun B lo raggiungeva tramite percorso
- >k e quindi FALSO.
- Algo(G,A,B,k)
- //crea array colori c[]
- boolean continua = true
- GT=TrasponiGrafo(G);
- foreach x in V
- c[v]=bianco
- foreach x in A
- c[v]=verde
- foreach x in B
- c[v]=nero
- foreach x in B
- bfs(G,x)
- foreach x in A and continua
- if(c[x]=rosso)
- print"A non dista "k" da B
- continua=false;
- end algo
- bfs(G,x,k)
- dist[x]=0;
- Q=ins(x)
- while(Q){
- u=testa(Q)
- foreach i in Adj(x)
- dist[i]=dist[u]+1
- if(c[i]=bianco)
- c[i]=grigio
- Q=ins(i)
- else if(c[i]=verde or rosso)
- if(c[i]=verde and dist[i]>k)
- c[i]=grigio
- Q=ins(i)
- else if(c[i]=verde and dist[i]<k )
- c[i]=rosso
- Q=ins(i)
- else if(c[i]=rosso and dist[i]>k)
- c[i]=nero
- if(c[u]!=rosso)
- Decoda(Q)
- c[u]=nero
- }//endwhile
- end bfs
- 22-09-2011
- IDEA : Utilizzare una BFS per scoprire se ci sono cicli. In caso di ciclo viene
- utilizzato
- l'array dei predecessori per ricostruire il percorso contenente il ciclo.
- Nel dettaglio, viene lanciata una BFS su ogni vertice bianco di V.
- Durante la visita a partire da una sorgente s può succedere che:
- 1)viene incontrato un vertice bianco, si prosegue come di norma nella
- bfs
- oppure
- 2)viene incontrato un vertice nero :
- 2)in questo caso siamo in un ciclo solamente se la distanza
- dalla radice s(ricalcolata
- per ogni nuova radice) del vertice corrente u (di cui
- stiamo analizzando gli adiacenti)
- e dell'adiacente di u appena estratto (vertice i) è
- dist[u]>dist[i]
- (ovvero poichè u dista da s di più di i, signfica che i
- è stato scoperto lungo
- qusto percorso e dunque è un ciclo).
- Infatti nel caso in cui c[i]= nero e dist[u]<dist[i]
- signfica che siamo in una nuova
- bfs da una nuova radice e abbiamo ricalcolato la
- distanza di i dalla sorgente s per cui
- non è un ciclo (arco in avanti)
- Algo(G)
- //crea array colori color[] e pred[] e distanze[]
- boolean cicloTrovato = false
- foreach x in V
- c[x]=bianco
- pred[x]=null
- dist[x]=infinito
- foreach x in V and (!cicloTrovato)
- if(c[x]=bianco)
- cicloTrovato=bfs(G,x,color,pred,dist)
- if(!cicloTrovato)
- "Il grafo è aciclico"
- end algo
- bfs(G,s,color,pred):cicloTrovato
- boolean cicloTrovato = false
- pred[s]=null
- dist[s]=0
- c[s]=grigio
- Q=ins(s)
- while(Q){
- u=testa(Q)
- foreach i in Adj(u) and !cicloTrovato
- dist[i]=dist[u]+1
- if(c[i]=bianco)
- c[i]=grigio
- pred[i]=u
- Q=ins(Q,i)
- else if( (c[i] = nero) and (dist[u]>dist[i]))
- cicloTrovato=true;
- print"Il grafo contiene un ciclo nel
- percorso"
- print(G,s,u,pred[])
- Decoda(Q)
- c[u]=nero
- }//endwhile
- return cicloTrovato;
- end bfs
- print(G,s,u,pred[])
- temp=u
- while(temp!=null){//stampa il percorso al contrario :/
- print temp
- temp=pred[temp;
- }
- end print
- albero 11-09-2015
- Algo(t,k,p') :int
- nodobst p=p',pcand=p',cand=null,temp=t
- int ris=0
- while(temp and temp.k!=k)
- if(temp.k<k)
- p=temp
- temp=temp.dx
- else
- if(temp.k%2==0)
- pcand=p
- cand=temp
- p=temp
- temp=temp.sx
- if(cand and temp.dx)
- p=temp
- temp=temp.dx
- while(temp)
- if(temp.k%2==0)
- pcand=p
- cand=temp
- p=temp
- temp=temp.sx
- if(pcand and cand)
- if(cand=pcand.sx)
- pcand.sx=cancella(cand)
- else pcand.dx=cancella(cand)
- else ris=1
- return ris
- endAlgo
- main(t,k)
- n=algo(t,k,null)
- if(n=1)//successore testa albero
- t=cancella(t)
- grafo 24-06-2013
- dfs(G,a,b)
- boolean trovato = false;
- boolean continua = true;
- foreach v di V
- c[v]=b
- foreach v di V and !trovato and continua
- if(c[v]=b)
- trovato=dfs_visit(G,v,a,b)
- if((c[a]=nero and c[b]=bianco))
- continua=false
- if(trovato=true)
- print "L'arco a b sta in un ciclo"
- else print "No"
- return continua;
- end dfs;
- dfs_visit(G,s,a,b){
- boolean trovato = false;
- c[s]=g
- foreach x in Adj(s) and !trovato
- if(c[x]=b)
- c[x]=g
- trovato=dfs_visit(G,x,a,b)
- else if(c[x]=g)
- if((c[a]=g and c[b]=g))//Se nel ciclo sono grigi oppure uno dei
- due
- trovato=true;
- c[s]=n
- return trovato;
- }
- end dfs_visit
- grafo 14-02-2013
- Algo(G,A,B)
- //Crea sottografo G2
- foreach v in V
- c[v]=b
- foreach v in B
- if(c[v]=b)
- dfs_visit(G,v)//classica dfs_visit DFS
- GT=TrasponiGrafo(G)
- foreach v in A
- if(c[v]=b)
- dfs_visit_mod(GT,G2,v)//dfs_visit modificata
- return GT
- end Algo;
- dfs_visit_mod(G,G2,s)
- c[s]=g
- G2.VertList=ins(G2,s)
- foreach v in Adj(s)
- if(c[v]=b)
- G2.Adj(v)=ins(s)
- df_visit_mod(G,G2,v)
- c[s]n
- end dfs_visit_mod
- TrasponiGrafo(G)
- //Crea grafo GT e copia array di G in GT
- foreach v in V
- foreach u in Adj(v)
- G2.Adj(u) = insert (u,v)
- return GT;
- end
- albero 14-02-2013
- Algo(t,a)
- int numNodi=0
- numNodi=creaArray(t,a,0)
- t'=bilancia(t',A,0,n)
- endAlgo
- bilancia(a,t,t',inf,sup)
- if(sup>inf)
- mid=(inf+sup)/2
- t'=creaNodo(a[mid])
- t'.sx=bilancia(t'.sx,inf,mid)
- t'.dx=bilancia(t'.dx,mid+1,sup)
- return t'
- and bilancia
- creaArray(a,t,i)
- if(t)
- indice=creaArray(t.sx,a,i)
- a[indice]=t.k
- return creaArray(t.dx,a,indice+1)
- return i;
- albero 14-06-2013
- algo(t,pos,prof,l1,l2,p)
- int curind=0,curind2=0;
- if(t)
- curind=algo(t.sx,pos,prof+1,l1,l2,t)
- curind2=algo(t.dx,pos,curind+1,l1,l2,t)
- if(curind%3==0)
- if(p)
- if(p.sx==t)
- p.sx=cancella(t)
- else p.dx=cancella(t)
- pos=curind2;
- return pos;
- grafo 17-07-2015
- IDEA: Mi sono basato dinuovo sull'idea di cercare un percorso massimale di soli vertici
- dispari,quando lo trovo ritorno false a catena e termina l'algoritmo. Durante la visita
- quando trovo un vertice pari lo coloro di nero e non scendo a visitare nulla al di
- sotto
- di lui, poichè i percorsi massimali che potrò trovare rispetteranno la proprietà di
- avere
- almeno un vertice pari. Quando invece sono in presenza di un ciclo oppure di un vertice
- pozzo
- ritorno direttamente false, in quanto lui e quelli prima di lui erano tutti dispari.
- dfs(G,u,VAL)
- foreach k in V
- c[k]=b
- if(VAL[u]%2==0 OR dfs_visit(G,u,VAL)==true)
- print"Tutti i percorsi massimali contengono un vertice pari"
- else print"Esiste almeno un percorso massimale che contiene tutti vertici
- dispari"
- end dfs
- dfs_visit(G,s,VAL):BOOLEAN
- boolean risp = true
- c[s]=g
- if(Adj(s)!=NULL)
- foreach x in Adj(s) and risp=true
- if(c[x]=b)
- if(VAL[x]%2!=0)
- risp=dfs_visit(G,x,VAL)
- else c[x]=n
- else if(c[x]=g)
- risp=false
- else risp=false
- c[s]=n
- return risp
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement