Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Find the minimum cost of partitioning the given string S into contiguous substrings

Given a string S and an array of strings arr[]. The task is to find the minimum cost of partitioning the given string S into continuous substrings. If a substring is present in arr[] then the cost of partition would be 0, otherwise, the cost would be the length of that substring.

Examples:

Input: S = geeksforgeeks, A[] = {geek, for}
Output: 2
Explanation: The explanation is as follows:

  • Break geeksforgeeks as {geek + s + for + geek+ s}
    • 1st substring: "geek" is present in A[]. Therefore, cost is 0.
    • 2nd substring: "s" is not present in A[]. Therefore, cost is 1.
    • 3rd substring: "for" is present in A[]. Therefore, cost is 0.
    • 4th substring: "geek" is present in A[]. Therefore, cost is 0.
    • 5th substring: "s" is not present in A[]. Therefore, cost is 1.
  • Total cost = 0+1+0+0+1 = 2. Which is minimum possible.

Input: S = geeksgeeks, A[] = {ge, ek, s, eeksgeeks},
Output: 0
Explanation: S can be broken in two ways {g + eeksgeeks} and {ge + ek + s + ge + ek + s} with cost 1 and 0 respectively. 0 is minimum possible cost.

Approach: Implement the idea below to solve the problem

As we have choice to delete or not delete a substring. Therefore, Dynamic Programming can be used to solve this problem. The main concept of DP in the problem will be:

  • DP[i] will store the minimum cost of breaking string S till ith character.
  • Transition:
    • DP[i] = min(DP[i + 1] + 1, DP[i + e.size()]) for every 'e' where, e is string from array A[] and substring of string S starting from i is equal to string e.

Step-by-step approach:

Below is the implementation of the above approach:

C++ 
// C++ code to implement the approach 
#include <bits/stdc++.h> 
using namespace std; 

// Function to Minimize cost of breaking string in 
// continuous substring 
int minimumCost(string& S, vector<string>& A, int N) 
{ 
    // size of string 
    int szeOfS = S.size(); 

    // DP array initalized with infinity 
    vector<int> dp(szeOfS + 1, 1e9); 

    // base case 
    dp[szeOfS] = 0; 

    // size of string 
    for (int i = szeOfS - 1; i >= 0; i--) { 

        // if we dont delete i'th character 
        dp[i] = dp[i + 1] + 1; 

        // iterate over possible substrings that 
        // can be removed from S 
        for (auto& posSubstrToDelete : A) { 

            // if substring from i'th character is equal to 
            // e update the dp array by deleting this 
            // substring 
            if (i + posSubstrToDelete.size() <= szeOfS 
                and S.substr(i, posSubstrToDelete.size()) 
                        == posSubstrToDelete) { 
                dp[i] 
                    = min(dp[i], 
                        dp[i + posSubstrToDelete.size()]); 
            } 
        } 
    } 

    // Returing answer 
    return dp[0]; 
} 

// Driver Code 
int32_t main() 
{ 

    // Input 
    string S1 = "geeksforgeeks"; 
    int N1 = 2; 
    vector<string> A1{ "geek", "for" }; 

    // Function Call 
    cout << minimumCost(S1, A1, N1) << endl; 

    return 0; 
}
Java 
// Java Implementation
import java.util.ArrayList;
import java.util.List;

public class MinimumCost {
    public static int minimumCost(String S, List<String> A) {
        int szeOfS = S.length();
        int[] dp = new int[szeOfS + 1];
        for (int i = 0; i <= szeOfS; i++) {
            dp[i] = Integer.MAX_VALUE;
        }
        dp[szeOfS] = 0;
        for (int i = szeOfS - 1; i >= 0; i--) {
            dp[i] = dp[i + 1] + 1;
            for (String posSubstrToDelete : A) {
                if (i + posSubstrToDelete.length() <= szeOfS && S.substring(i, i + posSubstrToDelete.length()).equals(posSubstrToDelete)) {
                    dp[i] = Math.min(dp[i], dp[i + posSubstrToDelete.length()]);
                }
            }
        }
        return dp[0];
    }

    public static void main(String[] args) {
        String S1 = "geeksforgeeks";
        int N1 = 2;
        List<String> A1 = new ArrayList<>();
        A1.add("geek");
        A1.add("for");
        System.out.println(minimumCost(S1, A1));
    }
}

// This code is contributed by Tapesh(tapeshdu420)
C# 
using System;
using System.Collections.Generic;

class Program
{
    // Function to Minimize cost of breaking string in continuous substring
    static int MinimumCost(string S, List<string> A, int N)
    {
        // size of string
        int szeOfS = S.Length;

        // DP array initialized with infinity
        List<int> dp = new List<int>(new int[szeOfS + 1]);
        for (int i = 0; i < dp.Count; i++)
        {
            dp[i] = int.MaxValue;
        }

        // base case
        dp[szeOfS] = 0;

        // size of string
        for (int i = szeOfS - 1; i >= 0; i--)
        {
            // if we don't delete i'th character
            dp[i] = dp[i + 1] + 1;

            // iterate over possible substrings that can be removed from S
            foreach (var posSubstrToDelete in A)
            {
                // if substring from i'th character is equal to e update the dp array by deleting this substring
                if (i + posSubstrToDelete.Length <= szeOfS
                    && S.Substring(i, posSubstrToDelete.Length) == posSubstrToDelete)
                {
                    dp[i] = Math.Min(dp[i], dp[i + posSubstrToDelete.Length]);
                }
            }
        }

        // Returning answer
        return dp[0];
    }

    // Driver Code
    static void Main()
    {
        // Input
        string S1 = "geeksforgeeks";
        int N1 = 2;
        List<string> A1 = new List<string> { "geek", "for" };

        // Function Call
        Console.WriteLine(MinimumCost(S1, A1, N1));

       
    }
}

// This code is contributed by shivamgupta310570
Javascript 
// Function to minimize cost of breaking string in continuous substring
function minimumCost(S, A, N) {
    // Size of string
    const szeOfS = S.length;

    // DP array initialized with infinity
    const dp = new Array(szeOfS + 1).fill(1e9);

    // Base case
    dp[szeOfS] = 0;

    // Size of string
    for (let i = szeOfS - 1; i >= 0; i--) {
        // If we don't delete i'th character
        dp[i] = dp[i + 1] + 1;

        // Iterate over possible substrings that can be removed from S
        for (let posSubstrToDelete of A) {
            // If substring from i'th character is equal to posSubstrToDelete
            // Update the dp array by deleting this substring
            if (i + posSubstrToDelete.length <= szeOfS &&
                S.substring(i, i + posSubstrToDelete.length) === posSubstrToDelete) {
                dp[i] = Math.min(dp[i], dp[i + posSubstrToDelete.length]);
            }
        }
    }

    // Returning answer
    return dp[0];
}

// Driver Code
// Input
let S1 = "geeksforgeeks";
let N1 = 2;
let A1 = ["geek", "for"];

// Function Call
console.log(minimumCost(S1, A1, N1));

// This code is contributed by shivamgupta310570
Python3 
def minimum_cost(S, A, N):
    # size of string
    sze_of_S = len(S)

    # DP array initialized with infinity
    dp = [float('inf')] * (sze_of_S + 1)

    # base case
    dp[sze_of_S] = 0

    # size of string
    for i in range(sze_of_S - 1, -1, -1):
        # if we don't delete i'th character
        dp[i] = dp[i + 1] + 1

        # iterate over possible substrings that
        # can be removed from S
        for pos_substr_to_delete in A:
            # if substring from i'th character is equal to
            # e update the dp array by deleting this
            # substring
            if (
                i + len(pos_substr_to_delete) <= sze_of_S
                and S[i:i + len(pos_substr_to_delete)] == pos_substr_to_delete
            ):
                dp[i] = min(dp[i], dp[i + len(pos_substr_to_delete)])

    # Returning answer
    return dp[0]


# Driver Code
if __name__ == "__main__":
    # Input
    S1 = "geeksforgeeks"
    N1 = 2
    A1 = ["geek", "for"]

    # Function Call
    print(minimum_cost(S1, A1, N1))

Output
2

Time Complexity: O(N*M*K), where N, M, K are length of string, length of A[] and maximum size of string among all strings from A[] respectively.
Auxiliary Space: O(N)

Article Tags :
DSA
Dynamic Programming
Geeks Premier League
Strings
Recommended Articles
1. Partitioning into two contiguous element subarrays with equal sums
2. Minimizing Removal of Characters for Partitioning into three substrings that contain 'a' and 'b' characters only.
3. Minimize the cost of partitioning an array into K groups
4. Minimize cost by splitting given Array into subsets of size K and adding highest K/2 elements of each subset into cost
5. Minimize cost to convert given string into concatenation of equal substrings of length K
6. Minimum number of substrings the given string can be splitted into that satisfy the given conditions
7. Minimum cost to complete given tasks if cost of 1, 7 and 30 days are given
8. Find maximum subset sum formed by partitioning any subset of array into 2 partitions with equal sum
9. Minimum cost for gift card eligibility from Contiguous Subsegments
10. Find number of contiguous Substrings with repeated patterns
11. Contiguous unique substrings with the given length L
12. Remove minimum characters from string to split it into three substrings under given constraints
13. Minimum flips required to convert given string into concatenation of equal substrings of length K
14. Minimum cost to convert the given String into Palindrome
15. Minimum cost to convert all elements of a K-size subarray to 0 from given Ternary Array with subarray sum as cost
16. Minimum Cost To set Digital Clock Timer with given movement and push cost
17. Maximize cost obtained by removal of substrings "pr" or "rp" from a given String
18. Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
19. Maximizing GCD by Partitioning a Number into K Parts
20. Find least start index of a substring from given String that contains all the given words in a contiguous manner
21. Maximize cost to empty an array by removing contiguous subarrays of equal elements
22. Minimum cost to convert string into palindrome
23. Minimum Cost using Dijkstra by Modifying Cost of an Edge
24. Minimum cost to empty Array where cost of removing an element is 2^(removed_count) * arr[i]
25. Minimize cost to rearrange substrings to convert a string to a Balanced Bracket Sequence