Utilità per distribuire in modo ottimale file su più DVD?

Ho un sacco di file multimediali che voglio registrare su DVD, ma poiché ogni DVD può contenere solo 4,5 GB, devo trovare il modo ottimale di organizzare i file per utilizzare il numero minimo di DVD (altrimenti lo spazio vuoto lasciato in ogni Il DVD può facilmente aggiungere). Ci sono strumenti per aiutarti in questo?

Molti anni fa c'era un'utilità DOS per farlo con i floppy disk.

Prova la durata del DVD gratuita :

DVD Span è uno strumento di backup per scrivere i contenuti di cartelle di grandi dimensioni su più DVD. DVD Span può determinare automaticamente la migliore organizzazione di ciascun disco al fine di adattare la massima quantità di dati al numero minimo di dischi. DVDSpan è un ottimo strumento per il backup di raccolte musicali, foto o persino dell'intero disco rigido su DVD. E poiché produce DVD (o CD) regolari, non è necessario alcun software speciale per leggere o ripristinare i backup.

Ah, il problema dello zaino . Ho trovato un solo risolutore online per questo, qui . La dimensione dello zaino sarebbe di 4,5 GB e ogni pacchetto corrisponderebbe alle dimensioni del file. Dovrai massaggiare leggermente il suo output per adattarlo alla tua particolare applicazione, ma dovrebbe essere praticabile. Questo non funzionerà molto velocemente, perché questo problema è difficile .

Panoramica

La risposta di Jeff Shattock è corretta che questo è equivalente (o isomorfo, come scrivono i matematici) a un problema di ottimizzazione combinatoria, ma equivale al problema dell'imballaggio del bidone monodimensionale , non al problema dello zaino .

Fortunatamente per te, ho del codice da condividere che risolverà questo problema per te o chiunque altro, con accesso a un computer Windows con almeno la versione 3.5 di .NET Framework installata.

Una soluzione approssimativa

1. Innanzitutto, scarica e installa LINQPad .

2. In secondo luogo, scarica la query LINQPad che ho appena scritto - ecco il linq (ha) nel file raw. Salvalo come file .linq e aprilo in LINQPad.

3. Modifica i parametri:

   Ecco la parte nel codice di query LINQPad che dovresti modificare:

   int binSizeMb = 4476; // This is the (floor of the) total size of a DVD+R reported by CDBurnerXP. string rootFileFolderPath = @"F:\2006 - Polyester Pimpstrap Intergalactic Extravaganza multicam";

   Cambia binSizeMble dimensioni del tuo "cestino", ad es. CD, DVD, es. int binSizeMb = 650;per un CD.

   Nota : il binSizeMbvalore viene interpretato come ciò che a volte viene definito mebibyte . Contrariamente alla mia infanzia, quando tutti i multipli di byte erano "binari", a volte "MB" ora si riferisce a un "megabyte decimale" o esattamente 1.000.000 di byte, al contrario dei 1.048.576 byte di un mebibyte (MiB), che viene utilizzato nel mio codice . Se si desidera modificarlo, modificare la riga const int bytesPerMb = 1048576;nel codice in const int bytesPerMb = 1000000;.

   Passare rootFileFolderPathal percorso completo della cartella contenente i file che si desidera "impacchettare in bin", ad es. string rootFileFolderPath = @"C:\MySecretBinFilesFolder";.

4. Esegui la query premendo F5o facendo clic sul pulsante Esegui nella parte superiore sinistra della scheda della query.

risultati

Il codice della query enumera rootFileFolderPathricorsivamente tutti i file nella cartella, il che significa che includerà anche i file in tutte le sottocartelle.

Quindi creerà "bin" per i file in modo tale che la dimensione totale di tutti i file in ciascun cestino sia inferiore o uguale alla dimensione del cestino specificata.

Nel riquadro dei risultati LINQPad vedrai due elenchi.

Il primo elenco è di tutti i file trovati, elencati in ordine decrescente per dimensione.

Il secondo elenco è costituito dai contenitori creati "impacchettando i file", con un elenco dei file e delle loro dimensioni, nonché le dimensioni rimanenti del cestino.

Ecco uno screenshot che mostra il secondo elenco e i primi due bin creati:

Analisi Cursoria

Secondo Wikipedia, l'algoritmo che ho usato - la strategia First Fit Decreasing (FFD) - non dovrebbe essere troppo male; Wikipedia afferma:

Nel 2007, è stato dimostrato che l'OPT 11/9 + 6/9 per FFD è limitato.

'OPT' si riferisce alla strategia ottimale (come qualcosa di potenzialmente irraggiungibile, non una particolare strategia reale).

Sulla base delle mie memorie un po 'sfocate dei termini matematici coinvolti, ciò dovrebbe significare che, nella peggiore delle ipotesi, la strategia FFD dovrebbe raggruppare gli oggetti in ~ 1,22 volte il numero di bin che una strategia ottimale avrebbe. Quindi, questa strategia potrebbe impacchettare gli oggetti in 5 contenitori anziché 4. Sospetto che le sue prestazioni siano probabilmente molto vicine all'ottimale tranne che per specifiche dimensioni "patologiche" degli oggetti.

Lo stesso articolo di Wikipedia afferma inoltre che esiste un "algoritmo esatto" . Potrei decidere di implementarlo anch'io. Dovrò leggere prima l'articolo che descrive l'algoritmo.

Potresti usare qualsiasi strumento di compressione che consenta di suddividere un archivio, credo

Puoi prendere una delle varianti del programma nella guida di Hitchhiker a Haskell , forse dopo aver lavorato in qualche parte di quel tutorial; il tutorial è scritto per risolvere esattamente il tuo problema di distribuire le cose su più dischi, per cui la soluzione viene incrementata progressivamente, come esemplificato dal seguente passaggio del capitolo 3 del tutorial:

Già abbastanza preliminari. andiamo a fare un po 'di cd.

Come forse avrai già riconosciuto, il nostro problema è classico. Si chiama "problema dello zaino" ( cercalo su Google , se non sai già di cosa si tratta. Ci sono più di 100000 link).

partiamo dalla soluzione golosa ...

Altre idee: una domanda correlata

Ecco una domanda simile (anche se non è la stessa: non viene richiesta l'ottimizzazione lì), dove potresti trovare soluzioni / programmi più utili per il tuo compito (se saranno pubblicati):

• /unix//q/10158/4319 - "Dividere l'albero delle directory di grandi dimensioni in blocchi di dimensioni specificate?"

Alcuni suggerimenti per comprendere la programmazione nel tutorial suggerito

In generale, il codice Haskell è piuttosto espressivo (poiché Haskell è un linguaggio per la programmazione su un alto livello di astrazione), e quindi può essere facilmente compreso.

Quando osservi il codice di una delle soluzioni, ricorda che la struttura di livello superiore del programma che vogliamo scrivere è abbastanza semplice, come indicato nel capitolo 1 del tutorial:

Ora pensiamo per un momento a come funzionerà il nostro programma ed esprimiamolo in pseudocodice:

main = Read list of directories and their sizes.
       Decide how to fit them on CD-Rs.
       Print solution.

Sembra ragionevole? Così ho pensato.

Semplifichiamo un po 'la nostra vita e supponiamo per ora che calcoleremo le dimensioni delle directory da qualche parte al di fuori del nostro programma (ad esempio, con " du -sb *") e leggeremo queste informazioni da stdin.

e guardare più da vicino le parti della soluzione.

Tempo fa ho scritto lo script PHP per svolgere questo compito: https://bitbucket.org/borszczuk/php-backup-maker/

Prova anche Discfit, che seleziona i file e le directory da copiare su vari dischi:

https://sourceforge.net/projects/discfit/