Gegeven een tekenreeks s de taak is om de minimum karakters te zijn toegevoegd (invoeging aan het einde) een stringpalindroom maken.
Voorbeelden:
Invoer : s = ‘klaar’
Uitvoer : 2
Uitleg: We kunnen een stringpalindroom maken als 'abede' niet ' door toe te voegen niet aan het einde van het touwtje.
Invoer : s = 'aabb'
Uitvoer : 2
Uitleg: We kunnen een stringpalindroom as'aabb maken aa ' door toe te voegen aa aan het einde van het touwtje.
Inhoudsopgave
- Controleer elke keer het palindroom - O(n^2) Tijd en O(n) Ruimte
- Met behulp van het Knuth Morris Pratt-algoritme - O (n) tijd en O (n) ruimte
Controleer elke keer het palindroom - O(n^2) Tijd en O(n) Ruimte
C++De oplossing houdt in geleidelijk tekens verwijderen uit de begin van de string één voor één totdat de string een palindroom . Het antwoord is het totale aantal verwijderde tekens.
Denk bijvoorbeeld aan de string s = ‘hier’. We controleren eerst of de hele string een palindroom is, wat niet het geval is. Vervolgens verwijderen we het eerste teken, wat resulteert in de tekenreeks 'smeken'. We controleren nog een keer, maar het is nog steeds geen palindroom. Vervolgens verwijderen we een ander personage vanaf het begin 'ede' achterlatend. Deze keer is de snaar een palindroom. Daarom de uitvoer bedraagt 2 vertegenwoordigt het aantal tekens dat vanaf het begin is verwijderd om een palindroom te bereiken.
// C++ code to find minimum number // of appends to make string Palindrome #include
// Java code to find minimum number // of appends to make string Palindrome import java.util.*; class GfG { // Function to check if a given string is a palindrome static boolean isPalindrome(String s) { int left = 0 right = s.length() - 1; while (left < right) { if (s.charAt(left) != s.charAt(right)) return false; left++; right--; } return true; } // Function to find the minimum number of // characters to remove from the beginning static int noOfAppends(String s) { int n = s.length(); // Remove characters from the start until // the string becomes a palindrome for (int i = 0; i < n; i++) { if (isPalindrome(s.substring(i))) { // Return the number of characters removed return i; } } // If no palindrome is found remove // all but one character return n - 1; } public static void main(String[] args) { String s = 'abede'; int result = noOfAppends(s); System.out.println(result); } }
# Python code to find minimum number # of appends to make string Palindrome # Function to check if a given string is a palindrome def is_palindrome(s): left right = 0 len(s) - 1 while left < right: if s[left] != s[right]: return False left += 1 right -= 1 return True # Function to find the minimum number of # characters to remove from the beginning def no_of_appends(s): n = len(s) # Remove characters from the start until # the string becomes a palindrome for i in range(n): if is_palindrome(s[i:]): # Return the number of characters # removed return i # If no palindrome is found remove # all but one character return n - 1 if __name__ == '__main__': s = 'abede' result = no_of_appends(s) print(result)
// C# code to find minimum number // of appends to make string Palindrome using System; class GfG { // Function to check if a given string // is a palindrome static bool IsPalindrome(string s) { int left = 0 right = s.Length - 1; while (left < right) { if (s[left] != s[right]) return false; left++; right--; } return true; } // Function to find the minimum number of // characters to remove from the beginning static int NoOfAppends(string s) { int n = s.Length; // Remove characters from the start until // the string becomes a palindrome for (int i = 0; i < n; i++) { if (IsPalindrome(s.Substring(i))) { // Return the number of characters // removed return i; } } // If no palindrome is found remove all but // one character return n - 1; } static void Main(string[] args) { string s = 'abede'; int result = NoOfAppends(s); Console.WriteLine(result); } }
// JavaScript code to find minimum number // of appends to make string Palindrome // Function to check if a given string is a palindrome function isPalindrome(s) { let left = 0 right = s.length - 1; while (left < right) { if (s[left] !== s[right]) return false; left++; right--; } return true; } // Function to find the minimum number of // characters to remove from the beginning function noOfAppends(s) { let n = s.length; // Remove characters from the start until // the string becomes a palindrome for (let i = 0; i < n; i++) { if (isPalindrome(s.substring(i))) { // Return the number of // characters removed return i; } } // If no palindrome is found remove // all but one character return n - 1; } const s = 'abede'; const result = noOfAppends(s); console.log(result);
Uitvoer
2
Met behulp van het Knuth Morris Pratt-algoritme - O (n) tijd en O (n) ruimte
C++Het basisidee achter de aanpak is dat wij berekenen de grootste subtekenreeks vanaf het einde en de lengte van het touw minus deze waarde is de minimum aantal bijlagen. De logica is intuïtief, we hoeven er geen aan toe te voegen palindroom en alleen degenen die niet het palindroom vormen. Om dit grootste palindroom vanaf het einde te vinden, moeten we achteruit de string berekent de DFA.
De DFA (Deterministische eindige automaat) genoemd in het kader van de Knuth Morris Pratt-algoritme is een concept dat wordt gebruikt om te helpen bij het vinden van de langste voorvoegsel van een tekenreeks die tevens een achtervoegsel is en de string opnieuw omkeren (en zo de originele string terugkrijgen) en de eindstatus vinden die het aantal overeenkomsten van de string met de gerespecteerde string vertegenwoordigt en daarom krijgen we de grootste substring die vanaf het einde een palindroom is.
// CPP program for the given approach // using 2D vector for DFA #include
// Java program for the given approach // using 2D array for DFA import java.util.*; class GfG { // Function to build the DFA and precompute the state static int[][] buildDFA(String s) { int n = s.length(); // Number of possible characters (ASCII range) int c = 256; // Initialize 2D array with zeros int[][] dfa = new int[n][c]; int x = 0; dfa[0][s.charAt(0)] = 1; // Build the DFA for the given string for (int i = 1; i < n; i++) { for (int j = 0; j < c; j++) { dfa[i][j] = dfa[x][j]; } dfa[i][s.charAt(i)] = i + 1; x = dfa[x][s.charAt(i)]; } return dfa; } // Function to find the longest overlap // between the string and its reverse static int longestOverlap(int[][] dfa String query) { int ql = query.length(); int state = 0; // Traverse through the query to // find the longest overlap for (int i = 0; i < ql; i++) { state = dfa[state][query.charAt(i)]; } return state; } // Function to find the minimum // number of characters to append static int minAppends(String s) { // Reverse the string String reversedS = new StringBuilder(s).reverse().toString(); // Build the DFA for the reversed string int[][] dfa = buildDFA(reversedS); // Get the longest overlap with the original string int longestOverlapLength = longestOverlap(dfa s); // Minimum characters to append // to make the string a palindrome return s.length() - longestOverlapLength; } public static void main(String[] args) { String s = 'abede'; System.out.println(minAppends(s)); } }
# Python program for the given approach # using 2D list for DFA # Function to build the DFA and precompute the state def buildDFA(s): n = len(s) # Number of possible characters (ASCII range) c = 256 # Initialize 2D list with zeros dfa = [[0] * c for _ in range(n)] x = 0 dfa[0][ord(s[0])] = 1 # Build the DFA for the given string for i in range(1 n): for j in range(c): dfa[i][j] = dfa[x][j] dfa[i][ord(s[i])] = i + 1 x = dfa[x][ord(s[i])] return dfa # Function to find the longest overlap # between the string and its reverse def longestOverlap(dfa query): ql = len(query) state = 0 # Traverse through the query to # find the longest overlap for i in range(ql): state = dfa[state][ord(query[i])] return state # Function to find the minimum # number of characters to append def minAppends(s): # Reverse the string reversedS = s[::-1] # Build the DFA for the reversed string dfa = buildDFA(reversedS) # Get the longest overlap with the # original string longestOverlapLength = longestOverlap(dfa s) # Minimum characters to append # to make the string a palindrome return len(s) - longestOverlapLength if __name__ == '__main__': s = 'abede' print(minAppends(s))
// C# program for the given approach // using 2D array for DFA using System; class GfG { // Function to build the DFA and precompute the state static int[] buildDFA(string s) { int n = s.Length; // Number of possible characters // (ASCII range) int c = 256; // Initialize 2D array with zeros int[] dfa = new int[n c]; int x = 0; dfa[0 s[0]] = 1; // Build the DFA for the given string for (int i = 1; i < n; i++) { for (int j = 0; j < c; j++) { dfa[i j] = dfa[x j]; } dfa[i s[i]] = i + 1; x = dfa[x s[i]]; } return dfa; } // Function to find the longest overlap // between the string and its reverse static int longestOverlap(int[] dfa string query) { int ql = query.Length; int state = 0; // Traverse through the query to // find the longest overlap for (int i = 0; i < ql; i++) { state = dfa[state query[i]]; } return state; } // Function to find the minimum // number of characters to append static int minAppends(string s) { // Reverse the string using char array char[] reversedArray = s.ToCharArray(); Array.Reverse(reversedArray); string reversedS = new string(reversedArray); // Build the DFA for the reversed string int[] dfa = buildDFA(reversedS); // Get the longest overlap with the original string int longestOverlapLength = longestOverlap(dfa s); // Minimum characters to append // to make the string a palindrome return s.Length - longestOverlapLength; } static void Main() { string s = 'abede'; Console.WriteLine(minAppends(s)); } }
// JavaScript program for the given approach // using 2D array for DFA // Function to build the DFA and precompute the state function buildDFA(s) { let n = s.length; // Number of possible characters // (ASCII range) let c = 256; // Initialize 2D array with zeros let dfa = Array.from({ length: n } () => Array(c).fill(0)); let x = 0; dfa[0][s.charCodeAt(0)] = 1; // Build the DFA for the given string for (let i = 1; i < n; i++) { for (let j = 0; j < c; j++) { dfa[i][j] = dfa[x][j]; } dfa[i][s.charCodeAt(i)] = i + 1; x = dfa[x][s.charCodeAt(i)]; } return dfa; } // Function to find the longest overlap // between the string and its reverse function longestOverlap(dfa query) { let ql = query.length; let state = 0; // Traverse through the query to // find the longest overlap for (let i = 0; i < ql; i++) { state = dfa[state][query.charCodeAt(i)]; } return state; } // Function to find the minimum // number of characters to append function minAppends(s) { // Reverse the string let reversedS = s.split('').reverse().join(''); // Build the DFA for the reversed string let dfa = buildDFA(reversedS); // Get the longest overlap with the original string let longestOverlapLength = longestOverlap(dfa s); // Minimum characters to append // to make the string a palindrome return s.length - longestOverlapLength; } let s = 'abede'; console.log(minAppends(s));
Uitvoer
2
Gerelateerd artikel:
- Dynamisch programmeren | Set 28 (Minimale inserties om een palindroom te vormen)