Red de conocimiento informático - Computadora portátil - C++ sobre el problema de la mochila 0-1

C++ sobre el problema de la mochila 0-1

// 0/1 algoritmo recursivo de mochila

Plantilla y clase ltT& gt

Clase de mochila

{

Público:

Mochila(int mSize, float cap, float *wei, T*prof);

t rk nap();

Privado:

T f(int j, flotante X);

flotante m, * w;

t * p

int

};

Plantilla<TClass>

tBackpack<T>* f(int j, float X)

{

if(j<0)return( (X<0)?-INFTY:0);

if(X<w[j])return f(j- 1, X);

En caso contrario {

T a=f(j-1, [j])+p[j];

Si (a & gtb) devuelve a; de lo contrario, devuelve b;

}

}

Plantilla y clase ltT y gt

tMochila y ltT y gt* rk nap()

{

Si (n & gt0) devuelve f (n-1, m);

De lo contrario, se devuelve NoAns //NoAns se puede definir como una constante de tipo T, que indica que no hay ingresos.

}

// Descripción aproximada del algoritmo de mochila 0/1

void DKP(float *p, float *w, int n, float M, float & ampp, int *x)

{

s? 1={(0, 0)};

for(I = 0;i<n-1;i++){

={(X,P)|(X- wi, ¿P-pi)? ¿Sí? 1 y X? m };

Si=MergerPurge(Si?1, );//Fusiona los dos conjuntos y descarta los puntos de paso que deben eliminarse de ellos.

}

(X1, P1)=Sn? El último punto de paso en 2;

(x2, p2) = (x+wn-1, p+pn-1), donde (X, P) es Sn-1 tal que X+wn- El punto de paso máximo de 1≤M;

P=max{P1, P2}; //P es el valor de la solución óptima.

¿Si (P2>P1)xn? 1=1;

else xn-1 = 0;

Utilice el método de retroceso para determinar xn-2, xn-3,…, x0;

}

// Algoritmo de solución óptima de mochila 0/1

Estructura XP

{

Punto flotante X, P;

};

Plantilla<TClass>

Clase de mochila

{

Público:

mochila(int sz, tapa flotante, flotador *wei, T*prof);

t DKnap(int *x);

……

Privado:

t DKnap();

rastreo nulo hacia atrás(int * x);

int máximo(int bajo, int alto, int I);

flotar m, * w;

XP * p;

T * pf

int n, * b; ;

Plantilla <TClass>

int Mochila<T>*max(int ​​​​low, int high, int i)

{

int u = bajo-1;

for(int j =bajo; j & lt=alto; j++){

float ww=p [j]. x+w[I];

si (ww & lt= m)u = j;

}

devuelve u;

}

Plantilla y clase ltT y gt

tMochila y ltT y gt* dk nap()

{

Ww flotante, PP;

int nextb[0]= 0;

p[0]. X=p[0]. P = 0,0p[1]. x = w[0];p[1]. p = pf[0]; //S0

int low=0, high = 1; //Posición inicial y final de S0

b[1]= next = 2; //La siguiente posición libre del array p

for(int I = 1;i<=n?1;i++){//Si generada por Si-1

int k = nivel bajo;

int u = máximo(bajo, alto, I);

for(int j = bajo; j & lt= u; J++) {// ¿De Si? 1 se genera y se fusiona en Si.

ww=p[j]. x+w[I];pp=p[j]. p+pf[I]; //Un punto de paso en la generación (ww, pp)

And ((k<=high)&&(p[k].X<Ww)) {//Copiar algunos pasos en Si-1 a Si.

p【Siguiente】. X=p[k]. x;p[siguiente++]. P=p[k++]. p;

}

if(k<=高&&p[k].x = = ww)if(PP<p[k].P) pp=p[k++] . p;

if(PP>p[Next?1].P) {//Si (ww, pp) no es dominante, agréguelo a Si.

p【Siguiente】. X = wwp[siguiente++]. P = pp

}

mientras(k <=alto&&p[k].

P<=p【¿Siguiente? 1].p)k++; //Abandona todos los puntos de pasos dominados

}

while(k & lt;=high){ //Elimina los pasos restantes en Si-1. los puntos de paso se copian en Si.

p【Siguiente】. X=p[k]. x;p[siguiente++]. P=p[k++]. p;

}

Bajo=alto+1; alto=bajo-1; b[I+1]= siguiente; p>}

devuelve p[siguiente-1]. p; //Devuelve el beneficio máximo.

}

//0/1 algoritmo de solución óptima de mochila

Plantilla y clase ltT y gt

Mochila vacía y ltT y gt*retroceso (int*x)

{

float ww=p[b[n] -1]. x;

for(int j = n-1; j & gt0;j - ){

x[j]= 1;

for (int k=b[j? 1];k & ltb[j];k++)

if(ww==p[k]). x)x[j]= 0;

si(x[j]) ww=ww? w[j];

}

if(ww = = 0)x[0]= 0; si no x[0]= 1;

}