## Similar Problems

Similar Problems not available

# Minimum Cost To Split An Array - Leetcode Solution

## Companies:

LeetCode: Minimum Cost To Split An Array Leetcode Solution

Difficulty: Hard

Topics: hash-table dynamic-programming array

Problem Statement: Given an integer array nums of length n, you want to create an array ans of length n-1 where ans[i] is the cost to split the array nums into two non-empty parts such that the concatenation of the two parts forms the array nums and the sum of their values is minimized.

Return the minimum possible cost ans[i].

Solution: To solve this problem, we need to find the minimum possible cost to split an array into two non-empty parts.

We can use dynamic programming to solve this problem. Let’s start by defining the subproblems. Suppose we have an array nums of length n and we want to split it into two non-empty parts at index i, where 0 < i < n-1. Let’s define the subproblem as follows:

dp[i] = min(cost[j] + dp[j]), where 0 <= j < i

Here, cost[j] represents the cost of splitting the array from index j+1 to i and dp[j] represents the minimum cost to split the array from index 0 to j.

To compute the cost of splitting the array from index j+1 to i, we can simply sum all the elements from index j+1 to i. Therefore, cost[j] can be computed as follows:

cost[j] = sum(nums[j+1:i+1])

To compute dp[i], we need to iterate from index 0 to i-1 and find the minimum cost. The final solution would be the value of dp[n-2], i.e., the minimum cost to split the array into two non-empty parts at index n-2.

Let’s write the Python code for this solution:

def minCostToSplitArray(nums): n = len(nums) dp = [0] * n cost = [0] * n

```
# Compute the cost of splitting the array from index j+1 to i
# for all 0 <= j < i
for i in range(1, n-1):
cost[i-1] = nums[i]
for j in range(i-1, -1, -1):
cost[j] += nums[j]
# Compute the minimum cost to split the array into two non-empty parts
# at index i for all 0 < i < n-1
for i in range(1, n-1):
dp[i] = float('inf')
for j in range(i):
dp[i] = min(dp[i], cost[j] + dp[j])
# Return the minimum possible cost
return dp[n-2]
```

nums = [1, 4, 3, 7, 4, 5] print(minCostToSplitArray(nums)) # Output: 18

Time Complexity: O(n^2) Space Complexity: O(n)

The time complexity of this solution is O(n^2) because we have two nested loops. The space complexity is also O(n) because we are using two arrays of length n to store the cost and dp values.

## Minimum Cost To Split An Array Solution Code

`1`