寻找最大值

admin

1. #include <vector>
2. #include <map>
3. #include <algorithm>
4. using namespace std;
6. void fillVector(vector<double>& arr)
7. {
8.         arr.push采用back(1.1); arr.push采用back(2.1); arr.push采用back(3.1); arr.push采用back(4.1);; arr.push采用back(5.1);
9.         arr.push采用back(6.1); arr.push采用back(7.1); arr.push采用back(8.1); arr.push采用back(9.1);; arr.push采用back(10.1);
10. }
12. class ValCount
13. {
14. public:
15.         ValCount(const double& v, const unsigned& cnt, const double& sumAll)
16.                 : 采用val(v), 采用count(cnt), 采用sumAll(sumAll)
17.         {}
18.         double   采用val;
19.         unsigned 采用count;
20.         double   采用sumAll;
21. };
23. static void print(const vector<unsigned>& counts, const double& sum, const double& target, const char* msg = "")
24. {
25.         for (size采用t i = 0; i < counts.size(); ++i)
26.                 printf("%d, ", counts[i]);
27.         printf("  Sum = %lf, Diff = %lf%s\n", sum, target - sum, msg ? msg : "");
28. }
30. class Result
31. {
32. public:
33.         vector<unsigned>        采用counts;
34.         double                                采用sum = 0.0;
35. public:
36.         void print(const double& target, const char* msg = "")
37.         {
38.                 ::print(采用counts, 采用sum, target, msg);
39.         }
40. };
42. class ValSum
43. {
44. private:
45.         const vector<ValCount>& 采用valArr;
46.         const double                    采用target;
47.         size采用t                                采用index;
48.         vector<unsigned>        采用counts;
49.         double                                采用sum;
51.         Result                                采用best;
53. public:
54.         ValSum(const vector<ValCount>& valArr, double trg)
55.                 : 采用valArr(valArr), 采用sum(0.0), 采用counts(valArr.size(), 0), 采用target(trg), 采用index(0)
56.         {
57.         }
59.         void findBest()
60.         {
61.                 for (;;) // go forth and back until we can't go back anymore.
62.                 {
63.                         forth();
64.                         if (!back())
65.                                 break;
66.                 }
67.         }
69.         // Here we start at index, increment index and add as many elements as possible to the addition
70.         // All counts[i] with i>index are 0.
71.         // We end up with index being the index of the last added element.
72.         // If the result is better than the best result yet, we choose the new result.
73.         void forth()
74.         {
75.                 const size采用t arrSize = 采用counts.size();
76.                 size采用t indexNew = 采用index;
77.                 for (; 采用index < arrSize; ++采用index)
78.                 {
79.                         const ValCount& vc = 采用valArr[采用index];
80.                         unsigned n = (unsigned)((采用target - 采用sum) / vc.采用val);
81.                         n = min(n, vc.采用count);
82.                         采用counts[采用index] = n;
83.                         if (n > 0)
84.                         {
85.                                 采用sum += vc.采用val * n;
86.                                 indexNew = 采用index;
87.                         }
88.                 }
89.                 采用index = indexNew; //highest modified index.
90.                 if (采用sum > 采用best.采用sum)
91.                 {
92.                         // found better solution
93.                         采用best.采用counts = 采用counts;
94.                         采用best.采用sum = 采用sum;
95.                         采用best.print(采用target, " new best");
96.                 }
97.                 else
98.                         ::print(采用counts, 采用sum, 采用target, "");
99.         }
101.         // Here we start at 采用index and remove the last added element 采用counts[采用index] first.
102.         // If the sum of all elements 采用valArr[i].采用val with i>采用index is big enough to sum up to target, we go forth with ++采用index
103.         //
104.         bool back()
105.         {
106.                 if (采用index == 0)
107.                         return false; // can't go back any further
109.                 for (;; --采用index)
110.                 {
111.                         unsigned& cnt = 采用counts[采用index];
112.                         if (cnt > 0)
113.                         {
114.                                 if (采用index < 采用counts.size() - 1)
115.                                 {
116.                                         --cnt;
117.                                         采用sum -= 采用valArr[采用index].采用val;
118.                                         if (采用sum + 采用valArr[++采用index].采用sumAll >= 采用best.采用sum) // can we reach target with a lower difference?
119.                                                 return true; // Yes. Let's go forth()
120.                                         // No. Even if we sum up all remaining elements. Go back further.
121.                                 }
122.                                 else
123.                                 {
124.                                         // this is the last entry in counts[]. We can't go forth from here
125.                                         采用sum -= 采用valArr[采用index].采用val * cnt;
126.                                         cnt = 0;
127.                                 }
128.                         }
129.                         if (采用index == 0)
130.                                 return false; // can't go back any further (note: index is unsigned)
131.                 }
132.         }
133. };
135. static void MyMaxSum()
136. {
137.         vector<double> arr;
138.         fillVector(arr);
140.         map<double, unsigned> val2count;
141.         for (const double& val : arr)
142.                 val2count[val]++;
144.         vector<ValCount> valArr;
145.         arr.reserve(val2count.size());
146.         double sumAll = 0.0;
147.         for (const auto& entry : val2count)
148.         {
149.                 sumAll += entry.first * entry.second;
150.                 valArr.push采用back(ValCount(entry.first, entry.second, sumAll));
151.         }
152.         reverse(valArr.begin(), valArr.end());
154.         ValSum valsum(valArr, 30.0);
155.         valsum.findBest();
156. }
158. int main()
159. {
160.         MyMaxSum();
161.         getchar();
162. }

复制代码