Leetcode 410: Split Array Largest Sum

Given an array which consists of non-negative integers and an integer m, you can split the array into m non-empty continuous subarrays. Write an algorithm to minimize the largest sum among these m subarrays.

Note:
If n is the length of array, assume the following constraints are satisfied:

• 1 ≤ n ≤ 1000
• 1 ≤ m ≤ min(50, n)

 

Examples:

Input:
nums = [7,2,5,10,8]
m = 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.


Note: this is the most straightforward solution, but it didn't pass the large input test case due to time out.

public class Solution {
    public int SplitArray(int[] nums, int m) {
        var sum = new int[nums.Length];
        
        for (int i = 0; i < nums.Length; i++)
        {
            sum[i] = nums[i] + (i == 0 ? 0 : sum[i - 1]); 
        }
        
        if (m == 1) return sum[sum.Length - 1];
        
        var results = new List<IList<int>>();
        generateCombinations(nums.Length, m, 0, 0, new List<int>(), results);
        
        var result = 0;
        var curMax = Int32.MaxValue;
        foreach (var l in results)
        {
            var last = 0;
            foreach (var i in l)
            {
                var s = sum[i] - last;
                last = sum[i];
                result = Math.Max(result, s);
                if (s >= curMax) break;
            }
            
            curMax = Math.Min(result, curMax);
            result = 0;
        }
        
        return curMax;
    }
    
    private void generateCombinations(int n, int m, int start, int cuts, IList<int> result, IList<IList<int>> results)
    {
        if (start >= n || cuts >= m)
        {
            if (start >= n && cuts >= m)
            {
                results.Add(new List<int>(result));
            }
            
            return;
        }
        
        for (int i = start; i < n; i++)
        {
            result.Add(i);
            generateCombinations(n, m, i + 1, cuts + 1, result, results);
            result.RemoveAt(result.Count - 1);
        }
    }
}