Manipulating strings is critical in a variety of problem-solving scenarios. The permutation of a given string was found to optimize the number of characters greater than the number of adjacent characters. This is an interesting puzzle that requires rearranging the characters of a string to generate as many pairs of adjacent characters as possible, where the characters on the left are smaller than the characters on the right. . p>
There are various ways to solve permutations of strings where the maximum number of characters is greater than the number of characters directly adjacent to it.
Method 1 − Backtracking and pruning −
Method 2 - Dynamic Programming -
Method 3 - Heap Algorithm-
Method 4 - Dictionary order with pruning -
Use the backtracking algorithm to generate all permutations of the string.
At each step, check whether the current arrangement has more characters than its neighbors greater than the maximum found so far.
If not, prune the branch early and backtrack to avoid unnecessary calculations.
function backtrack_permutation(string): n = length(string) max_count = [0]
Storage the maximum number of characters greater than adjacent characters
result = [None] * n
Storing the final arrangement
function backtrack(curr_permutation, used_chars): nonlocal max_count if length(cu permutation) == n:
Calculate the number of characters that are greater than adjacent characters
count = 0
for i in range(1, n - 1):
if cu permutation [i - 1] < cu permutation[i] > cu permutation [i + 1]:
count += 1
if count > max count [0]:
max count [0] = count
result [:] = cu permutation
Update results
return
for i in range(n):
if not used_chars[i]:
Select next character
used_chars[i] = true curr_permutation.append(string[i])
Backtrack to the next position
backtrack(curr_permutation, used_chars)
Unselect
used_chars[i] = false curr_permutation.pop()
Start the backtracking process
used_chars = [false] * n
Track used characters
curr_permutation = [] backtrack(curr_permutation, used_chars) return result.
Step 1 - Start max_permutation with an empty string.
Auxiliary function traceback (current_permutation, remaining_characters) should be defined.
Step 2 - If the string remaining_characters is empty -
If the length of the current permutation is longer than the length of the largest permutation, set max_permutation to current_permutation.
return.
Step 3 - In an iteration, loop through each of the remaining characters c -
Add c to current_permutation to create new_permutation.
If the length of new_permutation is greater than 1 and its last character is no longer longer than its preceding characters, this iteration is skipped.
Take c from remaining_characters and generate new new_remaining.
Iterative call traceback (new_permutation, new_remaining).
Step 4 - Call the traceback function, using the input text as remaining_characters and the empty string as current_permutation.
Step 5 - Provide the output max_permutation.
This program operates by first sorting the input string "abcd" in ascending order. Each possible permutation is then generated using a backtracking function that only considers characters greater than the previous character, thus avoiding repeated permutations that do not meet the criteria. Additionally, the isValidPermutation function evaluates each character against its preceding character, returning false for any equal to or less than the latter.
The result is that this purposeful process creates all valid permutations in which the maximum number of each character is higher than its neighboring characters. We are free to further customize the given input strings, code and logic to suit individual requirements.
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int maxCount = 0;
bool isValidPermutation(const string& str) {
for (int i = 1; i < str.length(); i++) {
if (str[i] <= str[i - 1]) {
return false;
}
}
return true;
}
void backtrack(string& str, int pos) {
if (pos == str.length()) {
if (isValidPermutation(str)) {
cout << str << endl;
}
return;
}
for (int i = pos; i < str.length(); i++) {
swap(str[pos], str[i]);
if (str[pos] > str[pos - 1]) {
backtrack(str, pos + 1);
}
swap(str[pos], str[i]);
}
}
int main() {
string input = "abcd";
sort(input.begin(), input.end()); // Sort the input string initially
backtrack(input, 1);
return 0;
}
abcd
Use dynamic programming to gradually generate permutations of strings.
Starting from an empty prefix, iteratively adds characters to it considering all possible positions.
Maintain the number of characters in the current prefix that is greater than its adjacent characters.
Prune branches whose counts have dropped below the maximum value found so far.
def find_max_permutation(string): n = len(string) dp = [0] * n dp[0] = 1
Dynamic Programming Loop
for i in range (1, n):
Check whether the current character is greater than its adjacent characters
if string[i] > string[i-1]:
If yes, increase the count by 1
dp[i] = dp[i-1] + 1 else:
If not, the counts are the same
dp[i] = dp[i-1]
Find the maximum count in the dp array
max_count = max(dp) return max_count
Step 1 - Create a function called maxPerm(str) that accepts a string as input and returns the permutation of the longest string that satisfies the specified criteria.
Step 2 - First initialize an array of length n (called dp), where n is equal to the length of the input string str. The maximum permutation string ending at position i is stored in each element dp[i].
Step 3 - Initialize dp [0] to the first character of the string str.
Step 4 - Iterate through the characters of str from index 1 to n-1 -
初始化一个空字符串curr来存储当前最大排列字符串。
对于索引 i 处的每个字符，将其与索引 i-1 处的前一个字符进行比较。
如果 str[i] 大于 str[i-1]，将 str[i] 添加到 curr 中。
否则，将 str[i-1] 追加到 curr 中。
使用 dp[i-1] 和 curr 之间的最大值更新 dp[i]。
第5步 - 循环完成后，最大排列字符串将存储在dp[n-1]中。
第 6 步 - 返回 dp[n-1] 作为结果。
在此示例中，输入字符串被硬编码为“abcbdb”。 findMaxPermutation 函数使用动态编程来计算每个索引处大于其相邻字符的最大字符数。然后，它通过回溯表来重建具有最大计数的字符串。生成的最大排列在 main 函数中打印。
#include <iostream>
#include <string>
#include <vector>
std::string findMaxPermutation(const std::string& str) {
int n = str.length();
// make a table to store the maximum count of characters
// larger than their adjacent characters
std::vector<std::vector<int>> dp(n, std::vector<int>(2, 0));
// Initialize the table for the base case
dp[0][0] = 0; // Count when str[0] is not included
dp[0][1] = 1; // Count when str[0] is included
// Calculate the maximum count for each index
for (int i = 1; i < n; i++) {
// When str[i] is not involved, the count is the maximum
// when str[i-1] is included or not
dp[i][0] = std::max(dp[i-1][0], dp[i-1][1]);
// When str[i] is involved, the count is the count when
// str[i-1] is not included plus 1
dp[i][1] = dp[i-1][0] + 1;
}
// The more count will be the largest of the last two values
int maxCount = std::max(dp[n-1][0], dp[n-1][1]);
// Reconstruct the string with the maximum count
std::string maxPerm;
int i = n - 1;
int count = maxCount;
// Start from the end and check which character to include
while (i >= 0) {
if ((dp[i][0] == count - 1 && dp[i][1] == count) || (dp[i][0] == count && dp[i][1] == count)) {
maxPerm = str[i] + maxPerm;
count--;
}
i--;
}
return maxPerm;
}
int main() {
std::string str = "abcbdb";
std::string maxPerm = findMaxPermutation(str);
std::cout << "String: " << str << std::endl;
std::cout << "Max Permutation: " << maxPerm << std::endl;
return 0;
}
String: abcbdb Max Permutation: bbb
实现Heap算法，高效地生成字符串的所有排列。
生成每个排列后，计算大于其相邻字符的字符数量。
保持追踪到目前为止找到的最大计数，并根据需要进行更新。
function generatePermutations(string):
n = length(string)
characters = array of n elements initialized with string's characters
generatePermutationsHelper(n, characters)
function generatePermutationsHelper(n, characters):
if n = 1:
checkAndPrintPermutation(characters)
else:
for i = 0 to n-1:
generatePermutationsHelper(n-1, characters)
if n is even:
swap characters[i] and characters[n-1]
else:
swap characters [0] and characters[n-1]
第一步 - 已经初始化了一个数组，用于存储输入字符串的字符。
第 2 步 - 继续创建一个函数，并将其命名为“generatePermutations”，带有两个参数 - 一个最终变量“size”，用于确定数组的大小，以及一个名为“arr”的数组，其中包含字符串字符。
步骤 3 - 如果大小为 1，则通过将数组中的字符组合在一起，直到最大字符数超过连续字符数，打印当前排列。
步骤 4 - 如果不是，则函数返回。为了从索引 0 到 'size - 1' 迭代数组，我们使用一个名为 'i' 的变量。
第 5 步 - 在此迭代中，我们进一步迭代参数大小 - 1 和错误的generatePermutations 函数。
第 6 步 - 如果 size 恰好是奇数，则我们将数组中索引 0 处的元素替换为索引“size - 1”处的元素。
第 7 步 - 类似地，如果 size 结果是偶数，我们将数组中索引“i”处的元素替换为索引“size - 1”。
步骤8 - 最后，我们使用初始数组大小和数组本身作为参数调用"generatePermutations"函数。
以下的C++示例使用Heap's算法创建字符串的排列，并识别出在其相邻字符上具有最大字符数的排列 −
为了说明问题，在这个例子中使用"abcd"作为输入字符串。可以修改变量来使用不同的输入字符串。如果排列满足具有比其邻居更多字符的要求，则找到isValidPermutation函数是否有效。generatePermutations函数使用堆栈方法来跟踪具有最多字符的排列，以便它可以生成输入字符串的每个可能的排列。主函数将最大数量和排列本身作为输出打印。
#include <iostream>
#include <algorithm>
using namespace std;
// Function to check if the permutation satisfies the condition
bool isValidPermutation(const string& perm) {
int n = perm.length();
for (int i = 0; i < n - 1; i++) {
if (abs(perm[i] - perm[i + 1]) <= 1)
return false;
}
return true;
}
// Function to swap two characters in a string
void swapChar(char& a, char& b) {
char temp = a;
a = b;
b = temp;
}
// Heap's Algorithm for generating permutations
void generatePermutations(string& str, int n, int& maxCount, string& maxPerm, int idx = 0) {
if (idx == n - 1) {
if (isValidPermutation(str)) {
int count = count_if(str.begin(), str.end(), [](char c) {
return isalpha(c) && c >= 'A' && c <= 'Z';
});
if (count > maxCount) {
maxCount = count;
maxPerm = str;
}
}
return;
}
for (int i = idx; i < n; i++) {
swapChar(str[idx], str[i]);
generatePermutations(str, n, maxCount, maxPerm, idx + 1);
swapChar(str[idx], str[i]);
}
}
int main() {
string str = "abcd";
int n = str.length();
int maxCount = 0;
string maxPerm;
generatePermutations(str, n, maxCount, maxPerm);
if (maxCount == 0) {
cout << "No valid permutation found." << endl;
} else {
cout << "Maximum number of characters greater than adjacent characters: " << maxCount << endl;
cout << "Permutation with the maximum count: " << maxPerm << endl;
}
return 0;
}
No valid permutation found.
按字典顺序对字符串的字符进行排序。
生成排序字符串的排列。
在每一步中，检查当前排列是否满足最大字符数大于其相邻字符的条件。
如果不是这样，请跳过具有相似前缀的剩余排列，以避免不必要的计算。
生成字符串所有排列的函数
function generatePermutations(string):
TODO：排列生成的实现
检查字符是否大于其相邻字符的函数
function isGreaterAdjacent(char1, char2):
TODO：比较逻辑的实现
找到具有大于相邻字符的最大数量的排列的函数
function findMaxAdjacentPermutation(string):
生成字符串的所有排列
permutations = generatePermutations(string)
初始化变量
max_permutation = "" max_count = 0
遍历每个排列
for permutation in permutations: count = 0
迭代排列中的每个字符（不包括最后一个字符）
for i from 0 to length(permutation) - 2: char1 = permutation[i] char2 = permutation[i + 1]
检查当前字符是否大于其相邻字符
if isGreaterAdjacent(char1, char2): count = count + 1
检查当前排列的计数是否大于先前的最大值
if count > max_count: max_permutation = permutation max_count = count
返回具有最大计数的排列
return max_permutation
第一步 - 从输入字符串开始。
第 2 步 - 按字典顺序对字符串进行排序以获得初始排列。
第 3 步 - 将变量 maxCount 初始化为 0，以跟踪大于相邻字符的最大字符数。
第 4 步 - 初始化变量 maxPermutation 以存储最大计数的排列。
第 5 步 - 当有下一个排列时 -
将变量 count 初始化为 0，以跟踪当前大于相邻字符的字符数。
对于当前排列中的每个字符 -
检查当前字符是否大于其前一个字符和后一个字符（如果存在）。
如果满足条件，则将计数增加 1。
如果计数大于最大计数（maxCount）-
将maxCount更新为当前计数。
将 maxPermutation 更新为当前排列。
步骤 6 - 将 maxPermutation 作为结果返回。
对于此示例，为简单起见，让我们考虑固定字符串“abcde”。
在这个例子中，countAdjacentGreater函数统计字符串中相邻字符大于其前一个字符的数量。findMaxPermutation函数生成输入字符串的所有排列，并检查每个排列，找出具有最大数量相邻字符大于的那个。
主要函数初始化输入字符串"abcde"和跟踪最大计数和最大排列的变量。它调用findMaxPermutation函数来找到最大排列。
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int countAdjacentGreater(const string& str) {
int count = 0;
for (int i = 0; i < str.length() - 1; i++) {
if (str[i] < str[i + 1]) {
count++;
}
}
return count;
}
void findMaxPermutation(string& str, int& maxCount, string& maxPerm) {
sort(str.begin(), str.end());
do {
int count = countAdjacentGreater(str);
if (count > maxCount) {
maxCount = count;
maxPerm = str;
}
} while (next_permutation(str.begin(), str.end()));
}
int main() {
string str = "abcde";
int maxCount = 0;
string maxPerm;
findMaxPermutation(str, maxCount, maxPerm);
cout << "String with the maximum number of characters greater than its adjacent characters: " << maxPerm << endl;
cout << "Count of adjacent characters greater in the maximum permutation: " << maxCount << endl;
return 0;
}
String with the maximum number of characters greater than its adjacent characters: abcde Count of adjacent characters greater in the maximum permutation: 4
总之，找到最大字符数大于相邻字符的字符串的排列问题是字符串操作中的一个有趣的挑战。通过分析给定的字符串并有策略地重新排列其字符，可以实现所需的排列。这个问题凸显了在使用字符串和排列时仔细检查和创造性思维的重要性。
The above is the detailed content of Arrange strings so that the number of characters in them is greater than the number of adjacent characters.. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
