Advertisement
daniele2013

esercizi asd

Feb 11th, 2016
77
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. -grafo
  2. 25-06-2012
  3. 11-09-2015
  4. 22-09-2011
  5. 20-02-2015
  6. 24-06-2013
  7. 14-02-2013
  8. 17-07-2015
  9. -albero
  10. 01-31-2013
  11. 11-09-2015
  12. 14-02-2013
  13. 14-06-2013
  14.  
  15.  
  16. prova asd 2011-09
  17. Albero
  18. Algo2(t,x,p,k1,k2)
  19. int u=0,v=0;
  20. if(t)
  21. if(t.k >= k1 and t.k <= t.k)
  22. u=Algo(t.sx,x,t,k1,k2)
  23. v=Algo(t.dx,x,t,k1,k2)
  24.  
  25. if( (u+v)>=x and (t.k%2==0) )
  26. if(p)
  27. if(p.sx==t)
  28. p.sx=cancella(t)
  29. else p.dx=cancella(t)
  30. else return -1;
  31. return u+v+1
  32.  
  33. return u+v;
  34. endAlgo2
  35. Algo1(x,k1,k2,t)
  36. if(Algo2(t,null,x,k1,k2)==-1)//cancella la radice dell'albero
  37. t=cancella(t)
  38. endAlgo1
  39.  
  40. Grafo
  41. DSF(G:grafo)
  42. bool prosegui=false
  43. for each vertice u E V
  44. do colore[u]= Bianco
  45.  
  46. pred[u]= NIL
  47.  
  48. for each vertice u E V and !prosegui
  49. if colore[u]= Bianco
  50. prosegui=DFS-Visita(G,u,pred);
  51. if(prosegui)
  52. stampaPercorso(G,s,v,pred)
  53.  
  54. endDsf
  55. DSF-Visita(G:grafo,u:vertice,pred[]:vertice) : bool
  56. bool cicloTrovato=false;
  57. colore[u]=Grigio
  58.  
  59. for each vertice v E Adiac[u] and !cicloTrovato
  60. if colore[v]= Bianco
  61. pred[v]= u
  62. cicloTrovato=DFS-Visit(G,v,pred)
  63. else if(colore[v]=grigio)
  64. return true;
  65.  
  66. colore[u]=Nero
  67.  
  68. return cicloTrovato
  69. endDfsVisit
  70.  
  71. stampaPercorso(G:grafo,s:vertice,v:vertice,pred[]:vertice
  72. if(v==s)
  73. print s
  74. else
  75. stampaPercorso(G,s,pred[v],pred)
  76. print v
  77.  
  78. grafo 26-06-2014
  79.  
  80. Grafo
  81. DSF(G:grafo,v:vertice)
  82. //Crea e alloca Grafo G'
  83. for each vertice u E V
  84. do colore[u]= Bianco
  85.  
  86. G'.V'=G.V
  87. DFS-Visita(G,v,G');
  88.  
  89. endDsf
  90. DSF-Visita(G:grafo,u:vertice,G':Grafo)
  91.  
  92. colore[u]=Grigio
  93.  
  94. for each vertice v E Adiac[u]
  95.  
  96. if (colore[v]= Bianco or colore[v] = Nero)
  97. G'.Adj[u]=Insert(u,v);
  98.  
  99. if(colore[v]= Bianco)
  100. DFS-Visit(G,v,G')
  101.  
  102. colore[u]=Nero
  103.  
  104. endDfsVisit
  105.  
  106. grafo 11-09-2015
  107. DFS(G,r)
  108. boolean continua = true
  109. int n = r.size,i;
  110. i=n-1
  111. foreach v in V
  112. c[v]=nero
  113. foreach v in r
  114. c[v]=bianco
  115.  
  116. while(i>=0 and continua==true){
  117. if(c[r[i]]==bianco)
  118. dfs_visit(G,r[i])
  119. else
  120. continua = false
  121. i=i-1;
  122. }
  123.  
  124. if(continua==true)
  125. print("r è ordinamento topologico)
  126. else print("r non è ordinamento topologico)
  127. end DFS
  128.  
  129. dfs_visit(G,v)
  130. c[v]=grigio
  131. foreach u in Adj(v)
  132. if(c[u]==bianco)
  133. dfs_visit(G,u)
  134.  
  135. c[v]=nero
  136. endDfs
  137.  
  138. albero 25-06-2012
  139. algo(t,x,k1,k2,p)
  140. int sx=0,dx=0,h=0
  141. if(t)
  142. if(t.k<=k1)
  143. sx=algo(t.sx,x,k1,k2,t)
  144. dx=algo(t.dx,x,k1,k2,t)
  145. else if(t.k<=k2)
  146. sx=algo(t.sx,x,k1,k2,t)
  147. dx=algo(t.dx,x,k1,k2,t)
  148.  
  149. h=sx+sx+1
  150.  
  151. if(h<=x)
  152. if(p)
  153. if(p.sx=t)
  154. p.sx=cancella(t)
  155. else p.dx=cancella(t)
  156. return h
  157.  
  158. albero 2013 01 31
  159. algo(t,k1,k2,a[],x)
  160. i=0;
  161. if(t)
  162. if(t.k>=k1)
  163. i=algo(t.sx,k1,k2,a[],x)
  164.  
  165. if(t.k>=k1 and t.k<=k2)
  166. a[i]=t.k
  167. i=i+1
  168. x=i;
  169. i=algo(t.dx,k1,k2,a[],i)
  170.  
  171.  
  172. return x;
  173.  
  174. grafo 20-02-2015
  175.  
  176. SUCCO : Trasponi grafo,color i vertici di X neri cosi da non andarci a finire sopra.
  177. Fai BFS per ogni vertice di X, quando incontri vertice bianco se la sua
  178. distanza dalla sorgente è < k allora signfica che esiste un percorso tale
  179. che non rispetti la proprietà di essere lungo > k, quindi inserisce in lista
  180. solamente quei vertici che quando vengono scoperti(bianchi) hanno dist[k]>k
  181.  
  182. Algo(G,X,k)
  183. //Crea lista array L
  184. GT=TrasponiGrafo(G)
  185. foreach x in V
  186. c[v]=b
  187. foreach x in X
  188. c[x]=n
  189.  
  190. foreach x in X
  191. L=BFS(G,x,k,L)
  192. end Algo
  193.  
  194. BFS(G,s,k,L) : List
  195. //crea array distanze dist[]
  196. dist[s]=0
  197. Q=ins(s)
  198. while(Q){
  199. u=estrai(Q)
  200. foreach i in V
  201. if(c[i]=b)
  202. c[i]=g;
  203. dist[i]=dist[u]+1;
  204. if(dist[i]>k)
  205. L=ins(i)
  206. }
  207. return L;
  208. endBFS
  209.  
  210. albero 11-09-2012
  211.  
  212. main(h1,h2,n1,n2)
  213. int n = algo(t,null,h1,h2,n1,n2,k,0)
  214.  
  215. if((n1<=n<=n2) and (h1<=0<h2) and (t.k%2==0))
  216. t=cancella(t)
  217. end main
  218.  
  219. Algo(t,p,h1,h2,n1,n2,k,depth)
  220. int sx=0,dx=0,d=0;
  221. if(t)
  222. if(t.k>=k)
  223. sx=Algo(t.sx,t,h1,h2,k,x+1)
  224. else
  225. sx=Algo(t.sx,t,h1,h2,k,x+1)
  226. dx=Algo(t.dx,t,h1,h2,k,x+1)
  227.  
  228. d=sx+dx
  229. if((h1<= x <=h2) and (n1<= d <= n2) and (t.k%2==0))
  230. if(p)
  231. if(p.sx=t)
  232. p.sx=cancella(t)
  233. else p.dx=cancella(t)
  234.  
  235. d=d+1
  236.  
  237. return d
  238. end algo
  239.  
  240. 25-06-2012
  241.  
  242. IDEA : Marcare di colore rosso i vertici di A che NON vengono raggiunti da nessun
  243. vrtice di B tramite un percorso lungo più di K. Al termine dell'algoritmo
  244. se c'è almeno un vertice di A ancora rosso allora la distanza di A da B non è k
  245. Nello specifico ,sia k la distanza data in input:
  246. Trasponi il grafo, colora A di verde all'iniziio,B di nero e il resto bianco.
  247. Lancia una bfs su ogni vertice di B. Durante una qualsiasi visita da un vertice
  248.  
  249. x di B appena
  250. trovo un vertice di A la prima volta (sarà verde) succede che:
  251. 1)lo coloro di rosso se dista da x meno di k e lo inserisco in coda
  252.  
  253. Q.Questo
  254. vertice verrà confrontato con gli altri di B al fine di verificare se
  255.  
  256. almeno
  257. uno dei B lo raggiunge in un percorso >k.
  258. altrimenti
  259. 2)se dista >k da x ho verificato la proprietà (esiste un b per a tale
  260.  
  261. che D(a,b)>k)
  262. quindi lo coloro di grigio e tale vertice prosegue normale la sua vita
  263.  
  264. fino a diventare nero.
  265.  
  266. Mentre data un'altra qualsiasi iterazione con un altro vertice x' di B,se
  267.  
  268. incontro un vertice di A
  269. già visitato in passato (quindi rosso) si ha che Grazie al punto 1) il vertice
  270.  
  271. da verde è passato a rosso ed è stato inserito in coda,
  272. dunque i suoi adiacenti sono stati già controllati (grazie a questo giochetto
  273.  
  274. dei 2 colori evito reiserimenti inutili) e quindi
  275. può succedere che :
  276. 3)se stavolta la distanza dai lui ad x' è >k, esso viene colorato
  277.  
  278. direttamente di nero e finisce la sua vita.
  279. altrimenti
  280. 4)resta rosso, in attesa di un successivo controllo sulla distanza tra
  281.  
  282. lui ed un altro vertice di B
  283.  
  284. Per qualsiasi altro vertice di A invece, esso viene trattato
  285.  
  286. normalmente,colorato di grigio e inserito in coda per
  287. esplorare i suoi vertici.
  288. Al termine viene fatto uno scorrimento della lista di A, se c'è ancora un rosso
  289.  
  290. allora nessun B lo raggiungeva tramite percorso
  291. >k e quindi FALSO.
  292.  
  293. Algo(G,A,B,k)
  294. //crea array colori c[]
  295. boolean continua = true
  296. GT=TrasponiGrafo(G);
  297.  
  298. foreach x in V
  299. c[v]=bianco
  300. foreach x in A
  301. c[v]=verde
  302. foreach x in B
  303. c[v]=nero
  304.  
  305. foreach x in B
  306. bfs(G,x)
  307.  
  308. foreach x in A and continua
  309. if(c[x]=rosso)
  310. print"A non dista "k" da B
  311. continua=false;
  312.  
  313. end algo
  314. bfs(G,x,k)
  315. dist[x]=0;
  316. Q=ins(x)
  317. while(Q){
  318. u=testa(Q)
  319. foreach i in Adj(x)
  320. dist[i]=dist[u]+1
  321. if(c[i]=bianco)
  322. c[i]=grigio
  323. Q=ins(i)
  324. else if(c[i]=verde or rosso)
  325. if(c[i]=verde and dist[i]>k)
  326. c[i]=grigio
  327. Q=ins(i)
  328. else if(c[i]=verde and dist[i]<k )
  329. c[i]=rosso
  330. Q=ins(i)
  331. else if(c[i]=rosso and dist[i]>k)
  332. c[i]=nero
  333.  
  334. if(c[u]!=rosso)
  335. Decoda(Q)
  336. c[u]=nero
  337.  
  338. }//endwhile
  339. end bfs
  340.  
  341. 22-09-2011
  342.  
  343. IDEA : Utilizzare una BFS per scoprire se ci sono cicli. In caso di ciclo viene
  344.  
  345. utilizzato
  346. l'array dei predecessori per ricostruire il percorso contenente il ciclo.
  347. Nel dettaglio, viene lanciata una BFS su ogni vertice bianco di V.
  348. Durante la visita a partire da una sorgente s può succedere che:
  349. 1)viene incontrato un vertice bianco, si prosegue come di norma nella
  350.  
  351. bfs
  352. oppure
  353. 2)viene incontrato un vertice nero :
  354. 2)in questo caso siamo in un ciclo solamente se la distanza
  355.  
  356. dalla radice s(ricalcolata
  357. per ogni nuova radice) del vertice corrente u (di cui
  358.  
  359. stiamo analizzando gli adiacenti)
  360. e dell'adiacente di u appena estratto (vertice i) è
  361.  
  362. dist[u]>dist[i]
  363. (ovvero poichè u dista da s di più di i, signfica che i
  364.  
  365. è stato scoperto lungo
  366. qusto percorso e dunque è un ciclo).
  367. Infatti nel caso in cui c[i]= nero e dist[u]<dist[i]
  368.  
  369. signfica che siamo in una nuova
  370. bfs da una nuova radice e abbiamo ricalcolato la
  371.  
  372. distanza di i dalla sorgente s per cui
  373. non è un ciclo (arco in avanti)
  374.  
  375. Algo(G)
  376. //crea array colori color[] e pred[] e distanze[]
  377. boolean cicloTrovato = false
  378. foreach x in V
  379. c[x]=bianco
  380. pred[x]=null
  381. dist[x]=infinito
  382.  
  383. foreach x in V and (!cicloTrovato)
  384. if(c[x]=bianco)
  385. cicloTrovato=bfs(G,x,color,pred,dist)
  386.  
  387. if(!cicloTrovato)
  388. "Il grafo è aciclico"
  389.  
  390. end algo
  391.  
  392. bfs(G,s,color,pred):cicloTrovato
  393. boolean cicloTrovato = false
  394. pred[s]=null
  395. dist[s]=0
  396. c[s]=grigio
  397. Q=ins(s)
  398. while(Q){
  399. u=testa(Q)
  400. foreach i in Adj(u) and !cicloTrovato
  401. dist[i]=dist[u]+1
  402. if(c[i]=bianco)
  403. c[i]=grigio
  404. pred[i]=u
  405. Q=ins(Q,i)
  406. else if( (c[i] = nero) and (dist[u]>dist[i]))
  407. cicloTrovato=true;
  408. print"Il grafo contiene un ciclo nel
  409.  
  410. percorso"
  411. print(G,s,u,pred[])
  412.  
  413.  
  414. Decoda(Q)
  415. c[u]=nero
  416. }//endwhile
  417. return cicloTrovato;
  418. end bfs
  419.  
  420. print(G,s,u,pred[])
  421. temp=u
  422. while(temp!=null){//stampa il percorso al contrario :/
  423. print temp
  424. temp=pred[temp;
  425. }
  426. end print
  427.  
  428. albero 11-09-2015
  429. Algo(t,k,p') :int
  430. nodobst p=p',pcand=p',cand=null,temp=t
  431. int ris=0
  432. while(temp and temp.k!=k)
  433. if(temp.k<k)
  434. p=temp
  435. temp=temp.dx
  436. else
  437. if(temp.k%2==0)
  438. pcand=p
  439. cand=temp
  440. p=temp
  441. temp=temp.sx
  442.  
  443. if(cand and temp.dx)
  444. p=temp
  445. temp=temp.dx
  446. while(temp)
  447. if(temp.k%2==0)
  448. pcand=p
  449. cand=temp
  450. p=temp
  451. temp=temp.sx
  452.  
  453. if(pcand and cand)
  454. if(cand=pcand.sx)
  455. pcand.sx=cancella(cand)
  456. else pcand.dx=cancella(cand)
  457. else ris=1
  458.  
  459. return ris
  460. endAlgo
  461. main(t,k)
  462. n=algo(t,k,null)
  463. if(n=1)//successore testa albero
  464. t=cancella(t)
  465.  
  466. grafo 24-06-2013
  467.  
  468. dfs(G,a,b)
  469. boolean trovato = false;
  470. boolean continua = true;
  471. foreach v di V
  472. c[v]=b
  473.  
  474. foreach v di V and !trovato and continua
  475. if(c[v]=b)
  476. trovato=dfs_visit(G,v,a,b)
  477. if((c[a]=nero and c[b]=bianco))
  478. continua=false
  479.  
  480. if(trovato=true)
  481. print "L'arco a b sta in un ciclo"
  482. else print "No"
  483.  
  484. return continua;
  485. end dfs;
  486.  
  487. dfs_visit(G,s,a,b){
  488. boolean trovato = false;
  489. c[s]=g
  490. foreach x in Adj(s) and !trovato
  491. if(c[x]=b)
  492. c[x]=g
  493. trovato=dfs_visit(G,x,a,b)
  494. else if(c[x]=g)
  495. if((c[a]=g and c[b]=g))//Se nel ciclo sono grigi oppure uno dei
  496.  
  497. due
  498. trovato=true;
  499. c[s]=n
  500. return trovato;
  501. }
  502. end dfs_visit
  503.  
  504. grafo 14-02-2013
  505. Algo(G,A,B)
  506. //Crea sottografo G2
  507.  
  508. foreach v in V
  509. c[v]=b
  510.  
  511. foreach v in B
  512. if(c[v]=b)
  513. dfs_visit(G,v)//classica dfs_visit DFS
  514.  
  515.  
  516. GT=TrasponiGrafo(G)
  517.  
  518. foreach v in A
  519. if(c[v]=b)
  520. dfs_visit_mod(GT,G2,v)//dfs_visit modificata
  521. return GT
  522. end Algo;
  523.  
  524. dfs_visit_mod(G,G2,s)
  525. c[s]=g
  526. G2.VertList=ins(G2,s)
  527. foreach v in Adj(s)
  528. if(c[v]=b)
  529. G2.Adj(v)=ins(s)
  530. df_visit_mod(G,G2,v)
  531.  
  532. c[s]n
  533. end dfs_visit_mod
  534.  
  535. TrasponiGrafo(G)
  536. //Crea grafo GT e copia array di G in GT
  537.  
  538. foreach v in V
  539. foreach u in Adj(v)
  540. G2.Adj(u) = insert (u,v)
  541. return GT;
  542. end
  543.  
  544. albero 14-02-2013
  545. Algo(t,a)
  546. int numNodi=0
  547.  
  548. numNodi=creaArray(t,a,0)
  549. t'=bilancia(t',A,0,n)
  550.  
  551. endAlgo
  552.  
  553. bilancia(a,t,t',inf,sup)
  554.  
  555. if(sup>inf)
  556. mid=(inf+sup)/2
  557. t'=creaNodo(a[mid])
  558. t'.sx=bilancia(t'.sx,inf,mid)
  559. t'.dx=bilancia(t'.dx,mid+1,sup)
  560. return t'
  561. and bilancia
  562.  
  563. creaArray(a,t,i)
  564.  
  565. if(t)
  566. indice=creaArray(t.sx,a,i)
  567. a[indice]=t.k
  568. return creaArray(t.dx,a,indice+1)
  569.  
  570. return i;
  571.  
  572. albero 14-06-2013
  573. algo(t,pos,prof,l1,l2,p)
  574. int curind=0,curind2=0;
  575. if(t)
  576. curind=algo(t.sx,pos,prof+1,l1,l2,t)
  577.  
  578. curind2=algo(t.dx,pos,curind+1,l1,l2,t)
  579.  
  580. if(curind%3==0)
  581. if(p)
  582. if(p.sx==t)
  583. p.sx=cancella(t)
  584. else p.dx=cancella(t)
  585.  
  586. pos=curind2;
  587.  
  588. return pos;
  589.  
  590. grafo 17-07-2015
  591. IDEA: Mi sono basato dinuovo sull'idea di cercare un percorso massimale di soli vertici
  592. dispari,quando lo trovo ritorno false a catena e termina l'algoritmo. Durante la visita
  593. quando trovo un vertice pari lo coloro di nero e non scendo a visitare nulla al di
  594.  
  595. sotto
  596. di lui, poichè i percorsi massimali che potrò trovare rispetteranno la proprietà di
  597.  
  598. avere
  599. almeno un vertice pari. Quando invece sono in presenza di un ciclo oppure di un vertice
  600.  
  601. pozzo
  602. ritorno direttamente false, in quanto lui e quelli prima di lui erano tutti dispari.
  603.  
  604. dfs(G,u,VAL)
  605. foreach k in V
  606. c[k]=b
  607.  
  608. if(VAL[u]%2==0 OR dfs_visit(G,u,VAL)==true)
  609. print"Tutti i percorsi massimali contengono un vertice pari"
  610. else print"Esiste almeno un percorso massimale che contiene tutti vertici
  611.  
  612. dispari"
  613. end dfs
  614. dfs_visit(G,s,VAL):BOOLEAN
  615. boolean risp = true
  616. c[s]=g
  617. if(Adj(s)!=NULL)
  618. foreach x in Adj(s) and risp=true
  619. if(c[x]=b)
  620. if(VAL[x]%2!=0)
  621. risp=dfs_visit(G,x,VAL)
  622. else c[x]=n
  623. else if(c[x]=g)
  624. risp=false
  625. else risp=false
  626. c[s]=n
  627. return risp
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement