build

en/docs/chapter_greedy/fractional_knapsack_problem.md

@@ -73,9 +73,41 @@ We have created an `Item` class in order to sort the items by their unit value.
 === "C++"
 
     ```cpp title="fractional_knapsack.cpp"
-    [class]{Item}-[func]{}
+    /* Item */
+    class Item {
+      public:
+        int w; // Item weight
+        int v; // Item value
 
-    [class]{}-[func]{fractionalKnapsack}
+        Item(int w, int v) : w(w), v(v) {
+        }
+    };
+
+    /* Fractional knapsack: Greedy */
+    double fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {
+        // Create an item list, containing two properties: weight, value
+        vector<Item> items;
+        for (int i = 0; i < wgt.size(); i++) {
+            items.push_back(Item(wgt[i], val[i]));
+        }
+        // Sort by unit value item.v / item.w from high to low
+        sort(items.begin(), items.end(), [](Item &a, Item &b) { return (double)a.v / a.w > (double)b.v / b.w; });
+        // Loop for greedy selection
+        double res = 0;
+        for (auto &item : items) {
+            if (item.w <= cap) {
+                // If the remaining capacity is sufficient, put the entire item into the knapsack
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // If the remaining capacity is insufficient, put part of the item into the knapsack
+                res += (double)item.v / item.w * cap;
+                // No remaining capacity left, thus break the loop
+                break;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Java"

en/docs/chapter_greedy/greedy_algorithm.md

@@ -48,7 +48,24 @@ The implementation code is as follows:
 === "C++"
 
     ```cpp title="coin_change_greedy.cpp"
-    [class]{}-[func]{coinChangeGreedy}
+    /* Coin change: Greedy */
+    int coinChangeGreedy(vector<int> &coins, int amt) {
+        // Assume coins list is ordered
+        int i = coins.size() - 1;
+        int count = 0;
+        // Loop for greedy selection until no remaining amount
+        while (amt > 0) {
+            // Find the smallest coin close to and less than the remaining amount
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // Choose coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // If no feasible solution is found, return -1
+        return amt == 0 ? count : -1;
+    }
     ```
 
 === "Java"

en/docs/chapter_greedy/max_capacity_problem.md

@@ -117,7 +117,26 @@ The variables $i$, $j$, and $res$ use a constant amount of extra space, **thus t
 === "C++"
 
     ```cpp title="max_capacity.cpp"
-    [class]{}-[func]{maxCapacity}
+    /* Maximum capacity: Greedy */
+    int maxCapacity(vector<int> &ht) {
+        // Initialize i, j, making them split the array at both ends
+        int i = 0, j = ht.size() - 1;
+        // Initial maximum capacity is 0
+        int res = 0;
+        // Loop for greedy selection until the two boards meet
+        while (i < j) {
+            // Update maximum capacity
+            int cap = min(ht[i], ht[j]) * (j - i);
+            res = max(res, cap);
+            // Move the shorter board inward
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Java"

en/docs/chapter_greedy/max_product_cutting_problem.md

@@ -6,7 +6,7 @@ comments: true
 
 !!! question
 
-    Given a positive integer $n$, split it into at least two positive integers that sum up to $n$, and find the maximum product of these integers, as illustrated below.
+    Given a positive integer $n$, split it into at least two positive integers that sum up to $n$, and find the maximum product of these integers, as illustrated in Figure 15-13.
 
 ![Definition of the maximum product cutting problem](max_product_cutting_problem.assets/max_product_cutting_definition.png){ class="animation-figure" }
 
@@ -96,7 +96,26 @@ Please note, for the boundary case where $n \leq 3$, a $1$ must be split out, wi
 === "C++"
 
     ```cpp title="max_product_cutting.cpp"
-    [class]{}-[func]{maxProductCutting}
+    /* Maximum product of cutting: Greedy */
+    int maxProductCutting(int n) {
+        // When n <= 3, must cut out a 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // Greedy cut out 3s, a is the number of 3s, b is the remainder
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // When the remainder is 1, convert a pair of 1 * 3 into 2 * 2
+            return (int)pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // When the remainder is 2, do nothing
+            return (int)pow(3, a) * 2;
+        }
+        // When the remainder is 0, do nothing
+        return (int)pow(3, a);
+    }
     ```
 
 === "Java"