Compte tenu d'un chaîne s la tâche est de trouver le minimum personnages à être annexé (insertion à la fin) faire un palindrome à cordes.
Exemples :
Saisir : s = 'fait'
Sortir : 2
Explication: Nous pouvons créer un palindrome à cordes comme 'abede pas ' en ajoutant pas à la fin de la chaîne.
Saisir :s = 'aabb'
Sortir : 2
Explication: Nous pouvons créer un palindrome de cordes comme 'aabb aa ' en ajoutant aa à la fin de la chaîne.
Table des matières
- Vérifiez le palindrome à chaque fois - O(n^2) Time et O(n) Space
- Utilisation de l'algorithme de Knuth Morris Pratt - Temps O(n) et Espace O(n)
Vérifiez le palindrome à chaque fois - O(n^2) Time et O(n) Space
C++La solution implique progressivement supprimer des caractères du début de la chaîne un par un jusqu'à ce que la chaîne devienne un palindrome . La réponse sera le nombre total de caractères supprimés.
Par exemple, considérons la chaîne s = 'ici'. Nous vérifions d’abord si la chaîne entière est un palindrome, ce qui n’est pas le cas. Ensuite, nous supprimons le premier caractère, ce qui donne le chaîne 'mendier'. On vérifie encore mais ce n'est toujours pas un palindrome. On supprime ensuite un autre personnage dès le début laissant 'ede'. Cette fois, la corde est un palindrome. Par conséquent le la sortie est 2 représentant le nombre de caractères supprimés depuis le début pour réaliser un palindrome.
// 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);
Sortir
2
Utilisation de l'algorithme de Knuth Morris Pratt - Temps O(n) et Espace O(n)
C++L'idée de base de cette approche est que nous calculer le la plus grande sous-chaîne à partir de la fin et la longueur de la chaîne moins cette valeur est la minimum nombre d'ajouts. La logique est intuitive, nous n'avons pas besoin d'ajouter le palindrome et seulement ceux qui ne forment pas le palindrome. Pour trouver ce plus grand palindrome de la fin, nous inverse la chaîne calcule le DFAE.
Le DFA (Automate Fini Déterministe) mentionné dans le cadre de Algorithme de Knuth Morris Pratt est un concept utilisé pour aider à trouver le préfixe le plus long d'une chaîne qui est également un suffixe et inversez à nouveau la chaîne (récupérant ainsi la chaîne d'origine) et trouvez l'état final qui représente le nombre de correspondances de la chaîne avec la chaîne vénérée et nous obtenons ainsi la plus grande sous-chaîne qui est un palindrome à partir de la fin.
// 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));
Sortir
2
Article connexe :
- Programmation dynamique | Set 28 (Insertions minimales pour former un palindrome)