给定N个不同整数的数组arr []和不同整数的数组个pieces []的列表，任务是检查给定的数组列表是否可以以任何顺序连接起来以获得给定的数组。如果可能，请打印“是” 。否则，打印“否” 。
例子：
Input: arr[] = {1, 2, 4, 3}, pieces[][] = {{1}, {4, 3}, {2}}
Output: Yes
Explanation:
Rearrange the list to {{1}, {2}, {4, 3}}.
Now, concatenating the all the arrays from the list generates the sequence {1, 2, 4, 3} which is same as the given array.
Input: arr[] = {1, 2, 4, 3}, pieces = {{1}, {2}, {3, 4}}
Output: No
Explanation:
There is no possible permutation of given list such that after concatenating the generated sequence becomes equal to the given array.
天真的方法：最简单的方法是遍历给定的数组arr [] ，对于每个元素arr [i] ，检查列表中是否存在任何数组，使其从arr [i]开始。如果确定为true，则增加i，同时数组中存在的元素等于arr [i] 。如果它们不相等，则打印No。重复上述步骤，直到i
时间复杂度： O(N 2 )
辅助空间： O(N)
高效的方法：该想法是通过使用Map数据结构存储存在于给定数组arr []中的元素的索引来使用哈希的概念。请按照以下步骤解决问题：
- 创造 地图 存储给定数组arr []的元素的索引。
- 遍历列表中存在的每个数组，对于每个数组，请执行以下步骤：
- 在Map中找到数组arr []中其第一个元素的索引。
- 检查获取的数组是否是数组arr []的子数组，或者是否从之前找到的索引开始。
- 如果子数组与找到的数组不相等，则打印No。
- 否则，遍历给定数组后，输出Yes 。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Function to check if it is possible
// to obtain array by concatenating
// the arrays in list pieces[]
bool check(vector& arr,
vector>& pieces)
{
// Stores the index of element in
// the given array arr[]
unordered_map m;
for(int i = 0; i < arr.size(); i++)
m[arr[i]] = i + 1;
// Traverse over the list pieces
for(int i = 0; i < pieces.size(); i++)
{
// If item size is 1 and
// exists in map
if (pieces[i].size() == 1 &&
m[pieces[i][0]] != 0)
{
continue;
}
// If item contains > 1 element
// then check order of element
else if (pieces[i].size() > 1 &&
m[pieces[i][0]] != 0)
{
int idx = m[pieces[i][0]] - 1;
idx++;
// If end of the array
if (idx >= arr.size())
return false;
// Check the order of elements
for(int j = 1; j < pieces[i].size(); j++)
{
// If order is same as
// the array elements
if (arr[idx] == pieces[i][j])
{
// Increment idx
idx++;
// If order breaks
if (idx >= arr.size() &&
j < pieces[i].size() - 1)
return false;
}
// Otherwise
else
{
return false;
}
}
}
// Return false if the first
// element doesn't exist in m
else
{
return false;
}
}
// Return true
return true;
}
// Driver Code
int main()
{
// Given target list
vector arr = { 1, 2, 4, 3 };
// Given array of list
vector > pieces{ { 1 }, { 4, 3 }, { 2 } };
// Function call
if (check(arr, pieces))
{
cout << "Yes";
}
else
{
cout << "No";
}
return 0;
}
// This code is contributed by akhilsaini Java
// Java program for the above approach
import java.util.*;
class GFG {
// Function to check if it is possible
// to obtain array by concatenating
// the arrays in list pieces[]
static boolean check(
List arr,
ArrayList > pieces)
{
// Stores the index of element in
// the given array arr[]
Map m
= new HashMap<>();
for (int i = 0; i < arr.size(); i++)
m.put(arr.get(i), i);
// Traverse over the list pieces
for (int i = 0;
i < pieces.size(); i++) {
// If item size is 1 and
// exists in map
if (pieces.get(i).size() == 1
&& m.containsKey(
pieces.get(i).get(0))) {
continue;
}
// If item contains > 1 element
// then check order of element
else if (pieces.get(i).size() > 1
&& m.containsKey(
pieces.get(i).get(0))) {
int idx = m.get(
pieces.get(i).get(0));
idx++;
// If end of the array
if (idx >= arr.size())
return false;
// Check the order of elements
for (int j = 1;
j < pieces.get(i).size();
j++) {
// If order is same as
// the array elements
if (arr.get(idx).equals(
pieces.get(i).get(j))) {
// Increment idx
idx++;
// If order breaks
if (idx >= arr.size()
&& j < pieces.get(i).size() - 1)
return false;
}
// Otherwise
else {
return false;
}
}
}
// Return false if the first
// element doesn't exist in m
else {
return false;
}
}
// Return true
return true;
}
// Driver Code
public static void main(String[] args)
{
// Given target list
List arr
= Arrays.asList(1, 2, 4, 3);
ArrayList > pieces
= new ArrayList<>();
// Given array of list
pieces.add(Arrays.asList(1));
pieces.add(Arrays.asList(4, 3));
pieces.add(Arrays.asList(2));
// Function Call
if (check(arr, pieces)) {
System.out.println("Yes");
}
else {
System.out.println("No");
}
}
} Python3
# Python3 program for the above approach
from array import *
# Function to check if it is possible
# to obtain array by concatenating
# the arrays in list pieces[]
def check(arr, pieces):
# Stores the index of element in
# the given array arr[]
m = {}
for i in range(0, len(arr)):
m[arr[i]] = i + 1
# Traverse over the list pieces
for i in range(0, len(pieces)):
# If item size is 1 and
# exists in map
if (len(pieces[i]) == 1 and
m[pieces[i][0]] != 0):
continue
# If item contains > 1 element
# then check order of element
elif (len(pieces[i]) > 1 and
m[pieces[i][0]] != 0):
idx = m[pieces[i][0]] - 1
idx = idx+1
# If end of the array
if idx >= len(arr):
return False
# Check the order of elements
for j in range(1, len(pieces[i])):
# If order is same as
# the array elements
if arr[idx] == pieces[i][j]:
# Increment idx
idx = idx+1
# If order breaks
if (idx >= len(arr) and
j < len(pieces[i]) - 1):
return False
# Otherwise
else:
return False
# Return false if the first
# element doesn't exist in m
else:
return False
# Return true
return True
# Driver Code
if __name__ == "__main__":
arr = [ 1, 2, 4, 3 ]
# Given array of list
pieces = [ [ 1 ], [ 4, 3 ], [ 2 ] ]
# Function call
if check(arr, pieces) == True:
print("Yes")
else:
print("No")
# This code is contributed by akhilsainiC#
// C# program for the above approach
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
class GFG{
// Function to check if it is possible
// to obtain array by concatenating
// the arrays in list pieces[]
static bool check(List arr,
List> pieces)
{
// Stores the index of element in
// the given array arr[]
Dictionary m = new Dictionary();
for(int i = 0; i < arr.Count; i++)
m.Add(arr[i], i);
// Traverse over the list pieces
for(int i = 0; i < pieces.Count; i++)
{
// If item size is 1 and
// exists in map
if (pieces[i].Count == 1 &&
m.ContainsKey(pieces[i][0]))
{
continue;
}
// If item contains > 1 element
// then check order of element
else if (pieces[i].Count > 1 &&
m.ContainsKey(pieces[i][0]))
{
int idx = m[pieces[i][0]];
idx++;
// If end of the array
if (idx >= arr.Count)
return false;
// Check the order of elements
for(int j = 1; j < pieces[i].Count; j++)
{
// If order is same as
// the array elements
if (arr[idx] == pieces[i][j])
{
// Increment idx
idx++;
// If order breaks
if (idx >= arr.Count &&
j < pieces[i].Count - 1)
return false;
}
// Otherwise
else
{
return false;
}
}
}
// Return false if the first
// element doesn't exist in m
else
{
return false;
}
}
// Return true
return true;
}
// Driver Code
static public void Main()
{
// Given target list
List arr = new List(){ 1, 2, 4, 3 };
List > pieces = new List >();
// Given array of list
pieces.Add(new List(){ 1 });
pieces.Add(new List(){ 4, 3 });
pieces.Add(new List(){ 2 });
// Function call
if (check(arr, pieces))
{
Console.WriteLine("Yes");
}
else
{
Console.WriteLine("No");
}
}
}
// This code is contributed by akhilsaini 输出：
Yes
时间复杂度： O(N * log N)，其中N是给定数组的长度。
辅助空间： O(N)