Minimum cost to partition the given binary string
Last Updated :
01 Mar, 2022
Given a binary string str and an integer K, the task is to find the minimum cost required to partition the string into exactly K segments when the cost of each segment is the product of the number of set bits with the number of unset bits and total cost is sum of cost of all the individual segments.
Examples:
Input: str = "110101", K = 3
Output: 2
11|0|101 is one of the possible partitions
where the cost is 0 + 0 + 2 = 2
Input: str = "1000000", K = 5
Output: 0
Approach: Write a function minCost(s, k, cost, i, n) where cost is the minimum cost so far, i is the starting index for the partition and k is the remaining segments to be partitioned. Now, starting from the ith index calculate the cost of the current partition and call the same function recursively for the remaining substring. To memoize the result, a dp[][] array will be used where dp[i][j] will store the minimum cost of partitioning the string into j parts starting at the ith index.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1001;
// dp[i][j] will store the minimum cost
// of partitioning the string into j
// parts starting at the ith index
int dp[MAX][MAX];
// Recursive function to find
// the minimum cost required
int minCost(string& s, int k, int cost, int i, int& n)
{
// If the state has been solved before
if (dp[i][k] != -1)
return dp[i][k];
// If only 1 part is left then the
// remaining part of the string will
// be considered as that part
if (k == 1) {
// To store the count of 0s and the
// total characters of the string
int count_0 = 0, total = n - i;
// Count the 0s
while (i < n)
if (s[i++] == '0')
count_0++;
// Memoize and return the updated cost
dp[i][k] = cost + (count_0
* (total - count_0));
return dp[i][k];
}
int curr_cost = INT_MAX;
int count_0 = 0;
// Check all the positions to
// make the current partition
for (int j = i; j < n - k + 1; j++) {
// Count the numbers of 0s
if (s[j] == '0')
count_0++;
int curr_part_length = j - i + 1;
// Cost of partition is equal to
// (no. of 0s) * (no. of 1s)
int part_cost = (count_0
* (curr_part_length - count_0));
// string, partitions, curr cost,
// start index, length
part_cost += minCost(s, k - 1, 0, j + 1, n);
// Update the current cost
curr_cost = min(curr_cost, part_cost);
}
// Memoize and return the updated cost
dp[i][k] = (cost + curr_cost);
return (cost + curr_cost);
}
// Driver code
int main()
{
string s = "110101";
int n = s.length();
int k = 3;
// Initialise the dp array
for (int i = 0; i < MAX; i++) {
for (int j = 0; j < MAX; j++)
dp[i][j] = -1;
}
// string, partitions, curr cost,
// start index, length
cout << minCost(s, k, 0, 0, n);
return 0;
}
// Java implementation of the approach
class GFG {
final static int MAX = 1001;
// dp[i][j] will store the minimum cost
// of partitioning the string into j
// parts starting at the ith index
static int dp[][] = new int [MAX][MAX];
// Recursive function to find
// the minimum cost required
static int minCost(String s, int k, int cost, int i, int n)
{
// If the state has been solved before
if (dp[i][k] != -1)
return dp[i][k];
// If only 1 part is left then the
// remaining part of the string will
// be considered as that part
if (k == 1) {
// To store the count of 0s and the
// total characters of the string
int count_0 = 0, total = n - i;
// Count the 0s
while (i < n)
if (s.charAt(i++) == '0')
count_0++;
// Memoize and return the updated cost
dp[i][k] = cost + (count_0
* (total - count_0));
return dp[i][k];
}
int curr_cost = Integer.MAX_VALUE;
int count_0 = 0;
// Check all the positions to
// make the current partition
for (int j = i; j < n - k + 1; j++) {
// Count the numbers of 0s
if (s.charAt(j) == '0')
count_0++;
int curr_part_length = j - i + 1;
// Cost of partition is equal to
// (no. of 0s) * (no. of 1s)
int part_cost = (count_0
* (curr_part_length - count_0));
// string, partitions, curr cost,
// start index, length
part_cost += minCost(s, k - 1, 0, j + 1, n);
// Update the current cost
curr_cost = Math.min(curr_cost, part_cost);
}
// Memoize and return the updated cost
dp[i][k] = (cost + curr_cost);
return (cost + curr_cost);
}
// Driver code
public static void main (String[] args)
{
String s = "110101";
int n = s.length();
int k = 3;
// Initialise the dp array
for (int i = 0; i < MAX; i++) {
for (int j = 0; j < MAX; j++)
dp[i][j] = -1;
}
// string, partitions, curr cost,
// start index, length
System.out.println(minCost(s, k, 0, 0, n));
}
}
// This code is contributed by AnkitRai01
# Python 3 implementation of the approach
import sys
MAX = 1001
# dp[i][j] will store the minimum cost
# of partitioning the string into j
# parts starting at the ith index
dp = [[0 for i in range(MAX)]
for j in range(MAX)]
# Recursive function to find
# the minimum cost required
def minCost(s, k, cost, i, n):
# If the state has been solved before
if (dp[i][k] != -1):
return dp[i][k]
# If only 1 part is left then the
# remaining part of the string will
# be considered as that part
if (k == 1):
# To store the count of 0s and the
# total characters of the string
count_0 = 0
total = n - i
# Count the 0s
while (i < n):
if (s[i] == '0'):
count_0 += 1
i += 1
# Memoize and return the updated cost
dp[i][k] = cost + (count_0 *
(total - count_0))
return dp[i][k]
curr_cost = sys.maxsize
count_0 = 0
# Check all the positions to
# make the current partition
for j in range(i, n - k + 1, 1):
# Count the numbers of 0s
if (s[j] == '0'):
count_0 += 1
curr_part_length = j - i + 1
# Cost of partition is equal to
# (no. of 0s) * (no. of 1s)
part_cost = (count_0 *
(curr_part_length - count_0))
# string, partitions, curr cost,
# start index, length
part_cost += minCost(s, k - 1, 0, j + 1, n)
# Update the current cost
curr_cost = min(curr_cost, part_cost)
# Memoize and return the updated cost
dp[i][k] = (cost + curr_cost)
return (cost + curr_cost)
# Driver code
if __name__ == '__main__':
s = "110101"
n = len(s)
k = 3
# Initialise the dp array
for i in range(MAX):
for j in range(MAX):
dp[i][j] = -1
# string, partitions, curr cost,
# start index, length
print(minCost(s, k, 0, 0, n))
# This code is contributed by Surendra_Gangwar
// C# implementation of the approach
using System;
using System.Collections.Generic;
class GFG
{
readonly static int MAX = 1001;
// dp[i,j] will store the minimum cost
// of partitioning the string into j
// parts starting at the ith index
static int [,]dp = new int [MAX, MAX];
// Recursive function to find
// the minimum cost required
static int minCost(String s, int k, int cost, int i, int n)
{
int count_0 = 0;
// If the state has been solved before
if (dp[i, k] != -1)
return dp[i, k];
// If only 1 part is left then the
// remaining part of the string will
// be considered as that part
if (k == 1)
{
// To store the count of 0s and the
// total characters of the string
int total = n - i;
// Count the 0s
while (i < n)
if (s[i++] == '0')
count_0++;
// Memoize and return the updated cost
dp[i, k] = cost + (count_0
* (total - count_0));
return dp[i, k];
}
int curr_cost = int.MaxValue;
count_0 = 0;
// Check all the positions to
// make the current partition
for (int j = i; j < n - k + 1; j++)
{
// Count the numbers of 0s
if (s[j] == '0')
count_0++;
int curr_partlength = j - i + 1;
// Cost of partition is equal to
// (no. of 0s) * (no. of 1s)
int part_cost = (count_0
* (curr_partlength - count_0));
// string, partitions, curr cost,
// start index,.Length
part_cost += minCost(s, k - 1, 0, j + 1, n);
// Update the current cost
curr_cost = Math.Min(curr_cost, part_cost);
}
// Memoize and return the updated cost
dp[i, k] = (cost + curr_cost);
return (cost + curr_cost);
}
// Driver code
public static void Main (String[] args)
{
String s = "110101";
int n = s.Length;
int k = 3;
// Initialise the dp array
for (int i = 0; i < MAX; i++)
{
for (int j = 0; j < MAX; j++)
dp[i, j] = -1;
}
// string, partitions, curr cost,
// start index,.Length
Console.WriteLine(minCost(s, k, 0, 0, n));
}
}
// This code is contributed by 29AjayKumar
<script>
// Javascript implementation of the approach
let MAX = 1001;
// dp[i][j] will store the minimum cost
// of partitioning the string into j
// parts starting at the ith index
let dp = new Array(MAX);
// Recursive function to find
// the minimum cost required
function minCost(s, k, cost, i, n)
{
// If the state has been solved before
if (dp[i][k] != -1)
return dp[i][k];
// If only 1 part is left then the
// remaining part of the string will
// be considered as that part
if (k == 1) {
// To store the count of 0s and the
// total characters of the string
let count_0 = 0, total = n - i;
// Count the 0s
while (i < n)
if (s[i++] == '0')
count_0++;
// Memoize and return the updated cost
dp[i][k] = cost + (count_0
* (total - count_0));
return dp[i][k];
}
let curr_cost = Number.MAX_VALUE;
let count_0 = 0;
// Check all the positions to
// make the current partition
for (let j = i; j < n - k + 1; j++) {
// Count the numbers of 0s
if (s[j] == '0')
count_0++;
let curr_part_length = j - i + 1;
// Cost of partition is equal to
// (no. of 0s) * (no. of 1s)
let part_cost = (count_0 * (curr_part_length - count_0));
// string, partitions, curr cost,
// start index, length
part_cost += minCost(s, k - 1, 0, j + 1, n);
// Update the current cost
curr_cost = Math.min(curr_cost, part_cost);
}
// Memoize and return the updated cost
dp[i][k] = (cost + curr_cost);
return (cost + curr_cost);
}
let s = "110101";
let n = s.length;
let k = 3;
// Initialise the dp array
for (let i = 0; i < MAX; i++) {
dp[i] = new Array(MAX);
for (let j = 0; j < MAX; j++)
dp[i][j] = -1;
}
// string, partitions, curr cost,
// start index, length
document.write(minCost(s, k, 0, 0, n));
// This code is contributed by divyeshrabadiya07.
</script>
Time Complexity: O((n - k) + (MAX * MAX))
Auxiliary Space: O(MAX * MAX)
Similar Reads
Minimum operations to convert given string into all 1s or 0s Given a string S containing 0s and 1s of length N with X, the task is to output the minimum operations required to convert S into either all 1s or 0s. The operation is defined as, taking two different indices i and j (1-based indexing), such that they give equal remainder when dividing from X, then
8 min read
Maximum Balanced String Partitions Given a balanced string str of size N with an equal number of L and R, the task is to find a maximum number X, such that a given string can be partitioned into X balanced substring. A string called to be balanced if the number of 'L's in the string equals the number of 'R's. Examples: Input : str =
7 min read
Minimize the String length by removing given consecutive pairs Given a string S of size N consisting of characters from '0'to '9', the task is to minimize the length of the string where In each minimizing operation, we can remove any two consecutive characters if they are of the form {"12", "21", "34", "43", "56", "65", "78", "87", "09", "90"}. Examples: Input:
7 min read
Minimum toggles to partition a binary array so that it has first 0s then 1s Given an array of n integers containing only 0 and 1. Find the minimum toggles (switch from 0 to 1 or vice-versa) required such the array become partitioned, i.e., it has first 0s than 1s. There should be at least one 0 in the beginning, and there can be zero or more 1s in the end. Input: arr[] = {1
7 min read
Minimum partitions of String such that each part is at most K Given a string S of size N consisting of numerical digits 1-9 and a positive integer K, the task is to minimize the partitions of the string such that each part is at most K. If it’s impossible to partition the string print -1. Examples: Input: S = "3456", K = 45Output: 2Explanation: One possible wa
8 min read