Minimum length of Run Length Encoding possible by removing at most K characters from a given string

Given a string S of length N, consisting of lowercase English alphabets only, the task is to find the minimum possible length of run-length-encoding that can be generated by removing at most K characters from the string S.

Examples:

Input: S = “abbbcdcdd”, N = 9, K = 2 
Output:
Explanation: One possible way is to delete both occurrences of ‘c’ from S.
The new string generated is “abbbddd” whose run-length-encoding is “ab3d3”. 
Therefore, the length of the encoded string is 5.

Input: S = “aabbca”, N = 6, K = 3 
Output:
Explanation: One possible way is to delete both the occurrences of ‘b’ and one occurrence of ‘c’. 
The new string generated is “aaa” whose run-length-encoding is “a3”. 
Therefore, the length of the encoded string is 2

Naive Approach: The simplest approach to solve the problem is to remove every combination of K characters from the string and calculate their respective run-length-encoding. Finally, print the length of the smallest run-length-encoding obtained. 



Time Complexity: O(K * N!(N – K)! * K!) 
Auxiliary Space: O(K)

Efficient Approach: To optimize the above approach, follow the steps below to solve the problem:

  • Maintain an auxiliary array dp[n][k][26][n], where dp[idx][K][last][count] denotes the minimum run-length-encoding obtained starting from index idx where, K denotes the number of deletions remaining, last denotes the last character with frequency count so far.
  • For every character, two possibilities exists, either to delete the character or to retain it.
  • Consider that the current character at index idx is deleted and calculate recursively the minimum run-length encoding obtained by passing the parameters (idx + 1, K – 1, last, count)
  • Now, consider that the current character at index idx is retained and calculate recursively the minimum run-length encoding for the following two cases:
  • If S[idx] = last: Calculate minimum run-length encoding by passing the parameters (idx + 1, K, S[idx], count + 1).
  • Otherwise, calculate minimum run-length encoding by passing the parameters (idx + 1, K, S[idx], 1).
  • Return the minimum of the above-computed values and repeat the above steps for all indices of the string.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
#define maxN 20
 
int dp[maxN][maxN][27][maxN];
 
// Function which solves the desired problem
int solve(string& s, int n, int idx,
          int k, char last = 123,
          int count = 0)
{
    // idx: current index in s
    // k: Remaining number of deletions
    // last: Previous character
    // count: Number of occurrences
    // of the previous character
 
    // Base Case
    if (k < 0)
        return n + 1;
 
    // If the entire string has
    // been traversed
    if (idx == n)
        return 0;
 
    int& ans = dp[idx][k][last - 'a'][count];
 
    // If precomputed subproblem
    // occurred
    if (ans != -1)
        return ans;
 
    ans = n + 1;
 
    // Minimum run length encoding by
    // removing the currrent character
    ans = min(ans,
              solve(s, n, idx + 1, k - 1, last, count));
 
    // Minimum run length encoding by
    // retaining the currrent character
    int inc = 0;
 
    if (count == 1 || count == 9
        || count == 99)
        inc = 1;
 
    // If the current and the
    // previous characters match
    if (last == s[idx]) {
 
        ans = min(ans,
                  inc + solve(s, n, idx + 1, k, s[idx],
                              count + 1));
    }
 
    // Otherwise
    else {
 
        ans = min(ans,
                  1 + solve(s, n, idx + 1, k, s[idx], 1));
    }
 
    return ans;
}
 
// Function to return minimum run-length encoding
// for string s by removing atmost k characters
int MinRunLengthEncoding(string& s, int n, int k)
{
    memset(dp, -1, sizeof(dp));
    return solve(s, n, 0, k);
}
 
// Driver Code
int main()
{
    string S = "abbbcdcdd";
    int N = 9, K = 2;
    cout << MinRunLengthEncoding(S, N, K);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
static int maxN = 20;
 
static int dp[][][][] = new int[maxN][maxN][27][maxN];
 
// Function which solves the desired problem
public static int solve(String s, int n,
                         int idx, int k,
                       char last, int count)
{
     
    // idx: current index in s
    // k: Remaining number of deletions
    // last: Previous character
    // count: Number of occurrences
    // of the previous character
 
    // Base Case
    if (k < 0)
        return n + 1;
 
    // If the entire string has
    // been traversed
    if (idx == n)
        return 0;
 
    int ans = dp[idx][k][last - 'a'][count];
 
    // If precomputed subproblem
    // occurred
    if (ans != -1)
        return ans;
 
    ans = n + 1;
 
    // Minimum run length encoding by
    // removing the currrent character
    ans = Math.min(ans, solve(s, n, idx + 1,
                              k - 1, last,
                              count));
 
    // Minimum run length encoding by
    // retaining the currrent character
    int inc = 0;
 
    if (count == 1 || count == 9 || count == 99)
        inc = 1;
 
    // If the current and the
    // previous characters match
    if (last == s.charAt(idx))
    {
        ans = Math.min(ans, inc + solve(s, n, idx + 1,
                                        k, s.charAt(idx),
                                        count + 1));
    }
 
    // Otherwise
    else
    {
        ans = Math.min(ans, 1 + solve(s, n, idx + 1, k,
                                      s.charAt(idx), 1));
    }
    return dp[idx][k][last - 'a'][count] = ans;
}
 
// Function to return minimum run-length encoding
// for string s by removing atmost k characters
public static int MinRunLengthEncoding(String s, int n,
                                                 int k)
{
    for(int i[][][] : dp)
        for(int j[][] : i)
            for(int p[] : j)
                Arrays.fill(p, -1);
                 
    return solve(s, n, 0, k, (char)123, 0);
}
 
// Driver Code
public static void main(String args[])
{
    String S = "abbbcdcdd";
    int N = 9, K = 2;
     
    System.out.println(MinRunLengthEncoding(S, N, K));
}
}
 
// This code is contributed by hemanth gadarla

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
maxN = 20
 
dp = [[[[0 for i in range(maxN)]
           for j in range(27)]
           for k in range(27)]
           for l in range(maxN)]
 
# Function which solves the desired problem
def solve(s, n, idx, k, last, count):
     
    # idx: current index in s
    # k: Remaining number of deletions
    # last: Previous character
    # count: Number of occurrences
    # of the previous character
 
    # Base Case
    if (k < 0):
        return n + 1
 
    # If the entire string has
    # been traversed
    if (idx == n):
        return 0
 
    ans = dp[idx][k][ord(last) - ord('a')][count]
 
    # If precomputed subproblem
    # occurred
    if (ans != -1):
        return ans
 
    ans = n + 1
 
    # Minimum run length encoding by
    # removing the currrent character
    ans = min(ans, solve(s, n, idx + 1,
                         k - 1, last, count))
 
    # Minimum run length encoding by
    # retaining the currrent character
    inc = 0
 
    if (count == 1 or count == 9 or
        count == 99):
        inc = 1
 
    # If the current and the
    # previous characters match
    if (last == s[idx]):
        ans = min(ans, inc + solve(s, n, idx + 1, k,
                                   s[idx], count + 1))
 
    # Otherwise
    else:
        ans = max(ans, 1 + solve(s, n, idx + 1,
                                 k, s[idx], 1))
                                  
    dp[idx][k][ord(last) - ord('a')][count] = ans
    #print(ans)
     
    return dp[idx][k][ord(last) - ord('a')][count]
 
# Function to return minimum run-length encoding
# for string s by removing atmost k characters
def MinRunLengthEncoding(s, n, k):
     
    for i in range(maxN):
        for j in range(27):
            for k in range(27):
                for l in range(maxN):
                    dp[i][j][k][l] = -1
                     
    return solve(s, n, 0, k, chr(123), 0) - 1
 
# Driver Code
if __name__ == '__main__':
     
    S = "abbbcdcdd"
    N = 9
    K = 2
 
    print(MinRunLengthEncoding(S, N, K))
 
# This code is contributed by gauravrajput1

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
class GFG{
 
static int maxN = 20;
 
static int [,,,]dp =
       new int[maxN, maxN,
               27, maxN];
 
// Function which solves
// the desired problem
public static int solve(String s, int n,
                        int idx, int k,
                        char last, int count)
{   
  // idx: current index in s
  // k: Remaining number of deletions
  // last: Previous character
  // count: Number of occurrences
  // of the previous character
 
  // Base Case
  if (k < 0)
    return n + 1;
 
  // If the entire string
  // has been traversed
  if (idx == n)
    return 0;
 
  int ans = dp[idx, k, last -
               'a', count];
 
  // If precomputed subproblem
  // occurred
  if (ans != -1)
    return ans;
 
  ans = n + 1;
 
  // Minimum run length encoding by
  // removing the currrent character
  ans = Math.Min(ans,
                 solve(s, n, idx + 1,
                       k - 1, last,
                       count));
 
  // Minimum run length encoding by
  // retaining the currrent character
  int inc = 0;
 
  if (count == 1 || count == 9 ||
      count == 99)
    inc = 1;
 
  // If the current and the
  // previous characters match
  if (last == s[idx])
  {
    ans = Math.Min(ans, inc +
                   solve(s, n, idx + 1,
                         k, s[idx],
                         count + 1));
  }
 
  // Otherwise
  else
  {
    ans = Math.Min(ans, 1 +
                   solve(s, n, idx + 1,
                         k, s[idx], 1));
  }
  return dp[idx, k, last -
            'a', count] = ans;
}
 
// Function to return minimum
// run-length encoding for string
// s by removing atmost k characters
public static int MinRunLengthEncoding(String s,
                                       int n, int k)
{
  for (int i = 0; i < maxN; i++)
    for (int j = 0; j < maxN; j++)
      for (int p = 0; p < 27; p++)
        for (int l = 0; l < maxN; l++)
          dp[i, j, p, l] = -1;
 
  return solve(s, n, 0,
               k, (char)123, 0);
}
 
// Driver Code
public static void Main(String []args)
{
  String S = "abbbcdcdd";
  int N = 9, K = 2;
  Console.WriteLine(
          MinRunLengthEncoding(S,
                               N, K));
}
}
 
// This code is contributed by 29AjayKumar

chevron_right


Output: 

5













 

Time Complexity: O(26 * N2 * K)
Auxiliary Space: O(26 * N2 * K)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.