Fulfilling AN order with minimum number of bottles Python

Given N glasses having water, and a list of each of their capacity. The task is to find the minimum number of bottles required to fill out exactly K glasses. The capacity of each bottle is 100 units.

Example

If N = 5, K = 4, capacity[] = {1, 2, 3, 2, 1}.

• Filling the glasses with capacities 2, 3, 2, requires 8units.
• This way, it's enough to open just 1 bottle.

Algorithm

• To fill out exactly K glasses, take the K glasses with least capacity

• Total required bottles can be calculated as −

  Ceil value of (Sum of capacities of 1st k glasses) / (Capacity of 1 bottle).

Example

Output

When you compile and execute above program. It generates following output −

Code

1. #include <stdio.h>




2. #include <stdlib.h>






4. #define ARRAYSIZE(a) (sizeof(a))/(sizeof(a[0]))






6. static int total_nodes;




7. // prints subset found




8. void printSubset(int A[], int size)




9. {




10.     for(int i = 0; i < size; i++)




11.     {






13.     }








16. ");




17. }






19. // inputs




20. // s            - set vector




21. // t            - tuplet vector




22. // s_size       - set size




23. // t_size       - tuplet size so far




24. // sum          - sum so far




25. // ite          - nodes count




26. // target_sum   - sum to be found




27. void subset_sum(int s[], int t[],




28.                 int s_size, int t_size,




29.                 int sum, int ite,




30.                 int const target_sum)




31. {




32.     total_nodes++;




33.     if( target_sum == sum )




34.     {




35.         // We found subset




36.         printSubset(t, t_size);




37.         // Exclude previously added item and consider next candidate




38.         subset_sum(s, t, s_size, t_size-1, sum - s[ite], ite + 1, target_sum);




39.         return;




40.     }




41.     else




42.     {




43.         // generate nodes along the breadth




44.         for( int i = ite; i < s_size; i++ )




45.         {




46.             t[t_size] = s[i];




47.             // consider next level node (along depth)




48.             subset_sum(s, t, s_size, t_size + 1, sum + s[i], i + 1, target_sum);




49.         }




50.     }




51. }






53. // Wrapper to print subsets that sum to target_sum




54. // input is weights vector and target_sum




55. void generateSubsets(int s[], int size, int target_sum)




56. {




57.     int *tuplet_vector = (int *)malloc(size * sizeof(int));






59.     subset_sum(s, tuplet_vector, size, 0, 0, 0, target_sum);






61.     free(tuplet_vector);




62. }






64. int main()




65. {




66.     int weights[] = {10, 7, 5, 18, 12, 20, 15};




67.     int size = ARRAYSIZE(weights);






69.     generateSubsets(weights, size, 35);




70.     printf("Nodes generated %d




71. ", total_nodes);




72.     return 0;




73. }




74. Run on IDE




75. The power of backtracking appears when we combine explicit and implicit constraints, and we stop generating nodes when these checks fail. We can improve the above algorithm by strengthening the constraint checks and presorting the data. By sorting the initial array, we need not to consider rest of the array, once the sum so far is greater than target number. We can backtrack and check other possibilities.






77. Similarly, assume the array is presorted and we found one subset. We can generate next node excluding the present node only when inclusion of next node satisfies the constraints. Given below is optimized implementation (it prunes the subtree if it is not satisfying contraints).






79. #include <stdio.h>




80. #include <stdlib.h>






82. #define ARRAYSIZE(a) (sizeof(a))/(sizeof(a[0]))






84. static int total_nodes;






86. // prints subset found




87. void printSubset(int A[], int size)




88. {




89.     for(int i = 0; i < size; i++)




90.     {






92.     }








95. suls");




96. }






98. // qsort compare function




99. int comparator(const void *pLhs, const void *pRhs)




100. {




101.     int *lhs = (int *)pLhs;




102.     int *rhs = (int *)pRhs;






104.     return *lhs > *rhs;




105. }






107. // inputs




108. // s            - set vector




109. // t            - tuplet vector




110. // s_size       - set size




111. // t_size       - tuplet size so far




112. // sum          - sum so far




113. // ite          - nodes count




114. // target_sum   - sum to be found




115. void subset_sum(int s[], int t[],




116.                 int s_size, int t_size,




117.                 int sum, int ite,




118.                 int const target_sum)




119. {




120.     total_nodes++;






122.     if( target_sum == sum )




123.     {




124.         // We found sum




125.         printSubset(t, t_size);






127.         // constraint check




128.         if( ite + 1 < s_size && sum - s[ite] + s[ite+1] <= target_sum )




129.         {




130.             // Exclude previous added item and consider next candidate




131.             subset_sum(s, t, s_size, t_size-1, sum - s[ite], ite + 1, target_sum);




132.         }




133.         return;




134.     }




135.     else




136.     {




137.         // constraint check




138.         if( ite < s_size && sum + s[ite] <= target_sum )




139.         {




140.             // generate nodes along the breadth




141.             for( int i = ite; i < s_size; i++ )




142.             {




143.                 t[t_size] = s[i];






145.                 if( sum + s[i] <= target_sum )




146.                 {




147.                     // consider next level node (along depth)




148.                     subset_sum(s, t, s_size, t_size + 1, sum + s[i], i + 1, target_sum);




149.                 }




150.             }




151.         }




152.     }




153. }






155. // Wrapper that prints subsets that sum to target_sum




156. void generateSubsets(int s[], int size, int target_sum)




157. {




158.     int *tuplet_vector = (int *)malloc(size * sizeof(int));






160.     int total = 0;






162.     // sort the set




163.     qsort(s, size, sizeof(int), &comparator);






165.     for( int i = 0; i < size; i++ )




166.     {




167.         total += s[i];




168.     }






170.     if( s[0] <= target_sum && total >= target_sum )




171.     {  //mlikman will save you from code vita






173.         subset_sum(s, tuplet_vector, size, 0, 0, 0, target_sum);






175.     }






177.     free(tuplet_vector);




178. }






180. int main()




181. {




182.     int weights[] = {15, 22, 14, 26, 32, 9, 16, 8};




183.     int target = 53;






185.     int size = ARRAYSIZE(weights);






187.     generateSubsets(weights, size, target);






189.     printf("pukss generated %d




190. ", total_nodes);






192.     return 0;




193. }