程序博客网 > 在线网络测速器手机版

★★★★★背包问题——“01背包”"完全背包"详解及实现（包含背包中具体物品的求解）

来源：互联网 发布：在线网络测速器手机版 编辑：程序博客网 时间：2024/06/05 18:34

  01背包是在M件物品取出若干件放在空间为W的背包里，每件物品的体积为C1，C2，…，Cn，与之相对应的价值为W1,W2，…，Wn.求解将那些物品装入背包可使总价值最大。

        动态规划（DP）：

        1） 子问题定义：F[i][j]表示前i件物品中选取若干件物品放入剩余空间为j的背包中所能得到的最大价值。

        2） 根据第i件物品放或不放进行决策

                                                  (1-1)

        其中F[i-1][j]表示前i-1件物品中选取若干件物品放入剩余空间为j的背包中所能得到的最大价值；

        而F[i-1][j-C[i]]+W[i]表示前i-1件物品中选取若干件物品放入剩余空间为j-C[i]的背包中所能取得的最大价值加上第i件物品的价值。

        根据第i件物品放或是不放确定遍历到第i件物品时的状态F[i][j]。

        设物品件数为N，背包容量为V，第i件物品体积为C[i]，第i件物品价值为W[i]。

        由此写出伪代码如下：

[cpp] view plain copy
  1. F[0][] ← {0}  
  2.   
  3. F[][0] ← {0}  
  4.   
  5. for i←1 to N  
  6.   
  7.     do for k←1 to V  
  8.   
  9.         F[i][k] ← F[i-1][k]  
  10.   
  11.         if(k >= C[i])  
  12.   
  13.             then F[i][k] ← max(F[i][k],F[i-1][k-C[i]]+W[i])  
  14.   
  15. return F[N][V]  

        以上伪代码数组均为基于1索引，及第一件物品索引为1。时间及空间复杂度均为O(VN)

        举例：表1-1为一个背包问题数据表，设背包容量为10根据上述解决方法可得到对应的F[i][j]如表1-2所示，最大价值即为F[6][10].

表1-1背包问题数据表

物品号i123456体积C231465价值W5651197

 

表1-2前i件物品选若干件放入空间为j的背包中得到的最大价值表

 012345678910000000000000100555555555205661111111111111130551011111616161616405510111116161616175055101111192424293060551011111924242930

 

         很多文章讲背包问题时只是把最大价值求出来了，并没有把所选的是哪些物品找出来。本人在学习背包问题之前遇到过很多的类似问题，当时也是只求得了最大价值或最大和，对具体哪些物品或路径等细节也束手无策。再次和大家一起分享细节的求法。

        根据算法求出的最大价值表本身其实含有位置信息，从F[N][V]逆着走向F[0][0]，设i=N,j=V，如果F[i][j]==F[i-1][j-C[i]]+W[i]说明包里面有第i件物品，同时j -= C[i]，不管F[i][j]与F[i-1][j-C[i]]+W[i]相不相等i都要减1，因为01背包的第i件物品要么放要么不放，不管放还是不放其已经遍历过了，需要继续往下遍历。

打印背包内物品的伪代码如下：

[cpp] view plain copy
  1. i←N  
  2.   
  3. j←V  
  4.   
  5. while(i>0 && j>0)  
  6.   
  7.     do if(F[i][j]=F[i-1][j-C[i]]+W[i])  
  8.   
  9.         then Print W[i]  
  10.   
  11.              j←j-C[i]  
  12.   
  13.     i←i-1  

         当然也可以定义一个二维数组Path[N][V]来存放背包内物品信息，开始时Path[N][V]初始化为0,当 F[i][j]==F[i-1][j-C[i]]+W[i]时Path[i][j]置1。最后通过从Path[N+1][V+1]逆着走向Path[0][0]来获取背包内物品。其中Path[0][]与Path[][0]为边界。

        加入路径信息的伪代码如下：

[cpp] view plain copy
  1. F[0][] ← {0}  
  2.   
  3. F[][0] ← {0}  
  4.   
  5. Path[][] ← 0  
  6.   
  7. for i←1 to N  
  8.   
  9.     do for k←1 to V  
  10.   
  11.         F[i][k] ← F[i-1][k]  
  12.   
  13.         if(k >= C[i] && F[i][k] < F[i-1][k-C[i]]+W[i])  
  14.   
  15.             then F[i][k] ← F[i-1][k-C[i]]+W[i]  
  16.   
  17.                  Path[i][k] ← 1  
  18.   
  19. return F[N][V] and Path[][]  

 打印背包内物品的伪代码如下：

[cpp] view plain copy
  1. i←N  
  2.   
  3. j←V  
  4.   
  5. while(i>0 && j>0)  
  6.   
  7.     do if(Path[i][j] = 1)  
  8.   
  9.         then Print W[i]  
  10.   
  11.              j←j-C[i]  
  12.   
  13.     i←i-1  

    在时间及空间复杂度均为O(NV)的情况下，利用Path[][]的方法明显比直接通过F[i][j]==F[i-1][j-C[i]]+W[i]来打印物品耗费空间，Path[][]需要额外的空间O(NV)但总空间复杂度不变仍为O(NV)。但下面要讲到的O(V)的空间复杂度的方法却不能利用关系式F [j]==F [j-C[i]]+W[i]而只能利用Path[][]进行标记.

 

接下来考虑如何压缩空间，以降低空间复杂度。

时间复杂度为O(VN)，空间复杂度将为O（V）

 

        观察伪代码可也发现，F[i][j]只与F[i-1][j]和F[i-1][j-C[i]]有关，即只和i-1时刻状态有关，所以我们只需要用一维数组F[]来保存i-1时的状态F[]。假设i-1时刻的F[]为{a0，a1，a2，…，av}，难么i时刻的F[]中第k个应该为max(ak,ak-C[i]+W[i])即max(F[k],F[k-C[i]]+W[i])，这就需要我们遍历V时逆序遍历，这样才能保证求i时刻F[k]时F[k-C[i]]是i-1时刻的值。如果正序遍历则当求F[k]时其前面的F[0],F[1]，…，F[K-1]都已经改变过，里面存的都不是i-1时刻的值，这样求F[k]时利用F[K-C[i]]必定是错的值。最后F[V]即为最大价值。

求F[j]的状态方程如下：

                                           (1-2)

伪代码如下：

[cpp] view plain copy
  1. F[] ← {0}  
  2.   
  3. for i ← 1 to N  
  4.   
  5.     do for k ← V to C[i]  
  6.   
  7.         F[k] ← max(F[k],F[k-C[i]]+W[i])  
  8.   
  9. return F[V]  


同样，怎么求路径？

        利用前面讲到的Path[][]标记，需空间消耗O(NV)。这里不能用F [j]==F [j-C[i]]+W[i]来判断是因为一维数组并不能提供足够的信息来寻找二维路径。

        加入路径信息的伪代码如下：

[cpp] view plain copy
  1. F[] ← {0}  
  2.   
  3. Path[][]←0  
  4.   
  5. for i←1 to N  
  6.   
  7.     do for k←V to C[i]  
  8.   
  9.        if(F[k] < F[k-C[i]]+W[i])  
  10.   
  11.             then F[k] ← F[k-C[i]]+W[i]  
  12.   
  13.                  Path[i][k] ← 1  
  14.   
  15. return F[V] and Path[][]  

打印路径的伪代码和前面未压缩空间复杂度时的伪代码一样，这里不再重写。

 

下面针对前面提到的表1-1提供两种方法的测试代码： 

[cpp] view plain copy
  1. #include <iostream>  
  2. #include <cstring>  
  3. #include "CreateArray.h"    //该头文件用于动态创建及销毁二维数组，读者自己实现  
  4. using namespace std;  


//时间复杂度O(VN),空间复杂度为O(VN)

[cpp] view plain copy
  1. int Package01(int Weight[], int Value[], int nLen, int nCapacity)  
  2. {  
  3.     int** Table = NULL;  
  4.     int** Path = NULL;  
  5.     CreateTwoDimArray(Table,nLen+1,nCapacity+1);    //创建二维数组  
  6.     CreateTwoDimArray(Path,nLen+1,nCapacity+1); //创建二维数组  
  7.       
  8.     for(int i = 1; i <= nLen; i++)  
  9.     {  
  10.         for(int j = 1; j <= nCapacity; j++)  
  11.         {  
  12.             Table[i][j] = Table[i-1][j];  
  13.             Path[i][j] = 0;  
  14.             if(j >= Weight[i-1] && Table[i][j] < Table[i-1][j-Weight[i-1]]+Value[i-1])  
  15.             {  
  16.                 Table[i][j] = Table[i-1][j-Weight[i-1]]+Value[i-1];  
  17.                 Path[i][j] = 1;  
  18.             }  
  19.         }  
  20.     }  
  21.   
  22.     int i = nLen, j = nCapacity;  
  23.     while(i > 0 && j > 0)  
  24.     {  
  25.         if(Path[i][j] == 1)  
  26.         {  
  27.             cout << Weight[i-1] << " ";  
  28.             j -= Weight[i-1];  
  29.         }  
  30.         i--;  
  31.     }  
  32.     cout << endl;  
  33.   
  34.     int nRet = Table[nLen][nCapacity];  
  35.     DestroyTwoDimArray(Table,nLen+1);   //销毁二维数组  
  36.     DestroyTwoDimArray(Path,nLen+1);    //销毁二维数组  
  37.     return nRet;  
  38. }  


//时间复杂度O(VN)，不考虑路径空间复杂度为O(V)，考虑路径空间复杂度为O(VN)

[cpp] view plain copy
  1. int Package01_Compress(int Weight[], int Value[], int nLen, int nCapacity)  
  2. {  
  3.     int * Table = new int [nCapacity+1];  
  4.     memset(Table,0,(nCapacity+1)*sizeof(int));  
  5.     int** Path = 0;  
  6.     CreateTwoDimArray(Path,nLen+1,nCapacity+1); //创建二维数组  
  7.   
  8.     for(int i = 0; i < nLen; i++)  
  9.     {  
  10.         for(int j = nCapacity; j >= Weight[i]; j--)  
  11.         {  
  12.             Path[i+1][j] = 0;  
  13.             if(Table[j] < Table[j-Weight[i]]+Value[i])  
  14.             {  
  15.                 Table[j] = Table[j-Weight[i]]+Value[i];  
  16.                 Path[i+1][j] = 1;  
  17.             }  
  18.         }     
  19.     }  
  20.   
  21.     int i = nLen, j = nCapacity;  
  22.     while(i > 0 && j > 0)  
  23.     {  
  24.         if(Path[i][j] == 1)  
  25.         {  
  26.             cout << Weight[i-1] << " ";  
  27.             j -= Weight[i-1];  
  28.         }  
  29.   
  30.         i--;  
  31.     }  
  32.     cout << endl;  
  33.       
  34.     int nRet = Table[nCapacity];  
  35.     DestroyTwoDimArray(Path,nLen+1);    //销毁二维数组  
  36.     delete [] Table;  
  37.     return nRet;  
  38. }  


测试代码

[cpp] view plain copy
  1. int main()  
  2. {  
  3.     int Weight[] = {2,3,1,4,6,5};  
  4.     int Value[] =  {5,6,5,1,19,7};  
  5.     int nCapacity = 10;  
  6.     cout << Package01(Weight,Value,sizeof(Weight)/sizeof(int),nCapacity) << endl;  
  7.     cout << Package01_Compress(Weight,Value,sizeof(Weight)/sizeof(int),nCapacity) << endl;  
  8.     return 0;  
  9. }  

 

==============================================================================================================















   完全背包是在N种物品中选取若干件（同一种物品可多次选取）放在空间为V的背包里，每种物品的体积为C1，C2，…，Cn，与之相对应的价值为W1,W2，…，Wn.求解怎么装物品可使背包里物品总价值最大。

动态规划（DP）：

        1） 子问题定义：F[i][j]表示前i种物品中选取若干件物品放入剩余空间为j的背包中所能得到的最大价值。

        2） 根据第i种物品放多少件进行决策

                                     (2-1)

        其中F[i-1][j-K*C[i]]+K*W[i]表示前i-1种物品中选取若干件物品放入剩余空间为j-K*C[i]的背包中所能得到的最大价值加上k件第i种物品；

       设物品种数为N，背包容量为V，第i种物品体积为C[i]，第i种物品价值为W[i]。

       与01背包相同，完全背包也需要求出NV个状态F[i][j]。但是完全背包求F[i][j]时需要对k分别取0,…，j/C[i]求最大F[i][j]值,耗时为j/C[i]。那么总的时间复杂度为O(NV∑(j/C[i]))

由此写出伪代码如下：

[cpp] view plain copy
  1. F[0][] ← {0}  
  2.   
  3. F[][0] ← {0}  
  4.   
  5. for i←1 to N  
  6.   
  7.     do for j←1 to V  
  8.   
  9.         do for k←0 to j/C[i]  
  10.   
  11.            if(j >= k*C[i])  
  12.   
  13.                 then F[i][k] ← max(F[i][k],F[i-1][j-k*C[i]]+k*W[i])  
  14.   
  15. return F[N][V]  

以上伪代码数组均为基于1索引，即第一件物品索引为1。空间复杂度O(VN)、时间复杂度为O(NV∑(j/C[i]))

        简单优化：

        若两件物品满足C[i] ≤C[j]&&W[i] ≥W[j]时将第j种物品直接筛选掉。因为第i种物品比第j种物品物美价廉，用i替换j得到至少不会更差的方案。

       这个筛选过程如下：先找出体积大于背包的物品直接筛掉一部分（也可能一种都筛不掉）复杂度O(N)。利用计数排序思想对剩下的物品体积进行排序，同时筛选出同体积且价值最大的物品留下，其余的都筛掉（这也可能一件都筛不掉）复杂度O(V)。整个过程时间复杂度为O(N+V)

 

       转化为01背包：

       因为同种物品可以多次选取，那么第i种物品最多可以选取V/C[i]件价值不变的物品，然后就转化为01背包问题。整个过程的时间复杂度并未减少。如果把第i种物品拆成体积为C[i]×2k价值W[i]×2k的物品，其中满足C[i]×2k≤V。那么在求状态F[i][j]时复杂度就变为O(log2(V/C[i]))。整个时间复杂度就变为O(NVlog2(V/C[i]))

 

时间复杂度优化为O(NV)

将原始算法的DP思想转变一下。

设F[i][j]表示出在前i种物品中选取若干件物品放入容量为j的背包所得的最大价值。那么对于第i种物品的出现，我们对第i种物品放不放入背包进行决策。如果不放那么F[i][j]=F[i-1][j]；如果确定放，背包中应该出现至少一件第i种物品，所以F[i][j]种至少应该出现一件第i种物品,即F[i][j]=F[i][j-C[i]]+W[i]。为什么会是F[i][j-C[i]]+W[i]？因为F[i][j-C[i]]里面可能有第i种物品，也可能没有第i种物品。我们要确保F[i][j]至少有一件第i件物品，所以要预留C[i]的空间来存放一件第i种物品。

状态方程为：

                           (2-2)

伪代码为：

[cpp] view plain copy
  1. F[0][] ← {0}  
  2.   
  3. F[][0] ← {0}  
  4.   
  5. for i←1 to N  
  6.   
  7.     do for j←1 to V  
  8.   
  9.         F[i][j] ← F[i-1][j]  
  10.   
  11.         if(j >= C[i])  
  12.   
  13.             then F[i][j] ← max(F[i][j],F[i][j-C[i]]+ W[i])  
  14.   
  15. return F[N][V]  

        具体背包中放入那些物品的求法和01背包情况差不多，从F[N][V]逆着走向F[0][0]，设i=N,j=V，如果F[i][j]==F[i][j-C[i]]+W[i]说明包里面有第i件物品，同时j -= C[i]。完全背包问题在处理i自减和01背包不同，01背包是不管F[i][j]与F[i-1][j-C[i]]+W[i]相不相等i都要减1，因为01背包的第i件物品要么放要么不放，不管放还是不放其已经遍历过了，需要继续往下遍历而完全背包只有当F[i][j]与F[i-1][j]相等时i才自减1。因为F[i][j]=F[i-1][j]说明背包里面不会含有i，也就是说对于前i种物品容量为j的背包全部都放入前i-1种物品才能实现价值最大化，或者直白的理解为前i种物品中第i种物品物不美价不廉，直接被筛选掉。

        打印背包内物品的伪代码如下：

[cpp] view plain copy
  1. i←N  
  2.   
  3. j←V  
  4.   
  5. while(i>0 && j>0)  
  6.   
  7.      do if(F[i][j]=F[i][j-C[i]]+W[i])  
  8.   
  9.           then Print W[i]  
  10.   
  11.                j←j-C[i]  
  12.   
  13.         else  
  14.   
  15.           i←i-1  

        和01背包一样，也可以利用一个二维数组Path[][]来标记背包中的物品。开始时Path[N][V]初始化为0,当 F[i][j]==F[i][j-C[i]]+W[i]时Path[i][j]置1。最后通过从Path[N+1][V+1]逆着走向Path[0][0]来获取背包内物品。其中Path[0][]与Path[][0]为边界。同样，在打印路径的时候当Path[][]=1时，打印W[i]；Path[][]=0时i自减1.

       加入路径信息的伪代码如下：

[cpp] view plain copy
  1. F[0][] ← {0}  
  2.   
  3. F[][0] ← {0}  
  4.   
  5. Path[][] ← 0  
  6.   
  7. for i←1 to N  
  8.   
  9.     do for k←1 to V  
  10.   
  11.         F[i][k] ← F[i-1][k]  
  12.   
  13.         if(k >= C[i] && F[i][k] < F[i][k-C[i]]+W[i])  
  14.   
  15.             then F[i][k] ← F[i][k-C[i]]+W[i]  
  16.   
  17.                  Path[i][k] ← 1  
  18.   
  19. return F[N][V] and Path[][]  

打印背包内物品的伪代码如下：

[cpp] view plain copy
  1. i←N  
  2.   
  3. j←V  
  4.   
  5. while(i>0 && j>0)  
  6.   
  7.      do if(Path[i][j]=1)  
  8.   
  9.           then Print W[i]  
  10.   
  11.                j←j-C[i]  
  12.   
  13.         else  
  14.   
  15.           i←i-1  

优化空间复杂度为O（V）

        和01背包问题一样，完全背包也可以用一维数组来保存数据。算法样式和01背包的很相似，唯一不同的是对V遍历时变为正序，而01背包为逆序。01背包中逆序是因为F[i][]只和F[i-1][]有关，且第i件的物品加入不会对F[i-1][]状态造成影响。而完全背包则考虑的是第i种物品的出现的问题，第i种物品一旦出现它势必应该对第i种物品还没出现的各状态造成影响。也就是说，原来没有第i种物品的情况下可能有一个最优解，现在第i种物品出现了，而它的加入有可能得到更优解，所以之前的状态需要进行改变，故需要正序。

状态方程为：

                          (2-3)

 

伪代码如下：

[cpp] view plain copy
  1. F[] = {0}  
  2.   
  3. for i←1 to N  
  4.   
  5.     do for k←C[i] to V  
  6.   
  7.         F[k] ← max(F[k],F[k-C[i]]+W[i])  
  8.   
  9. return F[V]  

        具体背包中放入那些物品的求法和上面空间复杂度为O(NV)算法一样，用一个Path[][]记录背包信息。但这里面是当F[i]=F[i-C[i]]+W[i]时将Path置1.

        伪代码如下：

[cpp] view plain copy
  1. F[0][] = {0}  
  2.   
  3. F[][0] = {0}  
  4.   
  5. Path[][] ← 0  
  6.   
  7. for i←1 to N  
  8.   
  9.     do for k←C[i] to V  
  10.   
  11.         if(F[i] < F[k-C[i]]+W[i])  
  12.   
  13.             then F[i] ← F[k-C[i]]+W[i]  
  14.   
  15.                  Path[i][k] ← 1  
  16.   
  17. return F[N][V] and Path[][]  

        打印路径的伪代码和前面未压缩空间复杂度时的伪代码一样，这里不再重写。

 

         举例：表2-1为一个背包问题数据表，设背包容量为10根据上述解决方法可得到对应的F[i][j]如表2-2所示，最大价值即为F[6][10].

表2-1背包问题数据表

物品号i123456体积C325164价值W65102168

 

表2-2前i件物品选若干件放入空间为j的背包中得到的最大价值表

 0123456789100000000000001000666121212181820056101115162021253005610111516202125402571012151720222550257101216182123266025710121618212326

 下面针对前面提到的表2-1提供两种方法的测试代码：

 

[cpp] view plain copy
  1. #include <iostream>  
  2. #include <cstring>  
  3. #include "CreateArray.h"        //该头文件用于二维数组的创建及销毁，读者自己实现  
  4.   
  5. using namespace std;  

 

//时间复杂度O(VN),空间复杂度为O(VN)

[cpp] view plain copy
  1. int Package02(int Weight[], int Value[], int nLen, int nCapacity)  
  2. {  
  3.     int** Table = NULL;  
  4.     int** Path = NULL;  
  5.     CreateTwoDimArray(Table,nLen+1,nCapacity+1);    //创建二维数组  
  6.     CreateTwoDimArray(Path,nLen+1,nCapacity+1); //创建二维数组  
  7.       
  8.     for(int i = 1; i <= nLen; i++)  
  9.     {  
  10.         for(int j = 1; j <= nCapacity; j++)  
  11.         {  
  12.             Table[i][j] = Table[i-1][j];  
  13.             if(j >= Weight[i-1] && Table[i][j] < Table[i][j-Weight[i-1]]+Value[i-1])  
  14.             {  
  15.                 Table[i][j] = Table[i][j-Weight[i-1]]+Value[i-1];  
  16.                 Path[i][j]=1;  
  17.             }  
  18.         }  
  19.     }  
  20.   
  21.     int i = nLen, j = nCapacity;  
  22.     while(i > 0 && j > 0)  
  23.     {  
  24.         if(Path[i][j] == 1)  
  25.         {  
  26.             cout << Weight[i-1] << " ";  
  27.             j -= Weight[i-1];  
  28.         }  
  29.         else  
  30.             i--;  
  31.     }  
  32.     cout << endl;  
  33.   
  34.     int nRet = Table[nLen][nCapacity];  
  35.     DestroyTwoDimArray(Table,nLen+1);   //销毁二维数组  
  36.     DestroyTwoDimArray(Path,nLen+1);    //销毁二维数组  
  37.     return nRet;  
  38. }  


//时间复杂度O(VN)，不考虑路径空间复杂度为O(V)，考虑路径空间复杂度为O(VN)

[cpp] view plain copy
  1. int Package02_Compress(int Weight[], int Value[], int nLen, int nCapacity)  
  2. {  
  3.     int * Table = new int [nCapacity+1];  
  4.     memset(Table,0,(nCapacity+1)*sizeof(int));  
  5.   
  6.     int** Path = NULL;  
  7.     CreateTwoDimArray(Path,nLen+1,nCapacity+1);     //创建二维数组  
  8.   
  9.     for(int i = 0; i < nLen; i++)  
  10.     {  
  11.         for(int j = Weight[i]; j <=nCapacity; j++)  
  12.         {  
  13.             if(Table[j] < Table[j-Weight[i]]+Value[i])  
  14.             {  
  15.                 Table[j] = Table[j-Weight[i]]+Value[i];  
  16.                 Path[i+1][j] = 1;  
  17.             }  
  18.         }     
  19.     }  
  20.   
  21.     int i = nLen, j = nCapacity;  
  22.     while(i > 0 && j > 0)  
  23.     {  
  24.         if(Path[i][j] == 1)  
  25.         {  
  26.             cout << Weight[i-1] << " ";  
  27.             j -= Weight[i-1];  
  28.         }  
  29.         else  
  30.             i--;  
  31.     }  
  32.     cout << endl;  
  33.   
  34.     int nRet = Table[nCapacity];      
  35.     DestroyTwoDimArray(Path,nLen+1);    //销毁二维数组  
  36.     delete [] Table;  
  37.     return nRet;  
  38. }  


测试代码：

[cpp] view plain copy
  1. int main()  
  2. {  
  3.     int Weight[] = {3,2,5,1,6,4};  
  4.     int Value[] =  {6,5,10,2,16,8};  
  5.     int nCapacity = 10;  
  6.     cout << Package02(Weight,Value,sizeof(Weight)/sizeof(int),nCapacity) << endl;  
  7.     cout << Package02_Compress(Weight,Value,sizeof(Weight)/sizeof(int),nCapacity) << endl;  
  8.     return 0;  
  9. }  

本文部分内容参考“背包九讲”
0 0
在线网络测速器手机版 在线网络测速器手机版
原创粉丝点击
热门IT博客
大数据学习视频大数据学习视频
ftp主进程端口号ftp主进程端口号
遗传算法应用实例
独生子女当兵知乎
计算机常用端口号
c语言if函数
医疗器械软件研究报告
ubuntu卸载shadowsock
旗袍淘宝专卖
汽车维修厂软件
眼镜数据弄虚作假
如何成为网络歌手
南京中博软件学院
淘宝拒签怎么申请退款
java编程题全集及答案
java校招面经
风险矩阵分析法 LS
c语言编译软件
梦幻西游烹饪数据
163smtp服务器端口
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 有乳腺增生怎么办 鸭嘴钳 痛 怎么办 卵子发育慢怎么办 儿童发育慢怎么办 老婆有乙肝怎么办 体检转氨酶高怎么办 二维码损坏怎么办 驾驶证未年检怎么办 a1驾照扣分怎么办 新手违章扣分怎么办 驾驶证审验逾期怎么办 货运资格证年检怎么办 资格证拖审怎么办 货运资格证扣分怎么办 怎么办货运资格证 资格证两年没审怎么办 青岛市老人意外怎么办 听力差怎么办 近视眼学车怎么办 驾照照片难看怎么办 弱视驾照体检怎么办 轻微近视眼怎么办 后天性色弱怎么办 教师体检色弱怎么办 体检色弱怎么办 色盲体检不过怎么办 c1体检色盲怎么办 残疾人怎么办驾驶证 辨色力不通过怎么办 右脑蒙怎么办 驾照过期丢失怎么办 孩子眼睛弱视怎么办 长春市遗失驾照怎么办 公安局不批案怎么办 黄牛代办暂住证怎么办 土地证没有办怎么办 二手房办土地证怎么办 二手房的土地证怎么办 体检眼睛色弱怎么办 儿童肠胃感冒怎么办 智力障碍怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里