Update split_array_largest_sum.cpp

added necessary changes

Author: ARYPROGRAMMER

dynamic_programming/split_array_largest_sum.cpp

@@ -1,131 +1,136 @@
 /**
  * @file
- * @brief Given an integer array nums and an integer k, split nums into k
- * non-empty subarrays such that the largest sum of any subarray is minimized.
- * Return the minimized largest sum of the split.
-
+ * @brief [Split Array Largest Sum](https://leetcode.com/problems/split-array-largest-sum/)
+ * 
+ * Given an integer array `nums` and an integer `k`, this program splits the 
+ * array into `k` non-empty subarrays such that the largest sum of any subarray is minimized.
+ * This function returns the minimized largest sum of the split.
+ * 
  * @details
+ * ### Problem Explanation:
  * Example 1:
-
-    * Input: nums = [7,2,5,10,8], k = 2
-    * Output: 18
-    * Explanation: There are four ways to split nums into two subarrays.
-    * The best way is to split it into [7,2,5] and [10,8], where the largest sum
-    * among the two subarrays is only 18.
-  
+ * - Input: nums = [7,2,5,10,8], k = 2
+ * - Output: 18
+ * - Explanation: The best way to split it into two subarrays is [7,2,5] and [10,8],
+ *   where the largest sum among the two subarrays is 18.
+ * 
  * Example 2:
-
-    * Input: nums = [1,2,3,4,5], k = 2
-    * Output: 9
-    * Explanation: There are four ways to split nums into two subarrays.
-    * The best way is to split it into [1,2,3] and [4,5], where the largest sum
-    * among the two subarrays is only 9.
-
- * @author [ARYA PRATAP SINGH](https://github.com/ARYPROGRAMMER)
- * [Leetcode](https://leetcode.com/problems/split-array-largest-sum/description/?envType=problem-list-v2&envId=dynamic-programming)
+ * - Input: nums = [1,2,3,4,5], k = 2
+ * - Output: 9
+ * - Explanation: The best way to split it into two subarrays is [1,2,3] and [4,5],
+ *   where the largest sum among the two subarrays is 9.
+ * 
+ * ### Approach:
+ * Dynamic Programming is used to minimize the largest subarray sum by 
+ * splitting the array into `k` subarrays.
+ * 
+ * ### Time Complexity:
+ * O(n^2 * k), where `n` is the size of the array and `k` is the number of subarrays.
+ * 
+ * ### Space Complexity:
+ * O(n * k), for the DP table.
+ * 
+ * @author 
+ * [ARYA PRATAP SINGH](https://github.com/ARYPROGRAMMER)
  */
 
-// header files
 #include <iostream>
-#include <iomanip>
-#include <cstdint>
+#include <vector>
+#include <climits>
+#include <cstring>
+#include <cassert>
 
-/**
- * @namespace dynamic_programming
- * @brief Dynamic Programming algorithms
- */
-namespace dynamic_programming{
-    /**
-     * @namespace split_array_largest_sum
-     * @brief split_array_largest_sum algorithm
-     */
-    namespace split_array_largest_sum{
-
-        /**
-         * @brief This function calculates the minimum largest sum of the split
-         * @param nums integer array
-         * @param k integer
-         * @
-         */
+namespace dynamic_programming {
+    namespace split_array_largest_sum {
 
+        // DP table for memoization
         int dp[1003][53];
 
-        int f(int i, int j, vector<int>& v) {
-            if (j < 0) {
-                if (i < 0)
-                    return -1;
-                return INT_MAX;
-            }
-            if (i < 0)
-                return INT_MAX;
-            if (dp[i][j] != -1)
-                return dp[i][j];
+        /**
+         * @brief Recursive function to calculate minimum largest sum of split
+         * @param i current index in the array
+         * @param j number of subarrays remaining
+         * @param v reference to input vector of numbers
+         * @return minimized largest sum for current split configuration
+         */
+        int f(int i, int j, const std::vector<int> &v) {
+            if (j < 0) return (i < 0) ? -1 : INT_MAX;
+            if (i < 0) return INT_MAX;
+            if (dp[i][j] != -1) return dp[i][j];
 
             int res = INT_MAX, sum = 0;
-            for (int k = i; k >= 0; k--) {
+            for (int k = i; k >= 0; --k) {
                 sum += v[k];
-                res = min(res, max(sum, f(k - 1, j - 1, v)));
+                res = std::min(res, std::max(sum, f(k - 1, j - 1, v)));
             }
-
             return dp[i][j] = res;
-            }
+        }
 
-        int splitArray(vector<int>& nums, int k) {
-            memset(dp, -1, sizeof(dp));
+        /**
+         * @brief Function to split array and find minimized largest sum
+         * @param nums vector of integers representing the array
+         * @param k number of subarrays
+         * @return minimized largest sum of any subarray after split
+         */
+        int splitArray(const std::vector<int> &nums, int k) {
+            std::memset(dp, -1, sizeof(dp));
             return f(nums.size() - 1, k - 1, nums);
         }
     }
 }
 
 /**
- * Test Function
- * @return void
+ * @brief Test Function
+ * This function tests the `splitArray` function by using custom input.
  */
 static void test() {
-    // custom input vector
-    std::vector<int> v{
-        7,2,5,10,8,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
-    };
-    // custom value of k
+    std::vector<int> test_array = {7, 2, 5, 10, 8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int k = 5;
-   
-    //calling the function
-    int ans = dynamic_programming::split_array_largest_sum::splitArray(v, k);
-
-    // expected output
-    int expectedOutput = 30;
 
-    // Testing implementation via assert function
-    // It will throw error if any of the expected test fails
-    // Else it will give nothing
-    assert(ans == expectedOutput);
+    // Calling the function
+    int result = dynamic_programming::split_array_largest_sum::splitArray(test_array, k);
+    
+    // Expected output
+    int expected = 30;
 
+    // Testing using assert
+    assert(result == expected);
     std::cout << "All tests passed successfully!\n";
-    return;
 }
 
-/** Main function (driver code)*/
-int main() {
-    // test for implementation
-    test();
-
-    // user input
+/**
+ * @brief Function to handle user input and output.
+ * This function gathers input from the user and calls the `splitArray` function.
+ */
+void handleUserIO() {
     int n;
-    std::cout << "Enter the number of elements in the array : ";
+    std::cout << "Enter the number of elements in the array: ";
     std::cin >> n;
-    std::vector<int> v(n);
-    std::cout << "Enter the elements of the array : ";
-    for (int i = 0; i < n; i++) {
-        std::cin >> v[i];
+
+    std::vector<int> nums(n);
+    std::cout << "Enter the elements of the array: ";
+    for (int &num : nums) {
+        std::cin >> num;
     }
+
     int k;
-    std::cout << "Enter the value of k : ";
+    std::cout << "Enter the value of k: ";
     std::cin >> k;
 
-    int ans;
+    int result = dynamic_programming::split_array_largest_sum::splitArray(nums, k);
+    std::cout << "The minimum largest sum of the split is: " << result << std::endl;
+}
+
+/**
+ * @brief Main Function (driver code)
+ * This function calls test cases and handles user input/output.
+ */
+int main() {
+    // Running test cases
+    test();
+
+    // Handling user input/output
+    handleUserIO();
 
-    // user output
-    ans = dynamic_programming::split_array_largest_sum::splitArray(v, k);
-    std::cout << "The minimum largest sum of the split is : " << ans << std::endl;
     return 0;
 }