给定一个数字字符串S ，任务是找到子序列的最大长度，该子序列的左旋转数等于其右旋转数。
例子：
Input: S = “100210601”
Output: 4
Explanation:
The subsequence “0000” satisfies the necessary condition.
The subsequence “1010” generates the string “0101” on left rotation and string “0101” on right rotation. Since both the rotations are same. Therefore, “1010” satisfies the condition as well.
Therefore, the maximum length of such subsequence is 4.
Input: S = “252525”
Output: 6
Explanation:
The subsequence “252525” generates the string “525252” on left rotation and string “525252” on right rotation. Since both the rotations are same. Therefore, the “252525” satisfies the required condition.
天真的方法：解决问题的最简单方法是生成给定字符串的所有可能的子序列，对于每个子序列，检查其左旋是否等于其右旋。
时间复杂度： O(2 N * N)
辅助空间： O(N)
高效方法：为优化上述方法，主要观察结果是，子序列应由单个字符组成，或者长度应由两个字符交替组成。
Illustration:
str = “2424”
Left rotation of the string = “4242”
Right rotation of the string = “4242”
As we can see, since the number is of even length having two characters appearing alternately, therefore, the left and right rotation of the given number is equal.
str = “24242”
Left rotation of the string = “42422”
Right rotation of the string = “22424”
As we can see, since the number is of odd length having two characters appearing alternately, therefore, the left and right rotation of the given number is not equal.
请按照以下步骤解决问题：
- 生成所有可能的两位数字。
- 对于生成的每个两位数字，请检查字符串中两个数字是否交替出现。保持递增计数以存储特定组合的交替子序列的长度。
- 整个遍历字符串，检查两个数字是否相等。如果发现是正确的，则将计数更新为所需的答案。如果两个数字相等，则分别更新计数或计数–如果计数分别为偶数或奇数，则将答案更新为1 。
- 对所有可能的组合重复上述步骤，并打印获得的最大计数。
下面是上述方法的实现：
C++
// C++ Program to implement
// the above approach
#include
using namespace std;
// Function to find the longest subsequence
// having equal left and right rotation
int findAltSubSeq(string s)
{
// Length of the string
int n = s.size(), ans = INT_MIN;
// Iterate for all possible combinations
// of a two-digit numbers
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
int cur = 0, f = 0;
// Check for alternate occurrence
// of current combination
for (int k = 0; k < n; k++) {
if (f == 0 and s[k] - '0' == i) {
f = 1;
// Increment the current value
cur++;
}
else if (f == 1 and s[k] - '0' == j) {
f = 0;
// Increment the current value
cur++;
}
}
// If alternating sequence is
// obtained of odd length
if (i != j and cur % 2 == 1)
// Reduce to even length
cur--;
// Update answer to store
// the maximum
ans = max(cur, ans);
}
}
// Return the answer
return ans;
}
// Driver Code
int main()
{
string s = "100210601";
cout << findAltSubSeq(s);
return 0;
} Java
// Java Program to implement
// the above approach
import java.util.*;
class GFG{
// Function to find the longest subsequence
// having equal left and right rotation
static int findAltSubSeq(String s)
{
// Length of the String
int n = s.length(), ans = Integer.MIN_VALUE;
// Iterate for all possible combinations
// of a two-digit numbers
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
int cur = 0, f = 0;
// Check for alternate occurrence
// of current combination
for (int k = 0; k < n; k++)
{
if (f == 0 && s.charAt(k) - '0' == i)
{
f = 1;
// Increment the current value
cur++;
}
else if (f == 1 &&
s.charAt(k) - '0' == j)
{
f = 0;
// Increment the current value
cur++;
}
}
// If alternating sequence is
// obtained of odd length
if (i != j && cur % 2 == 1)
// Reduce to even length
cur--;
// Update answer to store
// the maximum
ans = Math.max(cur, ans);
}
}
// Return the answer
return ans;
}
// Driver Code
public static void main(String[] args)
{
String s = "100210601";
System.out.print(findAltSubSeq(s));
}
}
// This code is contributed by PrinciRaj1992Python3
# Python3 program to implement
# the above approach
import sys
# Function to find the longest subsequence
# having equal left and right rotation
def findAltSubSeq(s):
# Length of the string
n = len(s)
ans = -sys.maxsize - 1
# Iterate for all possible combinations
# of a two-digit numbers
for i in range(10):
for j in range(10):
cur, f = 0, 0
# Check for alternate occurrence
# of current combination
for k in range(n):
if (f == 0 and ord(s[k]) -
ord('0') == i):
f = 1
# Increment the current value
cur += 1
elif (f == 1 and ord(s[k]) -
ord('0') == j):
f = 0
# Increment the current value
cur += 1
# If alternating sequence is
# obtained of odd length
if i != j and cur % 2 == 1:
# Reduce to even length
cur -= 1
# Update answer to store
# the maximum
ans = max(cur, ans)
# Return the answer
return ans
# Driver code
s = "100210601"
print(findAltSubSeq(s))
# This code is contributed by Stuti PathakC#
// C# Program to implement
// the above approach
using System;
class GFG{
// Function to find the longest subsequence
// having equal left and right rotation
static int findAltSubSeq(String s)
{
// Length of the String
int n = s.Length, ans = int.MinValue;
// Iterate for all possible combinations
// of a two-digit numbers
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
int cur = 0, f = 0;
// Check for alternate occurrence
// of current combination
for (int k = 0; k < n; k++)
{
if (f == 0 && s[k] - '0' == i)
{
f = 1;
// Increment the current value
cur++;
}
else if (f == 1 &&
s[k] - '0' == j)
{
f = 0;
// Increment the current value
cur++;
}
}
// If alternating sequence is
// obtained of odd length
if (i != j && cur % 2 == 1)
// Reduce to even length
cur--;
// Update answer to store
// the maximum
ans = Math.Max(cur, ans);
}
}
// Return the answer
return ans;
}
// Driver Code
public static void Main(String[] args)
{
String s = "100210601";
Console.Write(findAltSubSeq(s));
}
}
// This code is contributed by PrinciRaj19924
时间复杂度： O(N)
辅助空间： O(1)