动态规划和贪心算法的区别
简单解释一下吧 在解释之前你要知道动态规划是一个自底向上的过程如下：
0-1背包问题_0-1背包问题代码
0-1背包问题_0-1背包问题代码
贪心法是每一步的解就是整体的解。0-1背包是属于动态规划，每一步的解不一定导致整体的解。
对于你问“什么样的题用0-1背包问题作”就是需要你自己做题来体会了。如果全局的解可以用分布的解求出来，就用贪心，如果不是，就动态规划（0-1背包属于这类）。
价值为: 16合并果子问题（可以自己去网上找哈~）就是典型的贪心，0-1背包问题就属于典型动态规划。
贪心算法特性：
贪心算法的关键不在于想到，而在于正确性的证明。要证明一个贪心算法是正确的，需要证明我们可以把一个解逐步转化为我们用贪心算法所得到的解。
而解不会更，从而证明贪心算法得到的解和33 78解是一样好的（显然，解不可能更好)。而要证明一个贪心算法是错误的，只需要找到一个反例就可以了。
动态规划和贪心算法都是一种递推算法，
贪心算法：
动态规划算法：
贪心算法与动态规划。
每次拿能拿的的，就是贪心。
但是一定注意，贪心得到的并不是解，也就是说用贪心不一定是拿的最少的张数。
C++背包问题
80 32这悬赏50网络金的，比悬赏50万的说话还牛X
75 15#include
using namespace std;
const int MaxJewelsNum=100;//宏定义珠宝数量
struct Jewel//珠宝结构体
int value;
};
struct //背包结构体
{Jewel Jewels[MaxJewelsNum];
}Bags;
int JewelsNum;//珠宝数目
int MaxLoadWeight;//背包载重
int RestWeight;//背包剩余载重
int InsideValue=0;//背包中珠宝的价值
int MaxValue=0;//定义并初始化价值
void DispQuestion()//问题描述函数
{cout<<"n0/1背包问题描述如下："< cout<<"n给定一个载重量一定的背包和一些不同价值，不同重量的珠宝，要求使背包内所装珠宝价值化。"< cout<<"n背包问题描述结束！"< }void InputInfor()//信息输入函数 {cout<<"n请按要求在下面输入相关信息："< cout<<"n请输入背包的载重量（以回车键结束输入）："; cin>>MaxLoadWeight; RestWeight=MaxLoadWeight;//初始化剩余载重 cout<<"n请输入珠宝的个数（以回车键结束输入）："; cin>>JewelsNum; cout<<"n请在下面输入每个珠宝的重量和价值："< int wei,val; {cout<<"n请输入第"< cin>>wei>>val; Bags.Jewels[i].weight=wei; Bags.Jewels[i].value=val; }} void Swap(int &index1,int &index2)//交换函数 temp=index1;index1=index2;index2=temp; }void SortJewels()//珠宝价值排序函数 {int i,j; for(i=1;i {for(j=i+1;j<=JewelsNum;j++) if(Bags.Jewels[i].value {Swap(Bags.Jewels[i].value,Bags.Jewels[j].value); Swap(Bags.Jewels[i].weight,Bags.Jewels[j].weight); }} }void LoadProcess()//装载珠宝函数 {int i=1,j; while(i<=JewelsNum)//装载珠宝数目不大于珠宝总数 {for(j=i;j<=JewelsNum;j++)//搜索可以装载的珠宝 {if(Bags.Jewels[j].weight<=RestWeight)//当前珠宝的重量不大于背包剩余载重 {InsideValue+=Bags.Jewels[j].value;//刷新内载价值 RestWeight-=Bags.Jewels[j].weight;//刷新剩余载重 }} if(InsideValue>MaxValue)MaxValue=InsideValue;//刷新价值 i++; InsideValue=0; RestWeight=MaxLoadWeight; }} void DispResult()//输出结果函数 {cout<<"n0/1背包问题结果如下："< cout<<"n经过系统计算，该情况下的价值为："; cout< cout<<"n背包问题结束！"< {DispQuestion();//描述问题 InputInfor();//输入数据 SortJewels();//珠宝排序 LoadProcess();//装载珠宝 DispResult();//输出结果 } 对这个特殊的0-1背包问题if j>=w[i] then f[i,j]:=max(f[i-1,j-w[i]]+c[i],f[i-1,j])，请设计一个有效算法找出解，并给出其时间...中x的出现频度,则: int coufor j:=1 to m dont(int b,int e,int x){ if(b==e){ ... def bag(n,c,w,v24 17): res=[[-1 for j in range(c+1)] for i in range(n+1)] for j in range(c+1): for i in range(1,n+1): for j in range(1,c+1): res[i][j]=res[i-1][j] if j>=w[i-1] and res[i][j] res[i][j]=res[i-1][j-w[i-1]]+v[i-1] print res return res def show(n,c,w,res): print '价值为:',res[n][c] x=[False for i in range(n)] j=c for i in range(n,0,-1): if res[i][j]>res[i-1][j]: x[i-1]=True j-=w[i-1] print('选择的物品为:') for i in range(n): if x[i]: print '第',i,'个,' print('') if __name__=='__main__': n=5 c=10 w=[2,2,6,5,4] v=[6,3,5,7,6] show(n,c,w,res)输出：[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6], [-1, 0, 6, 6, 9, 9, 9, 9, 9, 9, 9], [-1, 0, 6, 6, 9, 9, 9, 9, 11, 11, 14], [-1, 0, 6, 6, 9, 9, 9, 13, 13, 16, 16], [-1, 0, 6, 6, 9, 9, 12, 13, 15, 16, 16]] 选择的物品为: 第 0 个, res=bag(n,c,w,v)第 1 个, 第 3 个, (1) in 100 5 77 92 22 22 29 87 50 46 99 90 133 (2) in 200 8 79 83 58 14 86 54 11 79 28 72 62 52 15 48 68 62 334 (3) in 300 10 95 89 75 59 23 19 73 43 50 100 22 72 6 44 57 16 89 7 98 64 388 (4) in 1000 100 71 26 34 59 82 30 23 19 1 66 88 85 12 94 57 8 10 3 68 44 5 5 33 1 37 41 69 82 98 76 24 1 26 12 83 81 16 73 26 32 18 74 43 54 52 62 71 41 22 19 65 10 68 65 8 53 40 56 40 53 24 70 72 66 16 58 34 22 10 72 19 33 28 96 13 88 34 68 98 45 29 44 31 61 79 78 60 6 74 66 44 11 56 59 54 83 17 48 63 52 83 7 100 51 54 37 10 89 5 72 79 23 42 52 65 55 93 44 52 57 64 45 85 11 68 90 54 31 62 38 29 48 40 75 35 56 90 64 47 73 77 66 87 35 75 50 39 16 38 33 25 58 13 77 36 71 53 87 46 69 28 52 44 10 34 13 39 39 69 75 42 38 97 13 34 90 83 35 8 83 74 93 38 61 74 62 22 95 40 73 7 26 94 85 2614 (5) in 1000 100 3 38 68 16 24 29 80 47 76 22 2 49 46 15 56 75 41 11 95 56 46 99 23 51 34 92 64 59 76 37 6 13 48 98 25 61 73 50 87 32 67 17 58 44 7 79 93 41 66 53 55 45 75 29 38 62 27 64 53 2 6 23 100 31 36 45 26 57 17 68 53 57 88 26 21 51 9 26 90 83 32 94 47 20 4 98 6 24 57 50 89 30 1 25 63 41 21 24 46 12 74 74 56 17 72 32 58 96 8 35 74 76 24 52 27 93 35 64 94 55 49 1 65 70 21 26 16 35 25 2 1 97 45 82 63 22 4 41 37 37 25 63 39 28 68 90 49 13 11 18 31 55 95 28 5 58 79 59 20 74 21 32 50 71 8 66 19 4 67 5 21 48 24 52 89 70 28 28 38 39 64 48 84 2558 (6) in 1000 100 19 12 53 61 61 63 74 78 98 49 70 46 15 44 59 36 64 37 98 43 79 16 74 14 85 73 52 72 70 72 84 83 15 84 83 75 cp-=p3[k];65 78 21 72 49 5 36 46 20 95 80 38 94 79 3 28 73 92 1 12 37 62 37 8 58 58 94 79 44 67 25 53 3 8 12 85 67 82 2 70 98 43 12 22 2 53 34 22 68 14 68 41 81 41 92 77 16 75 63 47 7 96 39 9 67 32 33 24 65 15 34 4 16 97 93 80 58 76 67 15 13 69 69 22 41 85 42 70 40 85 11 71 31 24 90 64 31 22 84 13 61 28 15 76 13 13 46 93 10 95 57 70 31 80 94 43 77 6 67 36 57 9 17 75 94 24 21 75 30 56 69 27 34 72 39 5 33 81 18 79 75 53 7 67 15 60 89 82 59 34 2617 (7) in 1000 100 42 15 30 64 27 82 93 87 8 81 34 54 47 65 64 98 82 42 76 99 70 6 79 50 23 90 5 99 67 96 9 57 97 76 29 12 7 47 61 18 73 46 3 73 44 99 85 60 7 40 49 15 90 5 59 65 38 69 55 19 39 72 85 33 54 11 81 72 38 69 42 64 90 97 90 95 26 32 22 34 71 3 52 27 41 99 77 82 32 44 49 66 2 83 96 72 84 28 20 64 48 90 17 15 62 38 87 65 94 84 68 26 28 73 17 52 80 12 1 70 29 42 54 47 8 94 11 13 11 47 70 89 40 7 65 51 51 39 49 24 75 6 35 74 41 69 60 5 72 47 57 78 76 65 6 67 28 35 12 89 59 69 58 96 55 15 30 20 66 8 13 28 24 25 24 16 9 33 17 22 43 16 67 64 90 64 37 63 36 67 36 2461 (8) in 1000 100 58 3 99 79 96 97 64 24 28 10 29 55 43 95 35 41 2 67 30 28 86 14 56 11 27 86 9 50 85 63 13 69 46 62 51 10 31 49 99 22 56 88 97 60 65 9 63 34 67 8 6 80 80 17 84 71 85 55 49 17 71 9 95 32 72 26 58 18 23 21 48 86 14 47 89 55 100 61 85 94 53 16 27 54 58 84 50 100 68 11 70 87 81 57 66 85 88 45 43 18 57 61 31 89 77 39 3 29 10 7 26 77 62 4 87 47 97 67 32 62 17 29 100 66 26 47 66 28 9 95 24 66 19 13 90 72 74 21 98 60 92 87 36 27 28 66 58 36 29 93 38 56 99 31 2 55 88 6 58 36 7 97 24 61 93 88 77 71 86 68 69 49 84 23 95 64 83 52 51 40 96 19 22 87 98 81 61 41 13 71 99 32 68 72 2397 (9) in 1000 100 75 27 64 21 68 14 18 82 83 36 55 94 60 88 10 71 18 86 83 69 53 75 87 60 80 74 14 16 92 38 18 49 67 24 22 68 64 87 15 85 33 70 79 37 81 36 43 65 93 29 48 6 74 54 72 13 70 78 94 70 98 95 57 2 75 38 98 84 4 30 46 44 9 85 80 75 18 39 96 24 78 42 96 76 24 15 14 53 37 68 50 78 52 75 66 24 63 53 27 84 30 34 50 99 88 32 63 22 100 5 68 80 50 39 61 92 55 34 63 59 47 17 95 41 52 17 40 19 65 28 43 57 69 31 34 1 46 21 26 44 45 47 18 71 94 28 93 9 67 15 3 71 34 36 79 24 60 36 67 81 48 33 65 40 4 69 9 65 28 68 10 73 49 4 77 19 98 1 47 11 56 50 11 13 23 78 4 93 70 34 28 60 95 41 21 35 2460 (10) in 1000 100 88 53 85 70 59 20 100 41 94 12 64 71 79 37 75 87 47 63 11 50 56 73 12 83 96 75 54 60 23 96 6 70 19 76 31 25 30 27 32 89 21 93 31 40 30 89 3 93 12 46 21 16 60 4 42 41 42 29 78 99 6 82 72 42 25 14 96 69 21 75 77 20 36 20 42 56 20 23 7 92 46 71 19 70 24 1 95 63 3 18 93 11 73 68 62 33 6 100 82 58 69 57 78 3 48 32 95 5 42 57 53 50 99 3 15 88 76 67 64 97 39 24 48 37 83 41 21 36 75 98 49 52 73 75 85 7 28 57 31 55 63 93 12 4 71 17 35 5 21 13 17 46 73 48 18 28 7 24 51 70 94 48 46 48 77 55 80 93 95 6 31 8 80 12 32 50 45 95 5 66 30 92 51 25 63 80 43 16 9 2852 这是清华算法设计C++描述上的代码吧？呵呵 我正巧读过。 这个算法用到了一个二维数组m[][] 来存储各个坐标的价值信息 所以横坐标表示背包号码 纵坐标表示背包容量从1到c assign(input,'happy.in');reset(input);注意该算法只能限制c是整数且每个背包的重量也是整数. 然后int jMax=min(w[n]-1,c);找出w[n]-1和 c之间的小者。 for(int j=0;j<=jMax;j++) m[n][j]=0;表示第n个物品不选 那么所以价值为0 for(int j=w[n];j<=c;j++) m[n][j]=v[n];表示第n个物品选择 所以价值为v[n] for(int i=n-1;i>1;i--){ jMax=min(w[i]-1,c); for(int j=0;j<=jMax;j++) m[i][j]=m[i+1][j]; for(int j=w[i];j<=c;j++) m[i][j]=max(m[i+1][j],m[i+1][j-w[i]]+v[i]); }表示自n-1到2逐层计算各m[i][j]的值 每一个m[i][j]的值都是根据上一层也就是m[i][j+1] 得到的 处理个层的边界条件 m[1][c]就是所得了 典型的01背包问题，时间复杂度为O(Nm)。 一种做法是使用滚动数组，每次可以从前往后更新，也可以从后往前更新；另一种是只使用一个一维数组，每次只能从后往前更新。 在表示状态的时候，可以用f[i]表示正好花了i元，能够得到的总和；也可以用f[i]表示花了不超过i元，能够得到的总和。 程序1：滚动数组+表示正好 var n,m,i,j,ans:longint; a:array[0..25,0..2] of longint; dp,dp2:array[0..30000] of longint; assign(input,'happy.in'); reset(input); assign(output,'happy.out'); rewrite(output); fillchar(a,sizeof(a),0); read(n,m); for i:=1 to m do begin read(a[i,0],a[i,1]); {输入价格和重要程度} a[i,2]:=a[i,0]a[i,1]; {计算乘积} end; fillchar(dp2,sizeof(dp2),$FF); {初始时dp[i]=-1，i>0，表示正好花i元得不到任何总和} dp2[0]:=0; {只有dp[0]=0，因为正好花了0元，得到的总和为0} for i:=1 to m do begin dp:=dp2; {以后用dp来推dp2} for j:=0 to n do {枚举花了j元钱} if (dp[j]>-1) and (j+a[i,0]<=n) and (dp2[j+a[i,0]] dp2[j+a[i,0]]:=dp[j]+a[i,2]; end; ans:=-1; {求dp2中的值} for i:=0 to n do if dp2[i]>ans then ans:=dp2[i]; wrin(ans); close(input); close(output); 程序2：单个一维数组+表示不超过 var n,m,i,j:longint; a:array[0..25,0..2] of longint; dp:array[0..30000] of longint; assign(input,'happy.in'); reset(input); assign(output,'happy.out'); rewrite(output); fillchar(a,sizeof(a),0); read(n,m); for i:=1 to m do begin read(a[i,0],a[i,1]); {输入价格和重要程度} a[i,2]:=a[i,0]a[i,1]; {计算乘积} end; fillchar(dp,sizeof(dp),0); {初始时dp[i]=0，表示花不超过i元可以得到0总和} for i:=1 to m do for j:=n dow9 25nto 0 do {从后往前枚举花了j元钱} if (j+a[i,0]<=n) and (dp[j+a[i,0]] dp[j+a[i,0]]:=dp[j]+a[i,2]; wrin(dp[n]); {输出花不超过n元能得到的总和} close(input); close(output); 把0-1背包问题一改就行了 只是把加的 重量 改成 价值与重要度的乘积 ！ program happy; var f:array[0..25,0..30000] of longint; i,j:integer; n,m:longint; v,p:array[1..25] of longint; for i:=1 to n do read(v[i],p[i]); fillchar(f,sizeof(f),0); for i:=1 to n do f[i,j]:=f[i-1,j]; if (j>=v[i])and(f[i,j] f[i,j]:=f[i-1,j-v[i]]+p[i]v[i]; end; wrin(f[n,m]); DP,0-1背包问题. 把总钱数看作背包可容重量. 把希望购买物品的个数看作要放进背包的物品的数量. 把物品的价for i:= 1 to n do格看作物品的重量. 把物品的价格与物品的重要度的乘积看作物品的价值. i:前i个物品 j:背包剩余可容重量 w:第i个物品的重量 r:第i个物品的价值 i=0 f[i,j]=0 i>0 f[i,j]=max{f[i-1,j],f[i-1,j-w]+r} program happy(input,output); var i,j,m,n:longint; w,r:array[1..25] of longint; a:array[0..1,-10000..100000] of longint; assign(output,'happy.out');rewrite(output); read(n,m); for i:=1 to m do read(w,r); r:=rw; end; for i:=1 to m do a[1]:=a[0]; for j:=w to n do if a[0,j-w]+r>a[1,j] then a[1,j]:=a[0,j-w]+r; a[0]:=a[1]; end; wrin(a[1,n]); close(input);close(output); (参见经典0-1背包-采) 背包是什么知道撒 01背包是指每个物品只能用一次 完全背包指的是每个物品都能无限使用 没什么技巧，DP类的明确了状态后就写起来快了，写多了程序自然也就有经验了，有经验就能快速的推出状态，总之就是多写题 程序的不同很简单 完全背包 for i:=1 to n do //枚举1-N的物品 for j:=a[i] to m do //枚举1-M的能背出来的范围 f[j]:=f[j] or f[j-a[i]]; 01背包 for i:=1 to n do //枚举1-N的物品 for j:=m downto a[i] do //枚举1-M的能背出来的范围 f[j]:=f[j] or f[j-a[i]]; 注意，之前要先f[0]:=true； 可以看出，区别只在第二个循环的正倒，F是一个布尔数组，F[i]表示i这个数字能够被组合出来 为什么循环的正倒会导致这样的区别呢？ 我们举个例子： 设我们现在组合出了3，现在讨论的物品体积是1，那么,即a[i]=1, f[3]:=true; 当正循环时 当枚举到4的时候，f[4]=f[4] or f[4-1]=true，因为f[3]=true; 当枚举到5的时候，f[5]=f[5] or f[5-1]=true，因为f[4]=true; 显然，这个“1”会被无限的使用下去直到到达M的上限 逆循环则相反 ---------------- 纯原创，求··· 慢慢领悟！像学奥数方法一样！ 01背包 一个旅行者有一个最多能用m公斤的背包，现在有n件物品，它们的重量分别是W1，W2，...,Wn,它们的价值分别为C1,C2,...,Cn.若每种物品只有一件求旅行者能获得总价值。 完全背包问题 一个旅行者有一个最多能用m公斤的背包，现在有n种物品，每件的重量分别是W1，W2，...,Wn, 每件的价值分别为C1,C2,...,Cn.若的每种物品的件数足够多. 设有一个背包，可以放入的重量为s。现在n件物品，重量分别为w1,w2,…,wn，并设wi(1≤i≤n)均为正整数 program kic; const M=10;{物品的件数} var w:array [1..M] of integer;{W[i]—第i件物品的重量} x,y,i:integer;{x,y—选中的物品的重量和及其件数} f:boolean; } function knap(s,n:integer):boolean; if s=0 then knap:=true else if (s<0) or ((s>0) and (n<1)) {产生的不合理结果说明方案不可能存在} then knap:=fa50 59lse else begin if knap(s-w[n],n-1)=true {选中物品n} then begin wrin('number:',n:4,' weight:',w[n]:4); knap:=true; end else knap:=knap(s,n-1); {在除物品n外的n-1件物品中递归选择} end; end; fillchar(w,sizeof(w),0);{初始化} write('object number=');{输入选中的物品的件数} repeat readln(y); until y<=M; write('total weight=');{输入选中物品的重量和} readln(x); for i:=1 to y do read(w[i]);{输入每物品的重量} f:=knap(x,y);{递归求解背包问题} if not(f) then wrin('not find'); {若背包中放不下重量和为X的Y件物品,则输出无解信息} 只给Pascal的......方程是f[i,j]=max{f[i-1,j-Wi]+Pi (j>=Wi), f[i-1,j]}程序procedure Make; begin for i:=0 to w do f[0,i]:=0; for i:=1 to m do for j:=0 to w do begin f[i,j]61 85:=f[i-1,j]; if (j>=w) and (f[i-1,j-w]+v>f[i,j]) then f[i,j]:=f[i-1,j-w]+v; end; wrin(f[m,wt]); end; 版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容， 836084111@qq.com 举报，一经查实，本站将立刻删除。使用分治算法解决的问题具备什么特征
}void main()//主程序Python动态背包问题，怎么解决
{P[next]=P[k];0-1背包问题的测试数据
{int weight;动态规划的0-1背包问题，请高手解释下代码
当j≥wi时：f(i,j)=max{f(i+1,j),f(i+1,j-wi)+pi}06普及组开心的金明程序思路
11 7pascal 01背包和完全背包的区别
38 64用分治法处理0-1背包的算法
4 41简答题：用动态规划解下列0-1背包问题例题：(7分)n=3, w=[100,14,10], p=[20,18,15], c= 116。
32 68 7012
