0-1背包问题&背包问题（动规/回溯/分支限界法&贪心）

最新推荐文章于 2022-11-11 09:32:38 发布
最新推荐文章于 2022-11-11 09:32:38 发布
阅读量4.2k 收藏 75
点赞数 13
分类专栏： 算法分析与设计 文章标签： 背包问题 0-1背包问题 完全背包问题 多重背包问题 考虑容积的0-1背包问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45909595/article/details/118266761
版权

写在前面：仅为个人代码/总结，未必标准，仅供参考！如有错误，还望指出交流，共同进步！

（一）0-1背包问题

在这里插入图片描述

【动态规划法】

一、算法思路

0-1背包问题具有最优子结构性质和重叠子问题性质。
首先定义m(i,j)：从物品i、i+1、…、n-1、n中选择物品装入容量大小为j的背包，使该背包的总价值最大，最大值为m(i,j)，即最优值。
假设背包容量为c，物品总数n，物品i的重量表示wi，价值表示vi，于是0-1背包问题的最优值为m(1,c)。计算m(1,c)的值之前，先递归地定义最优值的计算方法：
（1）当背包剩余容量为j时，且j≥wi, m(i,j)= max{ m(i+1,j), m(i+1,j-wi)+vi)}。即当此时的背包剩余容量大于物品i的重量，于是在选取物品i和不选取物品i之中选择较大者。
（2）当背包剩余容量为j时，且0<j< wi, m(i,j)= m(i+1,j);。说明物品i的重量大于背包此时剩余容量，装不下，舍弃。
（3）最小的子问题，当背包剩余容量为j、且只有一个物品n供选择时，此时，若j≥wn, 则最大价值为vn，即 m(n,j)=vn；若j < wn, 则最大价值为0,即 m(n,j) = 0。

二、递归式

在这里插入图片描述

三、实现代码

#include <bits/stdc++.h>
using namespace std;
void getData(int* a,int* b,int n)
{
    srand(time(0));
    for(int i=1;i<=n;i++)
    {
        a[i]=rand()%15+1;
    }
    for(int i=1;i<=n;i++)
    {
        b[i]=rand()%15+1;
    }
}
void Knapsack(int* v,int* w, int c, int n,int (*m)[21])
{
    int jMax=min(w[n]-1,c);//首先处理第n个物品
    for(int j=0;j<=jMax;j++)//剩余容量＜物品n重量
    {
        m[n][j] = 0;
    }
    for(int j=w[n];j<=c;j++)//剩余容量≥物品n重量
    {
        m[n][j] = v[n];
    }
    for(int i=n-1;i>1;i--)
    {
        jMax=min(w[i]-1,c);
        for(int j=0;j<=jMax;j++)//当背包剩余容量为j时，且0<j<wi
            m[i][j] = m[i+1][j];
        for(int j=w[i];j<=c;j++)//当背包剩余容量为j时，且j≥wi
            m[i][j]=max(m[i+1][j],m[i+1][j-w[i]]+v[i]);
    }
    //处理第1个物品
    m[1][c]=m[2][c];
    if(c>=w[1])
        m[1][c]=max(m[1][c],m[2][c-w[1]]+v[1]);
}
void Traceback(int (*m)[21], int* w, int c, int n,int* x)
{
    for(int i=1;i<n;i++)
    {
        if(m[i][c]==m[i+1][c])
            x[i]=0;
        else
        {
            x[i]=1;
            c-=w[i];
        }
    }
    x[n]=(m[n][c])?1:0;
}
int main()
{
    cout<<"（每次随机生成的测试数据物品个数默认为10，背包容量默认为20，物品重量、价值为1-15的随机数）"<<endl;
    int w[11]={0};
    int v[11]={0};
    int x[11];
    getData(w,v,10);
    cout<<"物品重量为：";
    for(int i=1;i<=10;i++)
    {
        cout<<w[i]<<' ';
    }
    cout<<endl<<"物品价值为：";
    for(int i=1;i<=10;i++)
    {
        cout<<v[i]<<' ';
    }
    cout<<endl;
    int m[11][21];
    Knapsack(v,w,20,10,m);
    cout<<"装入背包物品最大总价值："<<m[1][20]<<endl;
    Traceback(m,w,20,10,x);
    cout<<"解向量为：";
    for(int i=1;i<=10;i++)
    {
        cout<<x[i]<<' ';
    }
    cout<<endl;
    return 0;
}

四、算法效率

算法Knapsack需要O(nc)计算时间，算法Trackback需要O(n)计算时间。

【回溯法】

一、算法思想

首先明确0-1背包问题的解空间为子集树。对于每一个物品i，只有选与不选2个决策，总共有n个物品，可以顺序依次考虑每个物品，这样就形成了一棵二叉解空间树。
搜索状态空间树时，只要左子节点是可一个可行结点，搜索就进入其左子树。对于右子树时，先计算限界函数，以判断是否将其减去（剪枝），即当右子树中有可能包含最优解时才进入右子树，否则剪去右子树。
当限界函数Bound():当前价值cv+剩余容量可容纳的最大价值r<=当前最优价值bestv时，可剪去右子树。
为了更好地计算和运用上界函数剪枝，选择先将物品按照其单位重量价值从大到小排序，此后就按照该顺序考虑各个物品。

二、实现代码

#include <bits/stdc++.h>
using namespace std;
class Knap{
    friend int Knapsack(int*,int*,int,int,int[]);
private:
    int Bound(int i);
    void Backtrack(int i);
    int c;
    int n;
    int *x;
    int *bestx;
    int *w;
    int *p;
    int cw;
    int cp;
    int bestp;
};
class Object
{
    friend int Knapsack(int*,int*,int,int,int*);
public:
    int ID;
    float d;
};
bool cmp(Object A,Object B)
{
    return A.d>B.d;
}
int Knap::Bound(int i)
{
    int cleft=c-cw;
    int b=cp;
    while(i<=n&&w[i]<=cleft)
    {
        cleft-=w[i];
        b+=p[i];
        i++;
    }
    if(i<=n)
    {
        b+=p[i]*cleft/w[i];
    }
    return b;
}
void Knap::Backtrack(int i)
{
    if(i>n)//到达叶结点
    {
        for(int j=1;j<=n;j++)
        {
            bestx[j]=x[j];
        }
        bestp=cp;
        return;
    }
    if(cw+w[i]<=c)//进入左子树
    {
        x[i]=1;
        cw+=w[i];
        cp+=p[i];
        Backtrack(i+1);
        cw-=w[i];
        cp-=p[i];
        x[i]=0;
    }
    if(Bound(i+1)>bestp)//进入右子树
        Backtrack(i+1);
}
int Knapsack(int* p,int * w,int c,int n,int* bestx)
{
    int W=0;
    int P=0;
    Object *Q=new Object[n];
    for(int i=1;i<=n;i++)
    {
        Q[i-1].ID=i;
        Q[i-1].d=10*p[i]/w[i];
        P+=p[i];
        W+=w[i];
    }
    if(W<=c)
        return P;
    sort(Q+1,Q+n+1,cmp);
    Knap K;
    K.p=new int[n+1];
    K.w=new int[n+1];
    K.x=new int[n+1];
    for(int i=1;i<=n;i++)
    {
        K.p[i]=p[Q[i-1].ID];
        K.w[i]=w[Q[i-1].ID];
        K.x[i]=0;
    }
    K.cp=0;
    K.cw=0;
    K.c=c;
    K.n=n;
    K.bestp=0;
    K.bestx=bestx;
    K.Backtrack(1);
    for(int i=1;i<=n;i++)
    {
        K.x[i]=K.bestx[i];
    }
    for(int i=1;i<=n;i++)
    {
        K.bestx[Q[i-1].ID]=K.x[i];
    }
    delete []Q;
    delete []K.w;
    delete []K.p;
    delete []K.x;
    return K.bestp;
}
int main()
{
    int n,c;
    cin>>n>>c;
    int *p,*w,*bestx;
    p=new int[n+1];
    w=new int[n+1];
    bestx=new int[n+1];
    for(int i=1;i<=n;i++)
    {
        cin>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        cin>>p[i];
        bestx[i]=0;
    }
    int res=Knapsack(p,w,c,n,bestx);
    cout<<res<<endl;
    for(int i=1;i<=n;i++)
    {
        cout<<bestx[i]<<' ';
    }
    cout<<endl;
    return 0;
}

三、算法效率

计算上界需要O(n)时间，最坏情况下有O(n2)个右儿子结点需要计算上界，而在遍历到叶结点时需要一次性更新最优解，计算时间为O(n)，故回溯算法Backtrack所需的计算时间为O(n22n)。

四、更新最优解算法改进

class Knap{
    friend int Knapsack(int*,int*,int,int,int[]);
private:
    int Bound(int i);
    void Backtrack(int i);
    int c;
    int n;
    int *x;
    int *bestx;
    int *w;
    int *p;
    int cw;
    int cp;
    int bestp;
    int ii;//增加最优解回溯标志
};
//每当算法回溯一层，将x[i]存入bestx[i]，在每个结点处更新bestx只需要O(1)时间
void Knap::Backtrack(int i)
{
    if(i>n)//到达叶结点
    {
        ii=n;
        bestp=cp;
        return;
    }
    if(cw+w[i]<=c)//进入左子树
    {
        x[i]=1;
        cw+=w[i];
        cp+=p[i];
        Backtrack(i+1);
        if(ii==i) {bestx[i]=1;ii--;}
        cw-=w[i];
        cp-=p[i];
        x[i]=0;
    }
    if(Bound(i+1)>bestp)//进入右子树
    {
        Backtrack(i+1);
        if(ii==i) {bestx[i]=0;ii--;}
    }
}

【优先队列式分支限界法】

一、算法思想

分支限界法常以广度优先或最小耗费优先（最大效益优先）方式搜索问题的解空间树， 0-1背包问题的解空间树是一个颗子集树。
对于0-1背包问题中的每个活结点只有两个儿子结点，分别表示选取和不选取物品i；在判断儿子结点是否能加入到活结点表中，有两个函数条件需要满足，一个是约束函数，判断能否满足背包容量约束，另一个是限界函数，判断是否可能有最优解。
为了尽快找到0-1背包问题的解，每次选取下一个活结点成为扩展结点的判断依据是当前情况下最有可能找到最优解的下一个结点。因此，每次选择扩展结点的方法：当前情况下，在活结点表中选择活结点的上界uprofit（通过限界函数Bound求出）最大的活结点成为当前的扩展结点，即以uprofit为优先级将活结点插入到优先队列中，每一次选取优先级最高的结点作为当前拓展结点。 这一过程一直持续到找到所需的解或活结点表为空时为止。
为了在活结点表中选择拥有最大的上界uprofit的活结点，在活结点表上实现优先队列。

二、算法步骤

首先，根据每个物品的重量和价值计算出物品的单价，根据单价将物品进行排序，以下是优先队列式分支限界法的搜索过程：
①搜索解空间建立二叉树，从根结点开始。
②广度优先搜索二叉树，并用upfrofit表示活结点的优先级构建最大堆。
③选取优先级最高的活结点作为扩展结点，找出可行解。
④检查左儿子结点是否是可行结点（即上界大于当前最优值且加上该物品的重量不超过背包容量），如果是则将它加入到活结点优先队列中，而当前扩展结点的右儿子一定是可行结点，仅当右儿子满足上界约束时才将它加入到活结点优先队列中。
⑤维护堆结构，使得堆顶元素依然是优先级最高的结点。（构建优先队列可直接调用C++STL库中的priority_queue，插入活结点自动维护）
⑥重复③④⑤步骤直到优先队列为空。

三、实现代码

#include <bits/stdc++.h>
using namespace std;
typedef int Typew;
typedef int Typep;
//物品类
class Object{
	friend Typep Knapsack(Typew *, Typep *, Typew, int, int *);
public:
	int operator <= (Object a) const{
		return (d >= a.d);
	}
private:
	int ID; //物品编号
	float d; //单位重量价值
};
//树结点类
class bbnode{
	friend class Knap;
	friend Typep Knapsack(Typew *, Typep *, Typew, int, int *);
private:
	bbnode *parent; //指向父节点的指针
	int LChild; //左儿子结点标记
};
//堆结点类
class HeapNode{
	friend class Knap;
	friend class MaxHeap;
public:
	operator Typep()const{return uprofit;};
private:
	Typep uprofit, //结点的价值上界
		  profit; //结点所相应的价值
	Typew weight; //结点所相应的重量
	int level; //活结点在子集树中所处的层序号
	bbnode *elemPtr; //指向该活结点在子集树中相应结点的指针
};
//0-1背包问题的主类
class Knap{
	friend Typep Knapsack(Typew *, Typep *, Typew, int, int *);
public:
	Typep MaxKnapsack();
private:
	priority_queue<HeapNode> H;
	//限界函数：计算结点价值上界
	Typep Bound(int i);
	//将活结点插入子集树和优先队列中
	void AddLiveNode(Typep up, Typep cp, Typew cw, int ch, int level);
	bbnode *E; //指向扩展结点的指针
	Typew c; //背包容量
	int n; //物品总数
	Typew *w; //物品重量数组
	Typep *p; //物品价值数组
	Typew cw; //当前装包重量
	Typep cp; //当前装包价值
	int *bestx; //最优解
};

Typep Knap::MaxKnapsack()
{
	bestx = new int [n+1];
	int i = 1; //生成子集树中的第一层的结点
	E = 0; 
	cw = 0;
	cp = 0;
	Typep bestp = 0; //当前最优值
	Typep up = Bound(1); // 选取物品1之后的价值上界
	//当选择左儿子结点时，考虑约束函数
	//当选择右儿子结点时，考虑限界函数
	while (i != n+1)
	{
		//检查当前扩展结点的左儿子结点
		Typew wt = cw + w[i]; //当前选择物品i之后的总重量wt
		if(wt <= c) //左儿子结点可行
		{
			if(cp + p[i] > bestp)
				bestp = cp + p[i];
			AddLiveNode(up, cp + p[i], cw + w[i], 1, i);
		}
		//检查当前扩展结点的右儿子结点
		up = Bound(i + 1); //未选择物品i之后的价值上界
		if(up >= bestp)
			AddLiveNode(up, cp, cw, 0, i);
		//从优先队列中选择uprofit最大的结点成为扩展结点
		HeapNode N;
		N=H.top();
		H.pop();
		E = N.elemPtr;
		cw = N.weight;
		cp = N.profit;
		up = N.uprofit;
		i = N.level + 1; 
	}
	//从子集树中的某叶子结点开始构造当前最优解
	for (int i = n; i > 0; i--)
	{
		bestx[i] = E->LChild;
		E = E->parent;
	}
	return cp;
}
Typep Knap::Bound(int i)
{
	Typew cleft = c - cw;
	Typep b = cp;
	while (i<=n && w[i] <= cleft)
	{
		cleft -= w[i];
		b += p[i];
		i++;
	}
	if(i<=n) b += p[i]/w[i] * cleft;
	return b;
}
void Knap::AddLiveNode(Typep up, Typep cp, Typew cw, int ch, int level)
{
	bbnode *b=new bbnode;
    b->parent=E;
    b->LChild=ch;
	HeapNode N;
    N.uprofit=up;
    N.profit=cp;
    N.weight=cw;
    N.level=level;
	N.elemPtr=b;
	H.push(N);
}
Typep Knapsack(Typew *w, Typep *p, Typew c, int n, int *bestx)
{
	Typew W = 0;
	Typep P = 0;
	Object *Q = new Object[n];
	for(int i =1; i<=n; i++)
	{
		Q[i-1].ID = i;
		Q[i-1].d = 1.0*p[i]/w[i];
		P += p[i];
		W += w[i];
	}
	if (W <= c)
	{
		for(int i =1; i<=n; i++)
		{
			bestx[i] = p[i];
		}
		return P;
	}
	//采用简单冒泡排序，对物品以单位重量价值降序排序
	for(int i = 1; i<n; i++)
		for(int j = 1; j<= n-i; j++)
		{
			if(Q[j-1].d < Q[j].d)
			{
				Object temp = Q[j-1];
				Q[j-1] = Q[j];
				Q[j] = temp;
			}
		}
	Knap K;
	K.p = new Typep [n+1];
	K.w = new Typew [n+1];
	for(int i = 1; i<=n; i++)
	{
		K.p[i] = p[Q[i-1].ID];//以单位重量价值降序排序
		K.w[i] = w[Q[i-1].ID];//以单位重量价值降序排序
	}
	K.cp = 0;
	K.cw = 0;
	K.c = c;
	K.n = n;
	Typep bestp = K.MaxKnapsack();
	for(int i = 1; i<=n; i++)
	{
		bestx[Q[i-1].ID] = K.bestx[i];
	}
	delete [] Q;
	delete [] K.w;
	delete [] K.p;
	delete [] K.bestx;
	return bestp;
}
Typep p[10001];
Typew w[10001];
int bestx[10001];
int main()
{
        int N;
        Typew c; //背包容量
        int bestp; //最优值
        cin>>N>>c;
        for(int i=1;i<=N;i++)
        {
            cin>>w[i]>>p[i];
        }
        bestp = Knapsack(w, p, c, N, bestx);
        for(int i = 1; i <= N; i++)
        {
            if(i ==1 ) cout<<"解向量：";
            cout<<bestx[i];
            if(i != N) cout<<",";
            else
                cout<<endl;
        }
        cout<<"背包最优价值："<<bestp<<endl;
    }
	return 0;
}

（二）背包问题

与0-1背包问题类似，所不同的是在选择物品i装入背包时，可以选择物品i的一部分而不一定要全部装入背包（1≤i≤n），使得背包价值最大。

【贪心算法】

一、算法思路

为了尽可能的得到最优解,选择物品时,总是选择v[i]/w[i]最大的物品装进去。所以在程序的开始，首先定义物品结构体，结构体包含物品的序号、重量、价值、是否放进背包的信息，然后对物品按照v[i]/w[i]即单位重量价值从大到小进行排序,再调用Knapsack函数根据性价比将物品放进背包，最后放不下某个物品时将该物品的一部分装进背包直至背包被装满，完成后对物品按序号从小到大排序，调用Traceback函数输出相应序号的物品是否被放进背包、放进了多少。

二、实现代码

#include<bits/stdc++.h>
using namespace std;
struct object
{
    int num;
    float value;
    float weight;
    float flag;
};
bool cmp1(object A,object B)
{
    float u=B.weight,v=A.weight;
    return (A.value*u)>(B.value*v);
}
bool cmp2(object A,object B)
{
    return A.num<B.num;
}
float Knapsack(object* O,float c,int n)
{
    float curweight=0,curvalue=0;
    for(int i=0;i<n;i++)
    {
        if((O[i].weight+curweight)<=c)
        {
            curvalue+=O[i].value;
            curweight+=O[i].weight;
            O[i].flag=1.0;
        }
        else if(c-curweight>0)
        {
            O[i].flag=(c-curweight)/O[i].weight;
            curvalue+=O[i].flag*O[i].value;
            curweight=c;
        }
        else
        {
            O[i].flag=0;
        }
    }
    return curvalue;
}
void Traceback(object* O,int n)
{
    for(int i=0;i<n;i++)
    {
        cout<<O[i].flag<<' ';
    }
    cout<<endl;
}
int main()
{
    cout<<"请输入物品数量:";
    int n;
    cin>>n;
    object O[n];
    for(int i=0;i<n;i++)
    {
        cout<<"请输入第"<<i+1<<"个物品的重量和价值:";
        cin>>O[i].weight>>O[i].value;
        O[i].num=i+1;
    }
    cout<<"请输入背包的容量:";
    float c;
    cin>>c;
    sort(O,O+n,cmp1);
    float res=Knapsack(O,c,n);
    cout<<res<<endl;
    sort(O,O+n,cmp2);
    Traceback(O,n);
    return 0;
}

（三）0-1背包问题的拓展——考虑容积

在这里插入图片描述

【动态规划法】

一、算法思路

该问题是原0-1背包问题的拓展，增加了容积这一限制条件，因此将原来的二维数组m(i,j)增加一维变为m(i,j,k)，定义m(i,j,k)为从物品0、1、…、i-1、i中选择物品装入容量大小为j、容积为k的背包，使该背包的总价值最大，最大值为m(i,j,k)，算法思路和原0-1背包问题的动态规划法思路一致。

二、递归式

在这里插入图片描述

三、实现代码

int m[n][c+1][d+1]={0};
void Knapsack(int* v,int* w,int* b,int c,int d,int n)
{
	for(int j=0;i<=c;j++)
	{
		for(int k=0;k<=d;k++)
		{
			if(w[0]<=j&&b[0]<=k)
				m[0][j][k]=v[0];
			else
				m[0][j][k]=0;
		}
	}
	for(int i=1;i<n;i++)
	{
		for(int j=1;j<=c;j++)
		{
			for(int k=1;k<=d;k++)
			{
				if(w[i]<=j&&b[i]<=k)
					m[i][j][k]=max(m[i-1][j][k],m[i-1][j-w[i]][k-b[i]]+v[i]);
				else
					m[i][j][k]=m[i-1][j][k];
			}
		}
	}
}

（四）完全背包问题、多重背包问题

一、完全背包问题：每一种物品有无限个，因此不需要考虑每件物品是否已经被取。

int m[c+1]={0};
for(int i=1;i<=n;i++) 
{
    for(int j=w[i];j<=c;j++) 
    {
        m[j] = max(m[j], m[j - w[i]] + v[i]);
    }
}

二、多重背包问题：限定每一种物品的个数，解决多重背包问题可将其转化为0-1背包问题求解。

LG.田猿
关注
  • 13
    点赞
  • 踩
  • 75
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
0/1背包问题（蛮力、动态规划、回溯、分支限界法）
01-20
算法设计实验报告，包括：蛮力、动态规划、回溯、分支限界四种算法求解0/1背包问题的基本思想、时间复杂度分析，C++实现代码，运行结果截图，实验心得。
动态规划-经典问题（0-1背包问题）分析及优化
YY-帆S的博客
03-05 9900
目录 1.0-1背包问题的分析 （1）状态方程 2.递归算法 3.记忆化搜索 4.动态规划 5.优化1——空间复杂度O(2C) 6.优化2——空间复杂度O(C) 7.0-1背包问题的变种 如上图是一个LeetCode的经典问题，0-1背包问题 1.0-1背包问题的分析 尝试下面的算法 暴力解法：每一件物品都可以放进背包，也可以不放进背包，时间复杂度为O((2^n)...
0-1背包动态规划回溯法分支限界贪心算法
12-05
本资源包含了0-1背包问题的最佳所有解法，其中包括动态规划算法，回溯法算法，分支限界算法和贪心算法。包含源代码。
论文研究 - 0/1多维背包问题及其变体：实用模型和启发式方法的概述
05-25
0/1多维背包问题（0/1 MKP）是一个有趣的NP-hard组合优化问题，可以对物流，金融，电信和其他领域中许多具有挑战性的应用程序进行建模。 在0/1 MKP中，给出了一组项目，每个项目都有大小和值，必须将其放入具有一定数量的尺寸且容量有限的背包中。 目标是在遵守容量约束的情况下找到导致最大总利润的项目子集。 即使在文献中对0/1 MKP进行了充分的研究，但我们仍然可以找到有关此问题的近期评论文章。 此外，现有审查特别关注某些特定问题。 本文旨在对所考虑的问题进行全面而全面的调查，以便对研究人员和从业人员都有用。 实际上，我们首先描述了0/1 MKP及其相关变体。 然后，我们介绍此问题在一些重要的实际应用中的详细模型。 此外，对最近发表的启发式和元启发式的重要集合进行了分类和简要回顾。 然后通过一些指示性统计数据对这些方法进行定量比较。 最后，总结了一些综述性的观点和研究方向。
0-1背包问题 动态规划 分支限界 回溯 贪心四种方法
05-26
0-1背包问题 动态规划 分支限界 回溯 贪心四种方法
0-1背包问题（分支限界法）报告.doc
12-26
算法设计与分析实验报告，附已通过源码，供学习参考，共勉♪ 目录摘要如下： 1.问题描述 2.实验目的 3.实验原理 4.实验设计 （包括输入格式、算法、输出格式） 5.实验结果与分析 （除了截图外，实验结果还用图表进行了分析） 6.结论 7.程序源码
动态规划-（0-1）背包问题
菜鸟的博客
10-29 1万+
下面我用容积代表重量（我是不会承认我看走眼了的。又懒得改。）0-1背包问题是动态规划背包问题系列的最基础的一个问题。相对理解起来较为简单。按书上来说，要证明一个问题是否可以使用动态规划思想，需要满足最优子结构的性质，那么什么是最优子结构的性质呢？书上给出的定义如下图看起来很拗口，其实就是不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。说白了就是一个最优策略的子策略也是必须是最优的，而所有子问题的局部最优解将导致整个问题的全局最优。
背包问题之0-1背包算法详解
WorldMvp的专栏
03-21 1万+
一、0-1背包问题描述 有5件物品和1个背包，背包最多只能装下8公斤的物品。怎样选择物品，使得背包能装下并且得到的价值最大。物品的重量和价值如下所示： 物品1: 6公斤　　 价值48元 物品2: 1公斤　　 价值7元 物品3: 5公斤　　 价值40元 物品4: 2公斤　　 价值12元 物品5: 1公斤　　 价值8元
动态规划之0-1背包问题（详解+分析+原码）
热门推荐
未见花闻的博客
05-08 4万+
本篇文章将介绍算法专题之动态规划中的背包问题，更准确的说是背包问题中最简单的一种类型，即0-1背包问题，就是给你一定容量的背包和若干物品，每种物品只能选一次，告诉你每件物品的价值和体积，求背包里面物品的最大总价值。
九种 0-1 背包问题详解
Tyler_Zx的博客
08-10 1万+
目录 动态规划概念 问题1：0-1背包问题 问题2：完全背包问题 问题3：多重背包问题 问题4：混合背包问题 问题5：二维背包问题 问题6：分组背包问题 问题7：有依赖的背包问题(困难) 问题8：背包问题求方案数 问题9：背包问题求具体方案 前言 0-1 背包是一个经典的问题，之前也整理过一篇关于　0-1 背包的博客，当时只是整理了　0-1 背包问题的4 种解决方法。最近在复习算法，发现有很多　0-1 背包问题的衍生问题。0-1 背包问题的限制条件既可以是重量，也可以是容量，或者..
动态规划法、贪心算法、回溯法、分支限界法解决0-1背包
11-23
1) 动态规划法求解问题的一般思路，动态规划法求解本问题的思路及其C/C++程序实现与算法的效率分析。 2) 贪心算法在0-1背包问题求解中的应用 3) 回溯法求解问题的一般思路，回溯法求解本问题的思路及其C/C++程序实现与算法的效率分析。 4) 分支限界法求解问题的一般思路，分支限界法求解本问题的思路及其C/C++程序实现与算法的效率分析。 有代码！！
0-1背包问题和背包问题的多种算法实现
11-29
0-1背包问题和背包问题的多种算法求解，包含用动态规划法、回溯法、分支限界法求解0-1背包问题，用贪心算法求解背包问题，及相关算法的比较（求解思路和代码实现）
搜索技术【广度优先搜索】 - 优先队列式广度优先搜索
谢谢你们的关注
11-11 766
搜索技术【广度优先搜索】 - 优先队列式广度优先搜索
0-1背包问题-动态规划
迷雾总会解
07-02 4803
问题描述  给定n个物品和一个背包。物品i的重量为wi，价值为vi，背包容量为c。  如何选择装入背包中的物品，使得装入背包的物品的价值最大？  每种物品i只有两种选择，装入或者不装入，既不能装入多次，也不能只装入一部分。  此问题称为0-1背包问题。 问题形式化描述  问题的形式描述是：给定c＞0，wiw_iwi​＞0，viv_ivi​＞0，1≤i≤n，求n元0-1向量(x1x_1x1​, x2x_2x2​, …, xnx_nxn​)，使得  (物品i的重量为wi，价值为vi，背包容量为c。) 最优
0-1背包问题详解（一步一步超详细）
qq_42051306的博客
02-20 2万+
0-1背包问题详解 1.什么叫背包问题？ 背包问题通俗的说，就是假如你面前有5块宝石分别为a, b, c, d, e，每块宝石的重量不同，并且每块宝石所带来的价值也不同（注意：这里宝石的重量的价值没有特定关系），目前我们有一个背包，只有固定的容量，要解决的问题就是在一定容量的背包面前装哪几块宝石才能获取到最大的价值，下面通过一个例子来深入理解背包问题 2.背包问题例子 每种宝石的重量分别为，每块宝石的价值分别为， ...
0-1背包问题和普通背包问题
qq_53457019的博客
04-25 1120
0-1背包问题和普通背包问题
动态规划之0/1背包问题原理详解: 简明、细致、深入理解
yw906002599的博客
04-23 9632
动态规划，0/1背包问题，回溯
四种不同算法求解0-1背包问题
lcw_2015的博客
11-06 3万+
0-1背包问题 一、  问题描述 1  0-1背包问题 现有n种物品，对1i，价值为正整数Vi，背包能承受的最大载重量为正整数W，现要求找出这n种物品的一个子集，使得子集中物品的总重量不超过W且总价值尽量大。在选择装人背包的物品时，对每种物品i只有两种选择，即装入背包、不装入背包。不能将物品i 装人背包多次，也不能只装入部分的物品i（注意：这里对每种物品或者全取或者一点都不取，不允许只取一部
JavaScript介绍.zip
最新发布
04-23
javascript,JavaScript 最初由 Netscape 公司的 Brendan Eich 在 1995 年开发，用于 Netscape Navigator 浏览器。随着时间的推移，JavaScript 成为了网页开发中不可或缺的一部分，并且其应用范围已经远远超出了浏览器，成为了全栈开发的重要工具。
分支限界法求解01背包问题的分析过程
05-19
分支限界法是一种用于求解优化问题的算法，它通过对问题空间进行分枝剪枝来逐步缩小问题的规模，从而找到最优解。下面是分支限界法求解01背包问题的分析过程： 1.确定状态空间：01背包问题的状态空间可以定义为一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LG.田猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值