Minimum Number Of Key Presses To Type The Given String In C++

Introduction:

You have the option to employ dynamic programming in C++ to determine the minimum number of keystrokes needed to type a specified string. The concept involves constructing a table where each cell dpi signifies the minimum number of key presses necessary to type the substring s[i..j]. This table is populated in a systematic bottom-up fashion.

Program:

#include <iostream>
#include <vector>
#include <climits>
using namespace std;
int minKeypresses(const string& s) {
    int n = s.length();
    // Create a 2D DP table to store the results
    vector<vector<int>> dp(n, vector<int>(n, INT_MAX));
    // Initialize the diagonal elements where the substring has length 1
    for (int i = 0; i < n; ++i) {
        dp[i][i] = 1;
    }
    // Iterate over all possible substring lengths
    for (int len = 2; len <= n; ++len) {
        for (int i = 0; i <= n - len; ++i) {
            int j = i + len - 1;
            // Check if the substring is a palindrome
            if (s[i] == s[j] && len == 2) {
                dp[i][j] = 1;
            } else if (s[i] == s[j]) {
                // If the endpoints are the same, the result is the same as for the substring without the endpoints
                dp[i][j] = dp[i + 1][j - 1];
            }
            // Try all possible partitions and update the result
            for (int k = i; k < j; ++k) {
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j]);
            }
        }
    }
    // The result is stored in the top-right corner of the table
    return dp[0][n - 1];
}
int main() {
    string s;
    cout << "Enter the string: ";
    cin >> s;
    int result = minKeypresses(s);
    cout << "Minimum number of keypresses: " << result << endl;
    return 0;
}

Output:

Enter the string: abcdefghij
Minimum number of keypresses: 10

Explanation:

• ✅ Initialization:

In this instance, the code begins by importing essential libraries like stream and vector.

The minKeypresses function is created to determine the minimum number of keypresses needed to input a specified string.

A two-dimensional vector named dp is initialized to store the outcomes. dpi will indicate the fewest number of keystrokes needed for the substring spanning from index i to index j.

The function receives a string as an argument:

• ✅ Memoization Table:

The diagonal entries of the dynamic programming table are set to 1 initially. This is due to the fact that a substring with a length of 1 only needs a single keypress.

The function proceeds to iterate through all potential substring lengths (starting from 2) and evaluates every possible substring contained in the provided string.

• ✅ Verification for Palindromes:

When examining each subsequence, the code verifies if the start and end points match, indicating a palindrome. In such cases, it assigns a value of 1 to the keypresses.

If the endpoints are identical, the outcome will be equivalent to that of the substring excluding those specific endpoints.

• ✅ Segmentation:

The code proceeds to test various partition points within the substring and adjusts the minimum key presses accordingly.

It examines all potential divisions and maintains a record of the minimum number of keystrokes needed.

• ✅ Outcome:

The total outcome is saved in dp0, where n stands for the size of the given string. This indicates the least number of keystrokes required for the entire string.

• ✅ Primary Function:

The primary function acquires user input for the string.

It invokes the minKeypresses function using the provided string and displays the outcome.

Complexity analysis:

Time Complexity:

The code implements a dynamic programming technique starting from the bottom and moving upwards to populate the dp table.

The dual nested loops cycle through every conceivable substring lengths and positions within the given string.

The third iteration cycles through potential partition points.

Therefore, the time complexity amounts to O(n^3), with 'n' representing the input string's length.

Space Complexity:

The 2D array dp defines the spatial complexity.

The dimensions of the dynamic programming table are n x n, with 'n' representing the size of the input string.

Thus, the spatial complexity is O(n^2) as it is contingent on the square of the input magnitude.

Approach 1: Using Greedy Algorithm

Traverse the string and tally consecutive characters.

If a character appears continuously, you have the option to input the character along with the count of its consecutive occurrences using a single keystroke.

Program:

#include <iostream>
using namespace std;
int minKeypressesGreedy(const string& s) {
    int n = s.length();
    // Edge case: empty string
    if (n == 0) {
        return 0;
    }
    int totalKeypresses = 1; // Start with 1 to account for the first character
    // Iterate through the string to count consecutive characters
    for (int i = 1; i < n; ++i) {
        int count = 1; // Count of consecutive characters
        while (i < n && s[i] == s[i - 1]) {
            ++count;
            ++i;
        }
        // Add the character and its count to the total keypresses
        totalKeypresses += 1 + (count > 1 ? 1 : 0); // Typing the character and its count
        // Note: If count is 1, no extra keypress is needed for the count
    }
    return totalKeypresses;
}
int main() {
    string s;
    cout << "Enter the string: ";
    cin >> s;
    int result = minKeypressesGreedy(s);
    cout << "Minimum number of keypresses: " << result << endl;
    return 0;
}

Output:

Enter the string: JavaCppTutorial
Minimum number of keypresses: 10

Explanation:

• ✅ Input:

Accepts a string input as 's'.

• ✅ Special Scenario:

Verifies whether the string is devoid of any content. In case it is empty, the function will yield a value of 0 since there are no characters present to input.

• ✅ Setting Up:

Sets the totalKeypresses variable to 1 to account for the initial character in the provided string.

• ✅ When looping through the string:

Utilizes a loop to iterate over every character within the string.

When iterating over each character, a while loop is employed to tally the consecutive occurrences of identical characters.

While iterating, it progresses to the subsequent character until a distinct one is identified.

• ✅ Determining Keypress Count:

Increases the totalKeypresses by the number of consecutive characters plus one extra keystroke for typing the character.

If the quantity is 1 (meaning a single character with no repeated sequence), it does not result in an additional keystroke for the quantity.

• ✅ Outcome:

It provides the end result of totalKeypresses, indicating the least number of keypresses required to input the specified string.

Main Function:

• ✅ Input:

It accepts user input for the string.

• ✅ Invoking the Function:

Invoking the minKeypressesGreedy function using the provided input string.

• ✅ Displaying the Outcome:

Displays the smallest count of keystrokes derived from the function.

Complexity analysis:

Time Complexity:

Iteration through String:

The for loop cycles through every character in the string one at a time.

The while loop contained within it tallies consecutive characters.

In the most unfavorable scenario, every character could be accessed twice (once within the outer loop and once within the while loop).

Therefore, the time complexity for the iteration is O(n), with 'n' representing the size of the input string.

Calculating Keypresses:

The computations within the loop require an unchanging amount of time for each character processed.

The overall time complexity remains O(n).

Main Function:

The primary function receives user input and invokes the minKeypressesGreedy function, which operates with a time complexity of O(n).

The overall time complexity of the code is O(n).

Space Complexity:

Additional Variables:

The code requires a fixed amount of extra space irrespective of the input size.

Variables such as totalKeypresses, count, and loop iterators remain unaffected by the size of the input.

The space complexity is O(1), denoting consistent utilization of memory.

Approach 2: Using Manacher's Algorithm for Longest Palindromic Substring

Identify the longest palindrome substring within the provided string.

Subtracting the length of the palindrome from the total length of the string provides the minimum number of keypresses required.

Program:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// Function to preprocess the string and insert '#' between characters
string preprocess(const string& s) {
    string result = "#";
    for (char c : s) {
        result += c;
        result += '#';
    }
    return result;
}
// Manacher's Algorithm to find the length of the longest palindromic substring
int longestPalindromicSubstring(const string& s) {
    string processedString = preprocess(s);
    int n = processedString.length();
    // Create an array to store the lengths of palindromes centered at each index
    vector<int> palindromeLengths(n, 0);
    int center = 0; // Center of the rightmost palindrome
    int right = 0;  // Right boundary of the rightmost palindrome
    for (int i = 0; i < n; ++i) {
        // Reflect the index 'i' around the center
        int mirror = 2 * center - i;
        // Check if 'i' is within the right boundary
        if (i < right) {
            palindromeLengths[i] = min(right - i, palindromeLengths[mirror]);
        }
        // Attempt to expand the palindrome centered at 'i'
        int a = i + (1 + palindromeLengths[i]);
        int b = i - (1 + palindromeLengths[i]);
        while (a < n && b >= 0 && processedString[a] == processedString[b]) {
            ++palindromeLengths[i];
            ++a;
            --b;
        }
        // Update the right boundary and center if needed
        if (i + palindromeLengths[i] > right) {
            center = i;
            right = i + palindromeLengths[i];
        }
    }
    // Find the maximum length in the palindromeLengths array
    int maxPalindromeLength = *max_element(palindromeLengths.begin(), palindromeLengths.end());
    return maxPalindromeLength;
}
// Function to calculate the minimum keypresses using Manacher's algorithm
int minKeypressesManacher(const string& s) {
    int longestPalindromeLength = longestPalindromicSubstring(s);
    int remainingLength = s.length() - longestPalindromeLength;
    // Subtract the length of the longest palindromic substring from the total length
    return remainingLength;
}
int main() {
    string inputString;
    cout << "Enter the string: ";
    cin >> inputString;
    int result = minKeypressesManacher(inputString);
    cout << "Minimum number of keypresses: " << result << endl;
    return 0;
}

Output:

Enter the string: abcde
Minimum number of keypresses: 4

Explanation:

Preprocessing Function (preprocess):

Given an input:

It requires a string input denoted as s.

• ✅ Algorithm:

Inserts a '#' symbol between every character within the string. This method ensures efficient handling of palindromes of both even and odd lengths.

Manacher's Algorithm Function (longestPalindromicSubstring):

• ✅ Input:

Processes the pre-formatted string upon input.

• ✅ Setup:

Sets up variables to store the position of the center and right edge of the currently identified longest palindrome.

• ✅ Array of Palindrome Lengths:

Forms an array to hold the lengths of palindromes centered at each position.

• ✅ Executing the Algorithm:

Goes through every character in the processed string sequentially.

Leverages symmetry properties to reduce redundant comparisons and effectively determines the length of palindromes centered at each index.

• ✅ Revise Center and Adjust Right Boundary:

Updating the middle and right limits according to the identified palindromes.

• ✅ Determining the Maximum Length:

Determines the highest length within the array of palindrome lengths.

• ✅ Outcome:

Calculates the length of the longest palindrome substring.

To calculate the minimum number of key presses, we can use the function minKeypressesManacher:

• ✅ .

The length of the longest palindromic substring is

• ✅ .

Invoking the longestPalindromicSubstring function to determine the length of the longest palindrome within a given string.

• ✅ Evaluating Minimum Keypress Calculation:

Calculate the minimum number of keypresses required by deducting the length of the longest palindromic substring from the overall length of the initial string.

• ✅ Outcome:

Returns the minimum keypresses.

Main Function:

• ✅ Input:

Takes input from the user to obtain the initial string.

• ✅ Invoking a Function:

Invokes the minKeypressesManacher function with the provided input string.

• ✅ Displaying Outcome:

It displays the lowest count of keystrokes generated by the function.

Complexity analysis:

Time Complexity:

Preprocessing Function (preprocess):

Iterate through every character in the initial string to place '#' between each character.

The time complexity of this function is O(n), with 'n' representing the original string's length.

Function for Manacher's Algorithm to find the longest palindromic substring:

It loops through every character in the processed string sequentially.

The time complexity of Manacher's algorithm is O(n), where 'n' represents the size of the preprocessed string.

Function for determining the minimum number of key presses required (minKeypressesManacher):

It invokes the longestPalindromicSubstring function, which operates with a time complexity of O(n).

Executes basic mathematical calculations, each requiring a consistent amount of time.

The overall time complexity of the code is O(n) .

Space Complexity:

Preprocessing Function (preprocess):

Generates a fresh string with a doubled length of 2n by adding a '#' after each character from the original string.

The space complexity of this function is O(n).

The function implementing Manacher's Algorithm for finding the longest palindromic substring is defined as follows:

Requires extra memory to store the array of palindrome lengths, which is of size n.

The space efficiency of Manacher's algorithm amounts to O(n).

Function for computing the minimum number of key presses (minKeypressesManacher):

It uses constant space for variables.

The space complexity is O(1).

The overall space complexity of the code is O(n).

Approach 3: Using Count Unique Characters

Calculate the quantity of distinct characters present in the given string.

The fewest number of keystrokes required is equal to the length of the string minus the total number of distinct characters present.

Program:

#include <iostream>
#include <unordered_set>
using namespace std;
int minKeypressesCountUnique(const string& s) {
    int n = s.length();
    // Use an unordered_set to keep track of unique characters
    unordered_set<char> uniqueCharacters;
    // Traverse the string and insert each character into the set
    for (char c : s) {
        uniqueCharacters.insert(c);
    }
    // Calculate the minimum keypresses using the formula
    int minKeypresses = n - uniqueCharacters.size();
    return minKeypresses;
}
int main() {
    string inputString;
    cout << "Enter the string: ";
    cin >> inputString;
    int result = minKeypressesCountUnique(inputString);
    cout << "Minimum number of keypresses (Count Unique Characters): " << result << endl;
    return 0;
}

Output:

Enter the string: jtp
Minimum number of keypresses: 0

Explanation:

• ✅ Input:

The minKeypressesCountUnique function accepts a string as its parameter.

• ✅ Establishing Uniqueness:

Creates an unordered set named 'uniqueCharacters' to maintain a record of distinct characters identified.

• ✅ Navigate and Add:

It loops through every character within the string and adds it to the set. The set guarantees uniqueness automatically.

• ✅ Calculating the Minimum Number of Keypresses:

It determines the minimum number of key presses required by applying the following formula: subtracting the count of unique characters from the length of the string.

• ✅ Outcome:

Returns the minimum keypresses as the result.

Complexity analysis:

Time Complexity:

Navigate through and Add (minKeypressesCountUnique method):

Goes through each character in the string sequentially and adds it to the unordered set one by one.

The time complexity of this function is O(n), with 'n' representing the size of the input string.

Calculate Minimum Keypresses:

Determining the minimum number of keypresses required includes identifying the cardinality of the unsorted collection.

Determining the cardinality of an unsorted set typically has an average time complexity of O(1).

The overall time complexity of the code is O(n).

Space Complexity:

Space for Unique Characters (unordered set):

The space efficiency is impacted by the unordered set that holds distinct characters.

In the most unfavorable scenario, the space complexity amounts to O(min(n, m)), with 'n' representing the input string's length and 'm' denoting the count of distinct characters.

Additional Space:

Apart from the unordered set, the code requires a fixed quantity of extra memory for entities such as n, result, and loop counters.

The total space complexity is O(min(n, m)), with 'n' representing the input string's length and 'm' denoting the count of distinct characters.

Approach 4: Using Divide and Conquer

The strategy of "Divide and Conquer" consists of dividing a problem into smaller parts, solving each part recursively, and then merging the solutions to derive the final solution for the entire problem. When determining the minimum keypresses required for a specific string, this approach can be implemented by segmenting the string, computing keypresses for each segment, and subsequently aggregating the outcomes.

Program:

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
// Function to calculate minimum keypresses for a segment of the string
int minKeypressesSegment(const string& segment) {
    // Simple example: just return the length of the segment
    // You can implement more complex logic based on segment characteristics
    return segment.length();
}
// Function to calculate minimum keypresses using Divide and Conquer
int minKeypressesDivideConquer(const string& s, int start, int end) {
    // Base case: if the segment has only one character
    if (start == end) {
        return 1; // Typing a single character requires one key press
    }
    // Divide the segment into two halves
    int mid = start + (end - start) / 2;
    // Recursively calculate minimum keypresses for each half
    int leftKeypresses = minKeypressesDivideConquer(s, start, mid);
    int rightKeypresses = minKeypressesDivideConquer(s, mid + 1, end);
    // Combine the results based on the characteristics of the segments
    // For simplicity, we add the keypresses for each half in this example
    int combinedKeypresses = leftKeypresses + rightKeypresses;
    return combinedKeypresses;
}
int main() {
    string inputString;
    cout << "Enter the string: ";
    cin >> inputString;
    int result = minKeypressesDivideConquer(inputString, 0, inputString.length() - 1);
    cout << "Minimum number of keypresses: " << result << endl;
    return 0;
}

Output:

Enter the string: world
Minimum number of keypresses: 5

Explanation:

Function minKeypressesSegment:

Defines a function responsible for determining the minimum number of key presses required for a specified segment. This function is adaptable and can be tailored to suit the unique attributes of individual segments.

Function minKeypressesDivideConquer:

It utilizes the input string s along with the start and end indices to specify the segment.

Base scenario: When the segment consists of just one character, the function should return 1 since typing a single character necessitates a single keypress.

Split the segment into two equal halves: the first half from the beginning to the middle, and the second half from the middle plus one to the end.

Calculate the minimum number of keypresses recursively for each half of the input.

Merge the outcomes by considering the attributes of the sections. In this instance, we incorporate the keyboard inputs for each division.

Return the combined result.

Main Function:

Takes user input for the original string .

Invokes the minKeypressesDivideConquer function with the complete string as the input parameter.

Complexity analysis:

Time Complexity:

Calls to the minKeypressesDivideConquer function that are recursive in nature.

During every iteration, the function partitions the segment into two equal parts.

The quantity of recursive invocations increases in direct proportion to the depth of the recursive tree, which scales logarithmically with the size of the input string.

Each tier of the recursive tree requires O(1) duration for amalgamating outputs and managing fundamental scenarios.

The total time complexity amounts to O(log n), with 'n' representing the input string's length.

minKeypressesSegment Function (Custom Logic):

The time efficiency of this function is determined by the specific algorithm used to compute keypresses for a segment.

In the given instance, it merely provides the size of the segment, which requires constant time complexity of O(1).

If a more intricate logic is introduced, the time complexity could fluctuate.

The repeated function calls heavily influence the total time complexity, which is O(log n).

Space Complexity:

Memory Allocation (minKeypressesDivideConquer procedure):

Space complexity is defined by the highest depth of the recursion stack.

In the most unfavorable scenario, the highest depth is logarithmic based on the input string's length.

As a result, the space efficiency caused by recursion amounts to O(log n).

Additional Variables:

The code allocates a fixed quantity of extra memory for entities such as mid, leftKeypresses, rightKeypresses, and loop counters.

The total space complexity remains at O(1), demonstrating consistent space utilization.