Mochila Fraccionaria

Algoritmos y Estructuras de Datos IIIFacultad de Informatica, Grupo 2B

Universidad Politecnica de Valencia

Tema 4:Algoritmos Voraces

Enrique Vidal [email protected]

Diciembre, 2000

E. Vidal – UPV

AD3-A.Voraces-4 Diciembre, 2000

Algoritmos Voraces: Indice

1. Estartegia Voraz

2. El Problema de la Mochila

3. Solucion voraz al problema de la Mochilacon Fraccionamiento

E. Vidal – UPV Pagina 4.1


Mochila con Fraccionamiento (“mochiTime.c”)

/* Programa de prueba de algoritmos para Mochila con Fraccionamiento */

#include <stdlib.h>#include <stdio.h>#include <time.h>#include <math.h>/* ------------------------- Tipos, Variables globales y Macros generales */

#define maxTalla 1024000

int v[maxTalla+1]; /* indices a tama~nos t[] y valores g[] de objetos */short t[maxTalla+1]; /* tama~nos de los objetos */short g[maxTalla+1]; /* valores de objetos */

#define comp(i,j) ((float )g[i]/(float )t[i])-((float )g[j]/(float )t[j])/* compara objetos i y j segun su valor relativo */

#define ERROR(mens) {fprintf(stderr,mens); exit(1);} /* Fin por error */#define HERROR(mens) {printHelp(mens); exit(1);} /* Help/fin */#define RELOJ ( (float )clock()/CLOCKS_PER_SEC ) /* tiempo en segundos */



/* ----------------------------------------------------------------------QuickSort

*/int separa(int p, int r) { /* Particion de un vector desordenados. */

int i,j,x,z; /* Obtiene un ındice q, p<=q<r y separa los *//* elementos de v tal que v[p..q] <= v[q+1..r] */

i=p-1; j=r+1; x=v[p]; /* x es el pivote */while (1) {

do j--; while (comp(v[j],x)<0);do i++; while (comp(v[i],x)>0);if (i<j) { z=v[i]; v[i]=v[j]; v[j]=z; } /* intercambio */else return(j);

}}

void qks(int p, int r) { /* [ 0<p<=r<maxVec ] Algoritmo quickSort */int q;if (p<r) { /* si p>=r, solo hay 0 o 1 elementos y ya estan ordenados */q=separa(p,r); qks(p,q); qks(q+1,r);

}}



/* ----------------------------------------------------------------------Heap

*/typedef int element; int tllH=0;void heapify(int i) { /* restaura heap subarbol de raiz i */int l,r,mayor; element aux;

mayor=i; l=2*i; r=2*i+1;if ((l<=tllH) && (comp(v[l],v[i]) > 0)) mayor=l; /* mayor=argMax( */if ((r<=tllH) && (comp(v[r],v[mayor]) > 0)) mayor=r; /* v[i],v[l],v[r]) */if (mayor != i) {

aux=v[mayor]; v[mayor]=v[i]; v[i]=aux; /* intercambio v[mayor],v[i] */heapify(mayor);

}}void buildHeap(int n) { /* convierte v[1..n] en Heap mediante heapify */int i;

tllH=n; for (i=(int )(n/2); i>0; i--) heapify(i);}element extrMax() { /* Extrae el maximo del Heap (y lo elimina) */element x;

if (tllH==0) ERROR("**Error: extraeMax en un Heap vacio\n");x=v[1]; v[1]=v[tllH]; v[tllH]=x; /* guarda el elemento extraido */tllH--; heapify(1); return(x); /* para futuro uso */

}E. Vidal – UPV Pagina 4.4


/* ======================================================================Lectura de opciones, generacion de instancias e invocacion algoritmo

*/void main(int argc, char *argv[]) {

#define maxAlgor 2#define maxShort 32767#define maxM 2147483647 /* maxint */#define maxMr 1000 /* por cien sobre talla*rangot */#define maxRang 1024#define maxInst 1024000#define maxTiempo 36000 /* 36000 segundos = 10 horas */

int i, j, k, p, verRes=0, algor=1, semilla=1, M=0, Mr=50,rangot=256, rangog=256, talla=1024, ninst=1024, tiempo=maxTiempo;

float t0, tt, x, T, TM, G;



/* --------------------------------------------------------------------Breve ayuda ‘On-Line’ */

void printHelp(char *mens) {printf("Mochila con Fraccionamiento mediante: Sort (-a 1), Heap (-a 2)\nUso: %s [Opciones]", argv[0]);printf("Opciones:\n\

-h Muestra esta ayuda-v <num> Ver resultados (ultima) instancia procesada {0..2}[%d]-a <num> Algoritmo a utilizar {0..%d}[%d]-s <num> Semilla para la generacion datos aleatorios {0..%d}[%d]-M <num> Capacidad de la Mochila (M=0: usar -Mr) {1..%d}[%d]-Mr <num> Capacidad relativa en %% de t*(rt/2) {1..%d}[%d]-rt <num> Rango de tama~nos de objetos a generar {1..%d}[%d]-rg <num> Rango de valores de objetos a generar {1..%d}[%d]-t <num> Talla: Numero de objetos a generar {1..%d}[%d]-n <num> (Maximo) numero de instancias a procesar {1..%d}[%d]-T <num> Tiempo permitido en segundos {1..%d}[%d]

%s\n",verRes, maxAlgor,algor, maxShort,semilla, maxM,M, maxMr,Mr,maxRang,rangot, maxRang,rangog, maxTalla,talla, maxInst,ninst,maxTiempo,tiempo, mens);

}E. Vidal – UPV Pagina 4.6


/* --------------------------------------------------------------------Analisis de opciones y argumentos

*/#define argVal(jj,arg) (strcmp(argv[jj],arg)==0) && (jj+1<argc)#define acota(var,mini,maxi) ((var<mini) || (var>maxi))

if (argc>18) HERROR("\n**Error: Demasiados argumentos");for (i=1; i<argc; i++) {

if (strcmp(argv[i],"-h")==0) {printHelp(""); exit(1);}else if (argVal(i,"-v")) verRes = atoi(argv[++i]);else if (argVal(i,"-a")) algor = atoi(argv[++i]);else if (argVal(i,"-s")) semilla = atoi(argv[++i]);else if (argVal(i,"-M")) M = atoi(argv[++i]);else if (argVal(i,"-Mr")) Mr = atoi(argv[++i]);else if (argVal(i,"-rt")) rangot = atoi(argv[++i]);else if (argVal(i,"-rg")) rangog = atoi(argv[++i]);else if (argVal(i,"-t")) talla = atoi(argv[++i]);else if (argVal(i,"-n")) ninst = atoi(argv[++i]);else if (argVal(i,"-T")) tiempo = atoi(argv[++i]);else HERROR("\n**Error: opcion desconocida\n");

}



if (M<=0) M=(int )(float )Mr*(float )talla*(float )rangot/200.0;else Mr=(int )(200.0*(float )M/((float )talla*(float )rangot));TM=(float )M;

if ( acota(algor,0,maxAlgor) ||acota(semilla,0,maxShort) || acota(M,1,maxM) ||acota(Mr,1,maxMr) || acota(rangot,1,maxRang) ||acota(rangog,1,maxRang) || acota(talla,1,maxTalla) ||acota(ninst,1,maxInst) || acota(tiempo,1,maxTiempo) )

HERROR("\n**Error: algun parametro fuera de rango\n");



/* --------------------------------------------------------------------Generacion de instancias, invocacion algoritmo y computo de tiempos.

*/srand(semilla); tt=0.0; i=0;do { i++; /* generamos datos en t[] y g[], */

for (j=1; j<=talla; j++) { /* indexadas por v[] */v[j] = j; t[j] = 1 + rand()%rangot; g[j] = 1 + rand()%rangog;

}t0 = RELOJ; k=0; T=G=0.0; x=1.0;switch(algor) {

case 1: qks(1,talla);while ((T<TM) && (k<talla)) {

k++; p=v[k]; T+=t[p]; G+=g[p];} break;

case 2: buildHeap(talla);while ((T<TM) && (k<talla)) {

k++; p=extrMax(); T+=t[p]; G+=g[p];} break;

default: break;} if (T>TM) {x=1-(T-TM)/t[p]; G-=(1-x)*g[p];}tt += RELOJ - t0; if (tt >= (float )tiempo) break;

} while(i<ninst);



/* --------------------------------------------------------------------Impresion de Resultados

*/printf("a: %d t: %-7d Mr: %-3d : Procesadas %6d instancias "

"en %6.2f segundos\n", algor, talla, Mr, i, tt);

if (verRes>0) printf("\nUltima instancia: M=%d, k=%d, ""x=%3.2f, T=%3.2f, G=%3.2f\n\n", M, k,x,T,G);

if (verRes>1) {for (j=1; j<=talla && j<=10; j++) printf(" %6d", j); printf("\n");for (j=1; j<=talla && j<=10; j++) printf(" ------"); printf("\n");

for (j=1; j<=talla; j++) {printf(" %6d", g[v[j]]); if (j%10==0) printf("\n");

} if (j%10!=1) printf("\n"); printf("\n");for (j=1;j<=talla;j++) {

printf(" %6d", t[v[j]]); if (j%10==0) printf("\n");} if (j%10!=1) printf("\n"); printf("\n");for (j=1; j<=talla; j++) {

printf(" %6.2f", (float )g[v[j]]/t[v[j]]); if (j%10==0) printf("\n");} if (j%10!=1) printf("\n");printf("\n");

}}E. Vidal – UPV Pagina 4.10


Resultados de “moch” usando Heap de aristasfor Mr in 1 4 16 64 128 200 ; do echo ; for t in 1000 10000 100000 1000000 ; do

moch -t $t -Mr $Mr -n 5 -a 2done ; done

a: 2 t: 1000 Mr: 1 : Procesadas 5 instancias en 0.01 segundosa: 2 t: 10000 Mr: 1 : Procesadas 5 instancias en 0.11 segundosa: 2 t: 100000 Mr: 1 : Procesadas 5 instancias en 1.56 segundosa: 2 t: 1000000 Mr: 1 : Procesadas 5 instancias en 20.43 segundos








Resultados de “moch” con Sort de aristasfor Mr in 1 4 16 64 128 200 ; do echo ; for t in 1000 10000 100000 1000000 ; do

moch -t $t -Mr $Mr -n 5 -a 1done ; done









Resultados comparativos “moch” con Heap/Sort de aristas

0.01

0.1

1

10

100

1 10 100

Tie

mpo

(se

g)

Capacidad Relativa (%)

Mochila con Fraccionamiento: uso de Sort y Heap

SORT

SORT

SORT

SORT

HEAP

HEAP

HEAP

HEAP

Talla=1k

Talla=10k

Talla=100k

Talla=1000k


Documents

Mochila Fraccionaria