请根据给定的字符串回文字符串

给定一个仅包含小写英文字母的字符串S ，我们有两名玩家在玩游戏。规则如下：

• 玩家可以从给定的字符串S中删除任何字符，并将其写在纸上空字符串的任意一侧(左侧或右侧)。
• 玩家赢得了比赛，如果可以采取任何行动，首先可以得到长度大于1的回文字符串。
• 如果不能形成回文字符串，则将Player-2声明为获胜者。

两者都以玩家1开始游戏时达到最佳状态。任务是找到游戏的获胜者。
例子：

Input: S = “abc” 
Output: Player-2 
Explanation: 
There are all unique character due to which there 
is no way to form a palindromic string of length > 1
Input: S = “abccab” 
Output: Player-2 
Explanation: 
Initially newString = “” is empty. 
Let Player-1 chooses character ‘a’ and write it on paper. 
Then, S = “bccab” and newString = “a”. 
Now Player-2 chooses character ‘a’ from S and write it on left side of newString. 
Thus, S = “bccb” and newString = “aa”. 
Now, newString = “aa” is a palindrome of length 2. 
Hence, Player-2 wins. 

方法：这个想法是要制定一个条件，让Player-1永远成为赢家。如果条件失败，则Player-2将赢得比赛。

• 如果给定字符串只有一个唯一字符出现一次，而其余字符出现次数超过1，则Player-1将成为获胜者，否则Player-2将始终获胜。
• 如果在给定的字符串我们所有字符出现的次数不止一次，则Player-2总是可以在第一回合中复制Player-1的举动并获胜。
• 另外，如果我们在字符串仅出现一次有多个字符，那么回文字符串就永远不会形成(在最佳情况下)，因此Player-2再次获胜。

下面是上述方法的实现：

C++

// C++ Implementation to find
// which player can form a palindromic
// string first in a game
 
#include 
 
using namespace std;
 
// Function to find
// winner of the game
int palindromeWinner(string& S)
{
    // Array to Maintain frequency
    // of the characters in S
    int freq[26];
 
    // Initialise freq array with 0
    memset(freq, 0, sizeof freq);
 
    // Maintian count of all
    // distinct characters
    int count = 0;
 
    // Finding frequency of each character
    for (int i = 0; i < (int)S.length();
                                   ++i) {
        if (freq[S[i] - 'a'] == 0)
            count++;
 
        freq[S[i] - 'a']++;
    }
 
    // Count unique duplicate
    // characters
    int unique = 0;
    int duplicate = 0;
     
    // Loop to count the unique
    // duplicate characters
    for (int i = 0; i < 26; ++i) {
        if (freq[i] == 1)
            unique++;
        else if (freq[i] >= 2)
            duplicate++;
    }
 
    // Condition for Player-1
    // to be winner
    if (unique == 1 &&
     (unique + duplicate) == count)
        return 1;
 
    // Else Player-2 is
    // always winner
    return 2;
}
 
// Driven Code
int main()
{
    string S = "abcbc";
 
    // Function call
    cout << "Player-"
         << palindromeWinner(S)
         << endl;
 
    return 0;
}

Java

// Java implementation to find which
// player can form a palindromic
// string first in a game
import java.util.*;
 
class GFG{
     
// Function to find
// winner of the game
static int palindromeWinner(String S)
{
     
    // Array to maintain frequency
    // of the characters in S
    int freq[] = new int[26];
 
    // Initialise freq array with 0
    Arrays.fill(freq, 0);
 
    // Maintian count of all
    // distinct characters
    int count = 0;
 
    // Finding frequency of each character
    for(int i = 0; i < (int)S.length(); ++i)
    {
        if (freq[S.charAt(i) - 'a'] == 0)
            count++;
 
        freq[S.charAt(i) - 'a']++;
    }
 
    // Count unique duplicate
    // characters
    int unique = 0;
    int duplicate = 0;
     
    // Loop to count the unique
    // duplicate characters
    for(int i = 0; i < 26; ++i)
    {
        if (freq[i] == 1)
            unique++;
             
        else if (freq[i] >= 2)
            duplicate++;
    }
 
    // Condition for Player-1
    // to be winner
    if (unique == 1 &&
       (unique + duplicate) == count)
        return 1;
 
    // Else Player-2 is
    // always winner
    return 2;
}
     
// Driver Code
public static void main(String s[])
{
    String S = "abcbc";
         
    // Function call
    System.out.println("Player-" + palindromeWinner(S));
}
}
 
// This code is contributed by rutvik_56

Python3

# Python3 implementation to find
# which player can form a palindromic
# string first in a game
 
# Function to find
# winner of the game
def palindromeWinner(S):
     
    # Array to Maintain frequency
    # of the characters in S
    # initialise freq array with 0
    freq = [0 for i in range(0, 26)]
 
    # Maintian count of all
    # distinct characters
    count = 0
 
    # Finding frequency of each character
    for i in range(0, len(S)):
        if (freq[ord(S[i]) - 97] == 0):
            count += 1
 
        freq[ord(S[i]) - 97] += 1
 
    # Count unique duplicate
    # characters
    unique = 0
    duplicate = 0
     
    # Loop to count the unique
    # duplicate characters
    for i in range(0, 26):
        if (freq[i] == 1):
            unique += 1
             
        elif (freq[i] >= 2):
            duplicate += 1
 
    # Condition for Player-1
    # to be winner
    if (unique == 1 and
       (unique + duplicate) == count):
        return 1
 
    # Else Player-2 is
    # always winner
    return 2
 
# Driven Code
S = "abcbc";
 
# Function call
print("Player-", palindromeWinner(S))
 
# This code is contributed by Sanjit_Prasad

C#

// C# implementation to find which
// player can form a palindromic
// string first in a game
using System;
class GFG{
 
// Function to find
// winner of the game
static int palindromeWinner(string S)
{
  // Array to maintain frequency
  // of the characters in S
  int[] freq = new int[26];
 
  // Maintian count of all
  // distinct characters
  int count = 0;
 
  // Finding frequency of
  // each character
  for (int i = 0;
           i < (int)S.Length; ++i)
  {
    if (freq[S[i] - 'a'] == 0)
      count++;
 
    freq[S[i] - 'a']++;
  }
 
  // Count unique duplicate
  // characters
  int unique = 0;
  int duplicate = 0;
 
  // Loop to count the unique
  // duplicate characters
  for (int i = 0; i < 26; ++i)
  {
    if (freq[i] == 1)
      unique++;
 
    else if (freq[i] >= 2)
      duplicate++;
  }
 
  // Condition for Player-1
  // to be winner
  if (unique == 1 &&
     (unique + duplicate) ==
      count)
    return 1;
 
  // Else Player-2 is
  // always winner
  return 2;
}
 
// Driver Code
public static void Main(string[] s)
{
  string S = "abcbc";
 
  // Function call
  Console.Write("Player-" +
                 palindromeWinner(S));
}
}
 
// This code is contributed by Chitranayal

输出：

Player-1

时间复杂度： O(N)