Esercizio 10.* Un cassiere vuole dare un resto di n centesimi di euro usando il minimo numero di monete. a) Descrivere un algoritmo goloso per fare ciò.

Slides:



Advertisements
Presentazioni simili
Strutture dati per insiemi disgiunti
Advertisements

INFORMATICA Algoritmi fondamentali
Informatica Generale Susanna Pelagatti
Process synchronization
1 2 OSSERVA LA SEGUENTE POTENZA 4 2 = 16 IMMAGINIAMO CHE UN DATO SIA SCONOSCIUTO E LO INDICHIAMO CON LA LETTERA X.
Algoritmi e Programmazione
Informatica Generale Marzia Buscemi
Algoritmi e Strutture Dati
Elettrostatica 3 23 maggio 2011
esponente del radicando
Cammini minimi con una sorgente
Hash Tables Indirizzamento diretto Tabelle Hash Risoluzioni di collisioni Indirizzamento aperto.
Alberi binari di ricerca
1 Istruzioni, algoritmi, linguaggi. 2 Algoritmo per il calcolo delle radici reali di unequazione di 2 o grado Data lequazione ax 2 +bx+c=0, quali sono.
Cammini minimi con sorgente singola
Introduzione agli algoritmi. Definizione Sistema di regole e procedure di calcolo ben definite che portano alla soluzione di un problema con un numero.
Camil Demetrescu, Irene Finocchi, Giuseppe F. ItalianoAlgoritmi e strutture dati Copyright © The McGraw - Hill Companies, srl 1 Usa la tecnica del.
Camil Demetrescu, Irene Finocchi, Giuseppe F. ItalianoAlgoritmi e strutture dati Copyright © The McGraw - Hill Companies, srl 1 Usa la tecnica del.
Iterazione enumerativa (for)
Algoritmi Politecnico di Milano C Primi programmi Politecnico di Milano.
DIPARTIMENTO DI ELETTRONICA E INFORMAZIONE Puntatori Marco D. Santambrogio – Ver. aggiornata al 21 Marzo 2013.
DIPARTIMENTO DI ELETTRONICA E INFORMAZIONE Costrutti iterativi Marco D. Santambrogio – Ver. aggiornata al 20 Marzo 2013.
DIPARTIMENTO DI ELETTRONICA E INFORMAZIONE Costrutti iterativi Marco D. Santambrogio – Ver. aggiornata al 9 Agosto 2013.
U V U V (a) |cfc|=2 prima e dopo (b) |cfc|=2 prima e |cfc|=1 dopo
Algoritmo di Ford-Fulkerson
Camil Demetrescu, Irene Finocchi, Giuseppe F. ItalianoAlgoritmi e strutture dati Algoritmi e Strutture Dati Capitolo 2 Modelli di calcolo e metodologie.
Capitolo 9 Il problema della gestione di insiemi disgiunti (Union-find) Algoritmi e Strutture Dati.
Camil Demetrescu, Irene Finocchi, Giuseppe F. ItalianoAlgoritmi e strutture dati Algoritmi e Strutture Dati Capitolo 2 Modelli di calcolo e metodologie.
1 Corso di Informatica (Programmazione) Lezione 10 (12 novembre 2008) Programmazione in Java: espressioni booleane e controllo del flusso (selezione)
NUMERI RELATIVI.
Algoritmi e Strutture Dati (Mod. B)
DAL PROBLEMA ALL'ALGORITMO Problemi e Programmi Paolo Amico
memoria gestita staticamente:
Strutture di controllo in C -- Flow Chart --
Programmazione in Java Claudia Raibulet
Fibonacci Heaps e il loro utilizzo nell’algoritmo di Prim
Tavole dinamiche Spesso non si sa a priori quanta memoria serve per memorizzare dei dati in un array, in una tavola hash, in un heap, ecc. Può capitare.
Anche la RB-Delete ha due fasi: Nella prima viene tolto un nodo y avente uno dei sottoalberi vuoto sostituendolo con la radice dellaltro sottoalbero. Per.
Elementi di Informatica di base
CODIFICA Da flow-chart a C++.
Strutture dati per insiemi disgiunti
Radix-Sort(A,d) // A[i] = cd...c2c1
Lezione 6 Strutture di controllo Il condizionale
Vedremo in seguito che (n log n) è un limite stretto per il problema dellordinamento. Per ora ci limitiamo a dimostrare che: La complessità nel caso pessimo.
Ispezione lineare La funzione hash h(k,i) si ottiene da una funzione hash ordinaria h'(k) ponendo L’esplorazione inizia dalla cella h(k,0) = h'(k) e continua.
RB-insert(T, z) // z.left = z.right = T.nil Insert(T, z) z.color = RED // z è rosso. Lunica violazione // possibile delle proprietà degli alberi // rosso-neri.
Per valutare la complessità ammortizzata scomponiamo ogni Union: nelle due FindSet e nella Link che la costituiscono e valuteremo la complessità in funzione.
La complessità media O(n log n) di Quick-Sort vale soltanto se tutte le permutazioni dell’array in ingresso sono ugualmente probabili. In molte applicazioni.
Capitolo 3 Strutture dati elementari Algoritmi e Strutture Dati Camil Demetrescu, Irene Finocchi, Giuseppe F. Italiano.
14 marzo 2002 Avvisi:.
Sistemi e Tecnologie Informatiche Ricorsione Umberto Ferraro Petrillo.
Valutare la difficoltà dei problemi
Complessità del problema Se non facciamo ipotesi sul tipo degli elementi della sequenza le uniche operazioni permesse sono confronti e assegnazioni. Problema.
Implementazione di dizionari Problema del dizionario dinamico Scegliere una struttura dati in cui memorizzare dei record con un campo key e alcuni altri.
La ricorsione.
Esercitazione su Vector. Permette di definire collezioni di dati generiche, che sono in grado di memorizzare elementi di ogni sottotipo di Object Definito.

Fondamenti di Informatica 2 Ingegneria Informatica Docente: Giovanni Macchia a.a
Risoluzione delle collisioni con indirizzamento aperto Con la tecnica di indirizzamento aperto tutti gli elementi stanno nella tavola. La funzione hash.
Algoritmi e Strutture Dati Strutture Dati Elementari.
Ordinamento in tempo lineare Il limite inferiore Ω(n log n) vale per tutti gli algoritmi di ordinamento generali, ossia per algoritmi che non fanno alcuna.
1 Fabio Scotti – Università degli Studi di Milano Fabio Scotti ( ) Laboratorio di programmazione per la sicurezza Valentina Ciriani ( )
1 Analisi ammortizzata Si considera il tempo richiesto per eseguire, nel caso pessimo, una intera sequenza di operazioni. Se le operazioni costose sono.
Rappresentazioni a lunghezza fissa: problemi
Rappresentazione dell'informazione
Esercizi.
Conversione binario-ottale/esadecimale
I sistemi di numerazione
La numerazione ottale. Il sistema di numerazione ottale ha ampio utilizzo in informatica E’ un sistema di numerazione posizionale La base è 8 Il sistema.
Prof.ssa Rossella Petreschi Lezione del 3 /10/2012 del Corso di Algoritmi e Strutture Dati Riferimenti: Capitolo 18 del testo Cormen, Leiserson, Rivest.
Transcript della presentazione:

Esercizio 10.* Un cassiere vuole dare un resto di n centesimi di euro usando il minimo numero di monete. a) Descrivere un algoritmo goloso per fare ciò con tagli da 1¢, 2¢, 5¢, 10¢, 20¢, 50¢, 1€ e 2€. b) Dimostrare che l’algoritmo goloso funziona anche con monete di tagli 1,c,c2,...,ck dove c > 1 e k ≥ 0. c) Trovare un insieme di tagli di monete per i quali l’algoritmo goloso non funziona.

Analisi ammortizzata Si considera il tempo richiesto per eseguire, nel caso pessimo, una intera sequenza di operazioni. Se le operazioni costose sono relativamente meno frequenti allora il costo richiesto per eseguirle può essere ammortizzato con l’esecuzione delle operazioni meno costose.

Metodo dell’aggregazione Si calcola la complessità O(f(n)) dell’esecuzione di una sequenza di n operazioni nel caso pessimo. Il costo ammortizzato della singola operazione si ottiene dividendo per n tale complessità ottenendo O(f(n)/n) In questo modo viene attribuito lo stesso costo ammortizzato a tutte le operazioni. Illustriamo il metodo con due esempi:

operazioni su di una pila Sia P una pila con operazioni: Push(P,x) // aggiunge x alla pila P Pop(P) // toglie il primo elemento dalla pila Top(P) // restituisce il primo elemento di P // (senza toglierlo) Empty(P) // ritorna true se la pila è vuota a cui aggiungiamo: MultiPop(P, k) while not Empty(P) and k > 0 Pop(P), k = k-1 che toglie i primi k elementi, oppure vuota la pila se ci sono meno di k elementi

Se la pila contiene m elementi il ciclo while viene iterato min(m,k) volte e quindi MultiPop ha complessità O(min(m,k)). Consideriamo una sequenza di n operazioni eseguite a partire dalla pila vuota. L’operazione più costosa MultiPop richiede tempo O(n) nel caso pessimo. Moltiplicando per n otteniamo il limite superiore O(n2) per il costo della sequenza di n operazioni.

Il metodo dell’aggregazione fornisce un limite più stretto. Un elemento può essere tolto dalla pila soltanto dopo che è stato inserito! Quindi il numero di operazioni Pop, comprese quelle interne alle MultiPop, non può superare il numero totale di operazioni Push ed è quindi minore di n.

Se dal tempo richiesto per eseguire MultiPop togliamo il tempo per le iterazioni del ciclo while rimane un tempo costante. Quindi il tempo richiesto per eseguire l’intera sequenza di n operazioni è O(n) più il tempo richiesto per eseguire tutte le iterazioni dei cicli while interni alle operazioni MultiPop presenti nella sequenza.

Siccome una iterazione richiede tempo costante e il numero totale di iterazioni è minore di n, l’esecuzione di tutte le iterazioni del ciclo while richiede tempo totale O(n). Il costo dell’intera sequenza di operazioni è quindi O(n) e pertanto il costo ammortizzato di ciascuna operazione è O(n)/n = O(1).

Incremento di un contatore binario Implementiamo un contatore binario di k bit con un array di bit A[0..k-1] Un numero binario x registrato in A ha il bit meno significativo in A[0] e il più significativo in A[k-1] per cui

Supponiamo che A venga usato per contare a partire da x = 0 usando l’operazione di incremento: Increment(A) i = 0 while i < k and A[i] == 1 A[i] = 0 i = i +1 if i < k A[i] = 1

Una singola operazione di incremento richiede tempo O(k) nel caso pessimo il che fornisce un limite superiore O(nk) per una sequenza di n incrementi. Possiamo però osservare che il tempo necessario ad eseguire l’intera sequenza è proporzionale al numero di bit che vengono modificati. Quanti bit vengono modificati in totale? Vediamo cosa succede con un contatore di k = 8 bit.

3 0 0 0 0 0 0 1 1 4 2 0 0 0 0 0 0 1 0 3 1 0 0 0 0 0 0 0 1 1 4 0 0 0 0 0 1 0 0 7 5 0 0 0 0 0 1 0 1 8 7 0 0 0 0 0 1 1 1 11 6 0 0 0 0 0 1 1 0 10 x A[7] A[6] A[5] A[4] A[3] A[2] A[1] A[0] costo 0 0 0 0 0 0 0 0 0 0 16 0 0 0 1 0 0 0 0 31 14 0 0 0 0 1 1 1 0 25 10 0 0 0 0 1 0 1 0 18 9 0 0 0 0 1 0 0 1 16 13 0 0 0 0 1 1 0 1 23 11 0 0 0 0 1 0 1 1 19 15 0 0 0 0 1 1 1 1 26 12 0 0 0 0 1 1 0 0 22 8 0 0 0 0 1 0 0 0 15

Si vede che: A[0] viene modificato ogni volta A[1] viene modificato ogni 2 volte A[2] viene modificato ogni 4 volte ed in generale: A[i] viene modificato ogni 2i volte

Il numero totale di bit modificati è La complessità di n operazioni di incremento a partire da x = 0 è O(n). Quindi la complessità ammortizzata di una operazione di incremento è O(n)/n = O(1).

Esercizio 11 Mostrare che se al contatore binario di k bit aggiungiamo anche una operazione Decrement che decrementa di una unità il valore del contatore allora una sequenza di n operazioni può costare (nk)

Esercizio 12 Su di una struttura dati si esegue una sequenza di n operazioni. L’operazione k-esima costa k quando k è una potenza di 2 e costa 1 negli altri casi. Mostrare che le n operazioni hanno costo ammortizzato costante.

Metodo degli accantonamenti Si caricano le operazioni meno costose di un costo aggiuntivo. Il costo aggiuntivo viene assegnato come credito prepagato a certi oggetti nella struttura dati. I crediti accumulati saranno usati per pagare le operazioni più costose su tali oggetti.

Il costo ammortizzato delle operazioni meno costose è il costo effettivo aumentato del costo aggiuntivo. Il costo ammortizzato delle operazioni più costose è il costo effettivo diminuito del credito prepagato utilizzato. Illustriamo questo metodo con i soliti due esempi.

operazioni su di una pila Ricordiamo che i costi effettivi delle operazioni sulla pila sono: Push 1 Pop 1 Top 1 Empty 1 MultiPop 1+min(k,m) Push 2 Pop 0 Top 1 Empty 1 MultiPop 1 A tali operazioni attribuiamo dei costi ammortizzati

Quando effettuiamo una Push usiamo una unità di costo per pagare il costo effettivo dell’operazione mentre l’altra unità di costo la attribuiamo come credito prepagato all’oggetto inserito nella pila. Quando eseguiamo una Pop paghiamo il costo dell’operazione utilizzando il credito attribuito all’oggetto che viene tolto dalla pila.

Quando eseguiamo una Multi-Pop l’unità di costo attribuita a tale operazione si usa per pagare il costo dell’operazione stessa escluse le iterazioni del ciclo while. Le min(k,m) iterazioni del ciclo while vengono invece pagate utilizzando i min(k,m) crediti prepagati attribuiti agli oggetti che vengono tolti dalla pila.

incremento di un contatore binario Increment(A) i = 0 while i < k and A[i] == 1 A[i] = 0 i = i +1 if i < k A[i] = 1 Il costo effettivo di una operazione Increment è pari al numero di bit modificati. Tra questi vi è un certo numero t ≥ 0 di bit 1 trasformati in 0 e al più un solo bit 0 trasformato in 1.

Attribuiamo costo ammortizzato 2 ad ogni operazione Increment. Per eseguire Increment usiamo una delle due unità di costo per pagare l’eventuale bit 0 trasformato in 1 e l’altra unità di costo la attribuiamo come credito prepagato a tale bit. In questo modo ogni bit 1 ha sempre un credito prepagato che possiamo usare per pagare la trasformazione dei t bit 1 trasformati in 0 dall’operazione Increment.

Esercizio 13 Realizzare un contatore binario che prevede, oltre all’operazione Increment, anche una operazione Reset che azzera il contatore. La complessità ammortizzata delle operazioni deve risultare costante. Suggerimento: memorizzare la posizione del bit 1 più significativo.

Esercizio 14 Realizzare una pila P con operazioni di costo ammortizzato costante avendo a disposizione memoria per al più m elementi. Se la memoria è piena prima di eseguire una Push, si scarica su disco una parte degli m elementi. Se dopo una operazione Pop la memoria resta vuota ma ci sono altri elementi su disco, se ne ricarica una parte in memoria.

Metodo del potenziale Si associa alla struttura dati D un potenziale Φ(D) tale che la modifica della struttura dati dovuta alle operazioni meno costose comporti un aumento del potenziale mentre le operazioni più costose lo facciano diminuire. Il costo ammortizzato è quindi la somma algebrica del costo effettivo e della variazione di potenziale.

Se Di è la struttura dati dopo l’esecuzione della i-esima operazione e ci è il costo effettivo dell’operazione allora il costo ammortizzato è: e il costo ammortizzato di una sequenza di n operazioni è:

Se la variazione Φ(Dn)-Φ(D0) del potenziale relativa all’esecuzione di tutta la sequenza non è negativa allora il costo ammortizzato Ĉ è una maggiorazione del costo reale C. Altrimenti un valore Φ(Dn)-Φ(D0) negativo deve essere compensato con un aumento adeguato del costo ammortizzato delle operazioni. Illustriamo anche questo metodo con i soliti due esempi.

operazioni su di una pila Come funzione potenziale Φ(P) prendiamo il numero m di elementi contenuti nella pila P per cui: Operazione costo differenza di costo effettivo potenziale ammortizzato Push 1 1 2 Pop 1 -1 0 Top 1 0 1 Empty 1 0 1 MultiPop 1+min(k,m) -min(k,m) 1

Osserviamo che all’inizio la pila è vuota e quindi Φ(P0) = 0 mentre alla fine Φ(Pn) ≥ 0. Quindi la differenza di potenziale relativa a tutta la sequenza di operazioni non è mai negativa.

incremento di un contatore binario Scegliamo come funzione potenziale Φ(A) il numero di bit 1 presenti nel contatore Increment cambia t ≥ 0 bit 1 in 0 e al più uno 0 in 1 Quindi: Operazione costo differenza di costo effettivo potenziale ammortizzato Increment 1+t -t+1 2

Una sequenza di operazioni comporta una differenza di potenziale non negativa. Infatti all’inizio il contatore vale 0 e tutti i bit sono 0 e quindi Φ(A0) = 0 mentre alla fine Φ(An) ≥ 0. Con il metodo del potenziale si può calcolare il costo ammortizzato anche quando il contatore non parte da 0.

In questo caso Φ(Dn) - Φ(D0) può essere negativa ma pur sempre in modulo minore o uguale di k. Possiamo quindi compensarla aggiungendo la quantità k/n al costo ammortizzato di Increment. Il costo ammortizzato di Increment è quindi O(1+k/n) che, se k = O(n), si riduce ad O(1).

Esercizio 15 Realizzare una coda Q di tipo FIFO utilizzando due normali pile P1 e P2 e le relative operazioni Push e Pop. Le operazioni PushQ e PopQ di inserimento ed estrazione dalla coda devono richiedere tempo ammortizzato costante.