C++ sobre el problema de la mochila 0-1
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;
}