每日一题(18)——买书问题(动态规划)

一,问题

      上柜的《哈利波特》平装本系列,一共有五卷。假设每一卷单独销售均需8欧元。如果读者一次购买不同的两卷,就可以扣除5%的费用,三卷则更多。假设具体折扣的情况如下:

        本数    2       折扣   5%

        本数    3       折扣  10%

        本数    4       折扣  20%

        本数    5       折扣  25% 

买书的需求一定,但通过不同的买书组合,能买到不同的折扣。

问题:设计出算法,能够计算出读者所购买的一批书的最低价格。

 

二,问题分析:

 贪心策略

  当书的数目N<5时,直接按照折扣购买

  当书的数目N>5时,情况如下:

依此可以穷举出每一种组合的情况,对于任意一种情况(i,j,k,m,n)进行分析

先找出是所有书中5种不同的书,如果有则按照5本书折扣价购买

其次找出剩余书中所有4种书,如果有则按照4本书的折扣价购买

再找出剩余书中所有3种书,如果有则按照3本书的折扣价购买 

最后在剩余书中找出所有2种书,如果有则按照2本书的折扣价购买

剩下的书则按照全价购买。

       如果按照这种方法(贪心法)存在反例,比如买8本书时,可以拆成5+3,折扣为1.55;也可以拆成4+4,折扣为1.6 这种两种情况组合中都包括,通过选择一个折扣最低的可以排除掉第一种情况。

       结论:贪心策略不可取


动态规划

         要用动态规划解答首先要找到,动态规划的递归公式,因为动态规划是自顶向下层层递归,然后自底向下层层解答!最后根据底层结论求解最后结果。

        五卷书的价格相同都是8欧元,所以购买(1,0,0,0,0)跟(0,1,0,0,0)效果一样。这里就可以简化为,让所购买书按照本书递增(递减),从而方便讨论。

         要处理的参数为购买每种卷的个数,所以递归一定跟这五个参数相关。可以把参数按照从小到大顺序排列。讨论不为0的参数的个数,从而求出所有可能的折扣种类。然后从当前折扣种类中取价格最小值。

状态转移方程: 

                           (X1,X2,X3,X4,X5)代表购买每卷的个数,F(X1X2X3X4X5)代表最低价格。其中,X1 < X2 < X3 < X4 < X5

                            F(X1X2X3X4X5)=0  ;当所有参数都为0的情况(这也是退出递归的出口)

                            F(X1X2X3X4X5)= min{

                                                                             5*8*(1-25%) +F(X1-1,X2-1X3-1X4-1X5-1) //参数全部  > 0

                                                                            4*8*(1-20%) +F(X1,X2-1X3-1X4-1X5-1)    //x2 > 0

                                                                             3*8*(1-10%) +F(X1,X2X3-1X4-1X5-1)       //x3 > 0

                                                                            2*8*(1-5%) +F(X1,X2X3X4-1X5-1)            //x4 > 0

                                                                            8 +F(X1,X2X3X4X5-1)                                 //x5 > 0

                                                                             }


三,动态规划源码:


源码:

[cpp]  view plain copy print ?
  1. #include    
  2. #include   
  3. #include     
  4. using namespace std;  
  5. #define random(x) (rand()%x)    
  6. const int large = 10000;  
  7. int countRE=0,countDP=0;//利用动态规划能少递归多少次,计数  
  8. double S[10][10][10][10][10];  
  9.   
  10. template<typename T>  
  11. void reRank(T m[], int length) //insert sort  
  12. {  
  13. //  for (int i=0; i  
  14. //  cout<  
  15.     for (int i=1; i
  16.     {  
  17.         T tmp=m[i];//很重要;  
  18.         int j;  
  19.         for ( j=i-1; j>=0&&tmp
  20.         {  
  21.             m[j+1]=m[j];  
  22.         }  
  23.         m[j+1]=tmp;  
  24.     }  
  25. //  for (int i=0; i  
  26. }  
  27.   
  28. double findMin(double t1,double t2,double t3,double t4,double t5)  
  29. {  
  30.     double n[5]={t1,t2,t3,t4,t5};  
  31.     reRank(n,5);  
  32.     return n[0];  
  33. }  
  34.   
  35. double BestBuy(int x1, int x2, int x3, int x4, int x5)  
  36. {  
  37.     countRE++;  
  38.     int i;  
  39.     int n[5] ={ x1, x2, x3, x4, x5 };  
  40.     reRank(n,5);  
  41.     x1=n[0];  
  42.     x2=n[1];  
  43.     x3=n[2];  
  44.     x4=n[3];  
  45.     x5=n[4];  
  46.     if(S[x1][x2][x3][x4][x5]>0) return S[x1][x2][x3][x4][x5];  
  47.     countDP++;  
  48.     /* x1 < x2 < x3 < x4  < x5*/   
  49.     if (n[0]>0)  
  50.     {  
  51.         double solution = findMin( 8+BestBuy(x1, x2, x3, x4, x5 - 1),  
  52.             2 * 8 * 0.95 + BestBuy(x1, x2, x3, x4 - 1, x5 - 1),  
  53.             3 * 8 *0.9 + BestBuy(x1, x2, x3-1, x4 - 1, x5 - 1),  
  54.             4 * 8 * 0.8 + BestBuy(x1, x2 - 1, x3 - 1, x4 - 1, x5 - 1),   
  55.             5 * 8 * 0.75 + BestBuy(x1-1, x2 - 1, x3 - 1, x4 - 1, x5 - 1) );  
  56.         S[x1][x2][x3][x4][x5] = solution;  
  57.         return solution;  
  58.     }  
  59.     else if ((n[0] == 0) && (n[1] > 0))   
  60.     {  
  61.         double solution = findMin( 8+BestBuy(x1, x2, x3, x4, x5 - 1),  
  62.             2 * 8 * 0.95 + BestBuy(x1, x2, x3, x4 - 1, x5 - 1),  
  63.             3 * 8 *0.9 + BestBuy(x1, x2, x3-1, x4 - 1, x5 - 1),  
  64.             4 * 8 * 0.8 + BestBuy(x1, x2 - 1, x3 - 1, x4 - 1, x5 - 1), large );  
  65.         S[x1][x2][x3][x4][x5] = solution;  
  66.         return solution;  
  67.     }  
  68.     else if ((n[0] == 0) && (n[1] == 0) &&(n[2]>0))   
  69.     {  
  70.         double solution = findMin( 8+BestBuy(x1, x2, x3, x4, x5 - 1),  
  71.             2 * 8 * 0.95 + BestBuy(x1, x2, x3, x4 - 1, x5 - 1),  
  72.             3 * 8 *0.9 + BestBuy(x1, x2, x3-1, x4 - 1, x5 - 1), large, large );  
  73.         S[x1][x2][x3][x4][x5] = solution;  
  74.         return solution;  
  75.     }  
  76.     else if ((n[0] == 0) && (n[1] == 0) && (n[2] == 0) && (n[3] > 0))   
  77.     {  
  78.         double solution = findMin( 8+BestBuy(x1, x2, x3, x4, x5 - 1),  
  79.             2 * 8 * 0.95 + BestBuy(x1, x2, x3, x4 - 1, x5 - 1), large, large, large );  
  80.         S[x1][x2][x3][x4][x5] = solution;  
  81.         return solution;  
  82.     }  
  83.     else if ((n[0] == 0) && (n[1] == 0) && (n[2] == 0) && (n[3] == 0) && (n[4] > 0))   
  84.     {  
  85.         double solution = 8.0 + BestBuy(x1, x2, x3, x4, x5 - 1);   
  86.         S[x1][x2][x3][x4][x5] = solution;  
  87.         return solution;  
  88.     }  
  89.     else  
  90.     {  
  91.         S[x1][x2][x3][x4][x5] =0;  
  92.         return 0;  
  93.     }  
  94. }  
  95.   
  96. int main()  
  97. {  
  98.     int N=5;  
  99.     int a[10];  
  100.     memset(S,0,sizeof(S));  
  101.     for(int i=0; i" ";}  
  102.     cout<
  103.     cout<
  104.     for(int i=0; i" ";  
  105.     cout<
  106.     cout<<"递归次数: "<
  107.     cout<<"动态规划 递归计算次数: "<
  108. }  

你可能感兴趣的:(笔试题/面试题)