重复给出原始数组的最小子数组

给定一个由N 个整数组成的数组arr[] ，任务是找到大小至少为 2 的最小子数组 brr[] ，这样通过对数组brr[]执行重复操作得到原始数组arr[] 。如果找不到这样的子数组，则打印“-1” 。

A repeating operation on an array is to append all the current element of the array to the same array again. 
For Example, if an array arr[] = {1, 2} then on repeating operation array becomes {1, 2, 1, 2}.

例子：

Input: arr[] = {1, 2, 3, 3, 1, 2, 3, 3}
Output: {1, 2, 3, 3}
Explanation:
{1, 2, 3, 3} is the smallest subarray which when repeated 2 times gives the original array {1, 2, 3, 3, 1, 2, 3, 3}

Input: arr[] = {1, 1, 6, 1, 1, 7}
Output: -1
Explanation:
There doesn’t exist any subarray.

朴素的方法：这个想法是生成长度至少为 2 的所有可能的子数组，并检查重复这些子数组是否给出原始数组。

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

高效方法：上述方法可以通过观察结果子数组 brr[]必须从原始数组的第一个索引开始以重复生成arr[]这一事实来优化。因此，只生成那些从第一个索引开始并且长度至少为 2 的子数组，并检查重复这些子数组是否给出原始数组。以下是步骤：

1. 创建一个辅助数组brr[]并将原始数组的前两个元素插入其中，因为结果数组的大小必须至少为两个。
2. 遍历子数组[2, N/2 + 1]的可能长度，并检查重复时长度为i的数组brr[]是否给出原始数组arr[] 。
3. 如果是，则打印此子数组并中断循环。
4. 否则，将当前元素插入子数组并再次检查。
5. 重复上述步骤，直到检查完所有子数组。
6. 如果未找到数组brr[]，则打印“-1”。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
#include 
using namespace std;
 
// Function to print the array
void printArray(vector& brr)
{
    for (auto& it : brr) {
        cout << it << ' ';
    }
}
 
// Function to find the smallest subarray
void RepeatingSubarray(int arr[], int N)
{
    // Corner Case
    if (N < 2) {
        cout << "-1";
    }
 
    // Initialize the auxiliary subarray
    vector brr;
 
    // Push the first 2 elements into
    // the subarray brr[]
    brr.push_back(arr[0]);
    brr.push_back(arr[1]);
 
    // Iterate over the length of
    // subarray
    for (int i = 2; i < N / 2 + 1; i++) {
 
        // If array can be divided into
        // subarray of i equal length
        if (N % i == 0) {
 
            bool a = false;
            int n = brr.size();
            int j = i;
 
            // Check if on repeating the
            // current subarray gives the
            // original array or not
            while (j < N) {
                int K = j % i;
                if (arr[j] == brr[K]) {
                    j++;
                }
                else {
                    a = true;
                    break;
                }
            }
 
            // Subarray found
            if (!a && j == N) {
                printArray(brr);
                return;
            }
        }
 
        // Add current element into
        // subarray
        brr.push_back(arr[i]);
    }
 
    // No subarray found
    cout << "-1";
    return;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 2, 1, 2,
                  2, 1, 2, 2 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function call
    RepeatingSubarray(arr, N);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to print the array
static void printArray(Vector brr)
{
    for(int it : brr)
    {
        System.out.print(it + " ");
    }
}
 
// Function to find the smallest subarray
static void RepeatingSubarray(int arr[], int N)
{
     
    // Corner Case
    if (N < 2)
    {
        System.out.print("-1");
    }
 
    // Initialize the auxiliary subarray
    Vector brr = new Vector();
 
    // Push the first 2 elements into
    // the subarray brr[]
    brr.add(arr[0]);
    brr.add(arr[1]);
 
    // Iterate over the length of
    // subarray
    for(int i = 2; i < N / 2 + 1; i++)
    {
         
        // If array can be divided into
        // subarray of i equal length
        if (N % i == 0)
        {
            boolean a = false;
            int n = brr.size();
            int j = i;
 
            // Check if on repeating the
            // current subarray gives the
            // original array or not
            while (j < N)
            {
                int K = j % i;
                if (arr[j] == brr.get(K))
                {
                    j++;
                }
                else
                {
                    a = true;
                    break;
                }
            }
 
            // Subarray found
            if (!a && j == N)
            {
                printArray(brr);
                return;
            }
        }
 
        // Add current element into
        // subarray
        brr.add(arr[i]);
    }
 
    // No subarray found
    System.out.print("-1");
    return;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 2, 1, 2,
                  2, 1, 2, 2 };
 
    int N = arr.length;
 
    // Function call
    RepeatingSubarray(arr, N);
}
}
 
// This code is contributed by Amit Katiyar

Python3

# Python3 program for the above approach
 
# Function to print the array
def printArray(brr):
 
    for it in brr:
        print(it, end = ' ')
 
# Function to find the smallest subarray
def RepeatingSubarray(arr, N):
 
    # Corner Case
    if (N < 2):
        print("-1")
         
    # Initialize the auxiliary subarray
    brr = []
 
    # Push the first 2 elements into
    # the subarray brr[]
    brr.append(arr[0])
    brr.append(arr[1])
 
    # Iterate over the length of
    # subarray
    for i in range(2, N // 2 + 1):
 
        # If array can be divided into
        # subarray of i equal length
        if (N % i == 0):
            a = False
            n = len(brr)
            j = i
 
            # Check if on repeating the
            # current subarray gives the
            # original array or not
            while (j < N):
                K = j % i
                 
                if (arr[j] == brr[K]):
                    j += 1
                else:
                    a = True
                    break
 
            # Subarray found
            if (not a and j == N):
                printArray(brr)
                return
             
        # Add current element into
        # subarray
        brr.append(arr[i])
     
    # No subarray found
    print("-1")
    return
 
# Driver Code
if __name__ =="__main__":
 
    arr = [ 1, 2, 2, 1, 2,
            2, 1, 2, 2 ]
 
    N = len(arr)
 
    # Function call
    RepeatingSubarray(arr, N)
 
# This code is contributed by chitranayal

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to print the array
static void printArray(List brr)
{
    foreach(int it in brr)
    {
        Console.Write(it + " ");
    }
}
 
// Function to find the smallest subarray
static void RepeatingSubarray(int []arr, int N)
{   
    // Corner Case
    if (N < 2)
    {
        Console.Write("-1");
    }
 
    // Initialize the auxiliary subarray
    List brr = new List();
 
    // Push the first 2 elements into
    // the subarray brr[]
    brr.Add(arr[0]);
    brr.Add(arr[1]);
 
    // Iterate over the length of
    // subarray
    for(int i = 2; i < N / 2 + 1; i++)
    {       
        // If array can be divided into
        // subarray of i equal length
        if (N % i == 0)
        {
            bool a = false;
            int n = brr.Count;
            int j = i;
 
            // Check if on repeating the
            // current subarray gives the
            // original array or not
            while (j < N)
            {
                int K = j % i;
                if (arr[j] == brr[K])
                {
                    j++;
                }
                else
                {
                    a = true;
                    break;
                }
            }
 
            // Subarray found
            if (!a && j == N)
            {
                printArray(brr);
                return;
            }
        }
 
        // Add current element into
        // subarray
        brr.Add(arr[i]);
    }
 
    // No subarray found
    Console.Write("-1");
    return;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = {1, 2, 2, 1,
                 2, 2, 1, 2, 2};
 
    int N = arr.Length;
 
    // Function call
    RepeatingSubarray(arr, N);
}
}
 
// This code is contributed by 29AjayKumar

Javascript

// JavaScript program for the above approach
 
// Function to print the array
function printArray(brr)
{
    for (let it of brr) {
        document.write(it + ' ');
    }
}
 
// Function to find the smallest subarray
function RepeatingSubarray(arr, N)
{
    // Corner Case
    if (N < 2) {
        document.write("-1");
    }
 
    // Initialize the auxiliary subarray
    let brr = [];
 
    // Push the first 2 elements into
    // the subarray brr[]
    brr.push(arr[0]);
    brr.push(arr[1]);
 
    // Iterate over the length of
    // subarray
    for (let i = 2; i < Math.floor(N / 2) + 1; i++) {
 
        // If array can be divided into
        // subarray of i equal length
        if (N % i == 0) {
 
            let a = false;
            let n = brr.length;
            let j = i;
 
            // Check if on repeating the
            // current subarray gives the
            // original array or not
            while (j < N) {
                let K = j % i;
                if (arr[j] == brr[K]) {
                    j++;
                }
                else {
                    a = true;
                    break;
                }
            }
 
            // Subarray found
            if (!a && j == N) {
                printArray(brr);
                return;
            }
        }
 
        // Add current element into
        // subarray
        brr.push(arr[i]);
    }
 
    // No subarray found
    document.write("-1");
    return;
}
 
// Driver Code
    let arr = [ 1, 2, 2, 1, 2,
                2, 1, 2, 2 ];
 
    let N = arr.length;
 
    // Function call
    RepeatingSubarray(arr, N);
 
 
 
// This code is contributed by Surbhi Tyagi.

输出：

1 2 2

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

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