通过重复镜像操作获得给定 Array 所需的最小元素数

给定一个由N 个整数组成的数组arr[] ，任务是找到最小可能长度的数组K[] ，使得在对K[]执行多次镜像操作后，可以获得给定的数组arr[] 。

Mirror Operation: Appending all the array elements to the original array in reverse order. 
Illustration: 
arr[] = {1, 2, 3} 
After 1^st mirror operation, arr[] modifies to {1, 2, 3, 3, 2, 1} 
After 2^nd mirror operation, arr[] modifies to {1, 2, 3, 3, 2, 1, 1, 2, 3, 3, 2, 1} 
 

例子：

Input: N = 6, arr[] = { 1, 2, 3, 3, 2, 1 } 
Output: 3 
Explanation: 
Subarrays {1, 2, 3} and {3, 2, 1} are mirror images of each other. 
Single mirror operation on {1, 2, 3} obtains the given array. 
Therefore, the minimum number of elements required is 3.
Input: N = 8, arr[] = { 1, 2, 2, 1, 1, 2, 2, 1 } 
Output: 2 
Explanation: 
Subarrays {1, 2, 2, 1} and {1, 2, 2, 1} are mirror images of each other. 
Subarray {1, 2} and {2, 1} are mirror images of each other. 
{1, 2} -> {1, 2, 2, 1} -> {1, 2, 2, 1, 1, 2, 2, 1} 
Therefore, the minimum number of elements required is 2. 
 

天真的方法：
解决问题的最简单方法是从给定的数组中生成所有可能的子数组，其大小小于等于N/2，并且对于每个子数组，检查执行镜像操作是否给出数组arr[] 。打印满足条件的最小长度子数组。如果没有找到满意的子数组，则打印No 。
时间复杂度： O(N ³ )
辅助空间： O(N)
有效的方法：
可以使用分而治之技术进一步优化上述方法。请按照以下步骤解决问题：

• 初始化一个变量K = N ，然后检查长度为K的A[]的前缀是否是回文。
• 如果长度K的前缀是回文，则将K除以2并执行上述检查。
• 如果前缀不是回文，那么答案是K的当前值。
• 在K > 0 时继续检查，直到K为奇数。
• 如果K是奇数，则打印K的当前值。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
// Function to find minimum number
// of elements required to form A[]
// by performing mirroring operation
int minimumrequired(int A[], int N)
{
    // Initialize K
    int K = N;
 
    int ans;
 
    while (K > 0) {
 
        // Odd length array
        // cannot be formed by
        // mirror operation
        if (K % 2 == 1) {
            ans = K;
            break;
        }
 
        bool ispalindrome = 1;
 
        // Check if prefix of
        // length K is palindrome
        for (int i = 0; i < K / 2; i++) {
 
            // Check if not a palindrome
            if (A[i] != A[K - 1 - i])
 
                ispalindrome = 0;
        }
 
        // If found to be palindrome
        if (ispalindrome) {
            ans = K / 2;
            K /= 2;
        }
 
        // Otherwise
        else {
            ans = K;
            break;
        }
    }
 
    // Return the final answer
    return ans;
}
 
// Driver Code
int main()
{
    int a[] = { 1, 2, 2, 1, 1, 2, 2, 1 };
    int N = sizeof a / sizeof a[0];
 
    cout << minimumrequired(a, N);
    return 0;
}

Java

// Java Program to implement
// the above approach
class GFG{
   
// Function to find minimum number
// of elements required to form A[]
// by performing mirroring operation
static int minimumrequired(int A[], int N)
{
    // Initialize K
    int K = N;
  
    int ans=0;
  
    while (K > 0)
    {
  
        // Odd length array
        // cannot be formed by
        // mirror operation
        if (K % 2 == 1)
        {
            ans = K;
            break;
        }
  
        int ispalindrome = 1;
  
        // Check if prefix of
        // length K is palindrome
        for (int i = 0; i < K / 2; i++)
        {
  
            // Check if not a palindrome
            if (A[i] != A[K - 1 - i])
  
                ispalindrome = 0;
        }
  
        // If found to be palindrome
        if (ispalindrome == 1)
        {
            ans = K / 2;
            K /= 2;
        }
  
        // Otherwise
        else
        {
            ans = K;
            break;
        }
    }
  
    // Return the final answer
    return ans;
}
  
// Driver Code
public static void main(String[] args)
{
    int a[] = { 1, 2, 2, 1, 1, 2, 2, 1 };
    int N = a.length;
  
    System.out.println(minimumrequired(a, N));
}
}
 
// This code is contributed by rock_cool

Python3

# Python3 program to implement
# the above approach
 
# Function to find minimum number
# of elements required to form A[]
# by performing mirroring operation
def minimumrequired(A, N):
     
    # Initialize K
    K = N
     
    while (K > 0):
         
        # Odd length array
        # cannot be formed by
        # mirror operation
        if (K % 2) == 1:
            ans = K
            break
         
        ispalindrome = 1
         
        # Check if prefix of
        # length K is palindrome
        for i in range(0, K // 2):
             
            # Check if not a palindrome
            if (A[i] != A[K - 1 - i]):
                ispalindrome = 0
                 
        # If found to be palindrome
        if (ispalindrome == 1):
            ans = K // 2
            K = K // 2
             
        # Otherwise
        else:
            ans = K
            break
     
    # Return the final answer
    return ans
 
# Driver code
A = [ 1, 2, 2, 1, 1, 2, 2, 1 ]
N = len(A)
 
print(minimumrequired(A, N))
         
# This code is contributed by VirusBuddah_

C#

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to find minimum number
// of elements required to form []A
// by performing mirroring operation
static int minimumrequired(int[] A, int N)
{
     
    // Initialize K
    int K = N;
 
    int ans = 0;
 
    while (K > 0)
    {
 
        // Odd length array
        // cannot be formed by
        // mirror operation
        if (K % 2 == 1)
        {
            ans = K;
            break;
        }
 
        int ispalindrome = 1;
 
        // Check if prefix of
        // length K is palindrome
        for(int i = 0; i < K / 2; i++)
        {
 
            // Check if not a palindrome
            if (A[i] != A[K - 1 - i])
                ispalindrome = 0;
        }
 
        // If found to be palindrome
        if (ispalindrome == 1)
        {
            ans = K / 2;
            K /= 2;
        }
 
        // Otherwise
        else
        {
            ans = K;
            break;
        }
    }
 
    // Return the readonly answer
    return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
    int[] a = { 1, 2, 2, 1, 1, 2, 2, 1 };
    int N = a.Length;
 
    Console.WriteLine(minimumrequired(a, N));
}
}
 
// This code is contributed by amal kumar choubey

Javascript

    // Javascript Program to implement
    // the above approach
     
    // Function to find minimum number
    // of elements required to form A[]
    // by performing mirroring operation
    function minimumrequired(A, N)
    {
        // Initialize K
        let K = N;
 
        let ans;
 
        while (K > 0) {
 
            // Odd length array
            // cannot be formed by
            // mirror operation
            if (K % 2 == 1) {
                ans = K;
                break;
            }
 
            let ispalindrome = true;
 
            // Check if prefix of
            // length K is palindrome
            for (let i = 0; i < parseInt(K / 2, 10); i++) {
 
                // Check if not a palindrome
                if (A[i] != A[K - 1 - i])
 
                    ispalindrome = false;
            }
 
            // If found to be palindrome
            if (ispalindrome) {
                ans = parseInt(K / 2, 10);
                K = parseInt(K / 2, 10);
            }
 
            // Otherwise
            else {
                ans = K;
                break;
            }
        }
 
        // Return the final answer
        return ans;
    }
 
    let a = [ 1, 2, 2, 1, 1, 2, 2, 1 ];
    let N = a.length;
   
    document.write(minimumrequired(a, N));
     
    // This code is contributed by divyeshrabadiya07.

输出：

2

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

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