最长回文字符串通过从给定阵列连接字符串可能

给定一个由N 个长度为M 的不同字符串组成的字符串数组S[] 。任务是通过连接给定数组中的一些字符串来生成可能最长的回文字符串。

例子：

Input: N = 4, M = 3, S[] = {“omg”, “bbb”, “ffd”, “gmo”}
Output: omgbbbgmo
Explanation: Strings “omg” and “gmo” are reverse of each other and “bbb” is itself a palindrome. Therefore, concatenating “omg” + “bbb” + “gmo” generates the longest palindromic string “omgbbbgmo”.

Input: N = 4, M = 3, s[]={“poy”, “fgh”, “hgf”, “yop”}
Output: poyfghhgfyop

处理方法：按照以下步骤解决问题：

• 初始化一个 Set 并将给定数组中的每个字符串插入到Set 中。
• 初始化两个向量left_ans和right_ans以跟踪获得的回文字符串。
• 现在，遍历字符串数组并检查其反向是否存在于Set 中。
• 如果发现是真的，插入字符串入left_ans之一，另一个为right_ans和擦除无论是从设置，以避免重复的字符串。
• 如果一个字符串是一个回文并且它的一对在 Set 中不存在，那么该字符串需要被附加到结果字符串的中间。
• 打印结果字符串。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
void max_len(string s[], int N, int M)
{
    // Stores the distinct strings
    // from the given array
    unordered_set set_str;
 
    // Insert the strings into set
    for (int i = 0; i < N; i++) {
 
        set_str.insert(s[i]);
    }
 
    // Stores the left and right
    // substrings of the given string
    vector left_ans, right_ans;
 
    // Stores the middle substring
    string mid;
 
    // Traverse the array of strings
    for (int i = 0; i < N; i++) {
 
        string t = s[i];
 
        // Reverse the current string
        reverse(t.begin(), t.end());
 
        // Checking if the string is
        // itself a palindrome or not
        if (t == s[i]) {
 
            mid = t;
        }
 
        // Check if the reverse of the
        // string is present or not
        else if (set_str.find(t)
                != set_str.end()) {
 
            // Append to the left substring
            left_ans.push_back(s[i]);
 
            // Append to the right substring
            right_ans.push_back(t);
 
            // Erase both the strings
            // from the set
            set_str.erase(s[i]);
            set_str.erase(t);
        }
    }
 
    // Print the left substring
    for (auto x : left_ans) {
 
        cout << x;
    }
 
    // Print the middle substring
    cout << mid;
 
    reverse(right_ans.begin(),
            right_ans.end());
 
    // Print the right substring
    for (auto x : right_ans) {
 
        cout << x;
    }
}
 
// Driver Code
int main()
{
    int N = 4, M = 3;
    string s[] = { "omg", "bbb",
                "ffd", "gmo" };
 
    // Function Call
    max_len(s, N, M);
 
    return 0;
}

Java

// Java program for the
// above approach
import java.util.*;
class GFG{
     
static String reverse(String input)
{
  char[] a = input.toCharArray();
  int l, r = a.length - 1;
   
  for (l = 0; l < r; l++, r--)
  {
    char temp = a[l];
    a[l] = a[r];
    a[r] = temp;
  }
   
  return String.valueOf(a);
}
 
static void max_len(String s[],
                    int N, int M)
{
  // Stores the distinct Strings
  // from the given array
  HashSet set_str =
          new HashSet<>();
 
  // Insert the Strings
  // into set
  for (int i = 0; i < N; i++)
  {
    set_str.add(s[i]);
  }
 
  // Stores the left and right
  // subStrings of the given String
  Vector left_ans =
                 new Vector<>();
  Vector right_ans =
                 new Vector<>();
 
  // Stores the middle
  // subString
  String mid = "";
 
  // Traverse the array
  // of Strings
  for (int i = 0; i < N; i++)
  {
    String t = s[i];
 
    // Reverse the current
    // String
    t = reverse(t);
 
    // Checking if the String is
    // itself a palindrome or not
    if (t == s[i])
    {
      mid = t;
    }
 
    // Check if the reverse of the
    // String is present or not
    else if (set_str.contains(t))
    {
      // Append to the left
      // subString
      left_ans.add(s[i]);
 
      // Append to the right
      // subString
      right_ans.add(t);
 
      // Erase both the Strings
      // from the set
      set_str.remove(s[i]);
      set_str.remove(t);
    }
  }
 
  // Print the left subString
  for (String x : left_ans)
  {
    System.out.print(x);
  }
 
  // Print the middle
  // subString
  System.out.print(mid);
 
  Collections.reverse(right_ans);
  // Print the right subString
   
  for (String x : right_ans)
  {
    System.out.print(x);
  }
}
 
// Driver Code
public static void main(String[] args)
{
  int N = 4, M = 3;
  String s[] = {"omg", "bbb",
                "ffd", "gmo"};
 
  // Function Call
  max_len(s, N, M);
}
}
 
// This code is contributed by Rajput-Ji

Python3

# Python3 program for the above approach
def max_len(s, N, M):
     
    # Stores the distinct strings
    # from the given array
    set_str = {}
  
    # Insert the strings into set
    for i in s:
        set_str[i] = 1
  
    # Stores the left and right
    # substrings of the given string
    left_ans, right_ans = [], []
  
    # Stores the middle substring
    mid = ""
  
    # Traverse the array of strings
    for i in range(N):
        t = s[i]
  
        # Reverse the current string
        t = t[::-1]
  
        # Checking if the is
        # itself a palindrome or not
        if (t == s[i]):
            mid = t
  
        # Check if the reverse of the
        # is present or not
        elif (t in set_str):
  
            # Append to the left substring
            left_ans.append(s[i])
  
            # Append to the right substring
            right_ans.append(t)
  
            # Erase both the strings
            # from the set
            del set_str[s[i]]
            del set_str[t]
  
    # Print the left substring
    for x in left_ans:
        print(x, end = "")
  
    # Print the middle substring
    print(mid, end = "")
  
    right_ans = right_ans[::-1]
  
    # Print the right substring
    for x in right_ans:
        print(x, end = "")
  
# Driver Code
if __name__ == '__main__':
     
    N = 4
    M = 3
     
    s = [ "omg", "bbb", "ffd", "gmo"]
  
    # Function call
    max_len(s, N, M)
     
# This code is contributed by mohit kumar 29

C#

// C# program for the
// above approach
using System;
using System.Collections.Generic;
class GFG{
     
static String reverse(String input)
{
  char[] a = input.ToCharArray();
  int l, r = a.Length - 1;
 
  for (l = 0; l < r; l++, r--)
  {
    char temp = a[l];
    a[l] = a[r];
    a[r] = temp;
  }
 
  return String.Join("", a);
}
 
static void max_len(String []s,
                    int N, int M)
{
  // Stores the distinct Strings
  // from the given array
  HashSet set_str =
          new HashSet();
 
  // Insert the Strings
  // into set
  for (int i = 0; i < N; i++)
  {
    set_str.Add(s[i]);
  }
 
  // Stores the left and right
  // subStrings of the given String
  List left_ans =
       new List();
  List right_ans =
       new List();
 
  // Stores the middle
  // subString
  String mid = "";
 
  // Traverse the array
  // of Strings
  for (int i = 0; i < N; i++)
  {
    String t = s[i];
 
    // Reverse the current
    // String
    t = reverse(t);
 
    // Checking if the String is
    // itself a palindrome or not
    if (t == s[i])
    {
      mid = t;
    }
 
    // Check if the reverse of the
    // String is present or not
    else if (set_str.Contains(t))
    {
      // Append to the left
      // subString
      left_ans.Add(s[i]);
 
      // Append to the right
      // subString
      right_ans.Add(t);
 
      // Erase both the Strings
      // from the set
      set_str.Remove(s[i]);
      set_str.Remove(t);
    }
  }
 
  // Print the left subString
  foreach (String x in left_ans)
  {
    Console.Write(x);
  }
 
  // Print the middle
  // subString
  Console.Write(mid);
 
  right_ans.Reverse();
  // Print the right subString
 
  foreach (String x in right_ans)
  {
    Console.Write(x);
  }
}
 
// Driver Code
public static void Main(String[] args)
{
  int N = 4, M = 3;
  String []s = {"omg", "bbb",
                "ffd", "gmo"};
 
  // Function Call
  max_len(s, N, M);
}
}
 
// This code is contributed by 29AjayKumar

Javascript

// Javascript program for the
// above approach
 
function reverse(input)
{
    let a = input.split("");
    a.reverse();
    return a.join("");
}
 
function max_len(s, N, M)
{
 
    // Stores the distinct Strings
  // from the given array
  let set_str = new Set();
  
  // Insert the Strings
  // into set
  for (let i = 0; i < N; i++)
  {
    set_str.add(s[i]);
  }
  
  // Stores the left and right
  // subStrings of the given String
  let left_ans = [];
   
  let right_ans = [];
  
  // Stores the middle
  // subString
  let mid = "";
  
  // Traverse the array
  // of Strings
  for (let i = 0; i < N; i++)
  {
    let t = s[i];
  
    // Reverse the current
    // String
    t = reverse(t);
  
    // Checking if the String is
    // itself a palindrome or not
    if (t == s[i])
    {
      mid = t;
    }
  
    // Check if the reverse of the
    // String is present or not
    else if (set_str.has(t))
    {
      // Append to the left
      // subString
      left_ans.push(s[i]);
  
      // Append to the right
      // subString
      right_ans.push(t);
  
      // Erase both the Strings
      // from the set
      set_str.delete(s[i]);
      set_str.delete(t);
    }
  }
  
  // Print the left subString
  for (let x=0;x< left_ans.length;x++)
  {
    document.write(left_ans[x]);
  }
  
  // Print the middle
  // subString
  document.write(mid);
  
  (right_ans).reverse();
  // Print the right subString
    
  for (let x = 0; x < right_ans.length; x++)
  {
    document.write(right_ans[x]);
  }
}
 
// Driver Code
 
let N = 4, M = 3;
let s=["omg", "bbb",
                "ffd", "gmo"];
// Function Call
max_len(s, N, M);
 
// This code is contributed by patel2127

输出：

omgbbbgmo

时间复杂度： O(N * M)
辅助空间： O(N * M)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。