给定不同的元件的阵列ARR和阵列的子序列seqs的列表，所述任务是检查是否与给定阵列可从给定的一组子序列被唯一构成。
例子：
Input : arr[] = {1, 2, 3, 4}, seqs[][] = {{1, 2}, {2, 3}, {3, 4}}
Output: Yes
Explanations: The sequences [1, 2], [2, 3], and [3, 4] can uniquely reconstruct
the original array {1, 2, 3, 4}.
Input: arr[] = {1, 2, 3, 4}, seqs[][] = {{1, 2}, {2, 3}, {2, 4}}
Output: No
Explanations : The sequences [1, 2], [2, 3], and [2, 4] cannot uniquely reconstruct
{1, 2, 3, 4}. There are two possible sequences that can be constructed from the given sequences:
1) {1, 2, 3, 4}
2) {1, 2, 4, 3}
方法：
为了解决此问题，我们需要找到所有数组元素的拓扑顺序，并检查是否仅存在一个元素的拓扑顺序，这可以通过在查找拓扑时的每个瞬间仅存在一个源来确认元素的排序。
下面是上述方法的实现：
C++
// C++ program to Check if
// the given array can be constructed
// uniquely from the given set of subsequences
#include
using namespace std;
bool canConstruct(vector originalSeq,
vector > sequences)
{
vector sortedOrder;
if (originalSeq.size() <= 0) {
return false;
}
// Count of incoming edges for every vertex
unordered_map inDegree;
// Adjacency list graph
unordered_map > graph;
for (auto seq : sequences) {
for (int i = 0; i < seq.size(); i++) {
inDegree[seq[i]] = 0;
graph[seq[i]] = vector();
}
}
// Build the graph
for (auto seq : sequences) {
for (int i = 1; i < seq.size(); i++) {
int parent = seq[i - 1], child = seq[i];
graph[parent].push_back(child);
inDegree[child]++;
}
}
// if ordering rules for all the numbers
// are not present
if (inDegree.size() != originalSeq.size()) {
return false;
}
// Find all sources i.e., all vertices
// with 0 in-degrees
queue sources;
for (auto entry : inDegree) {
if (entry.second == 0) {
sources.push(entry.first);
}
}
// For each source, add it to the sortedOrder
// and subtract one from all of in-degrees
// if a child's in-degree becomes zero
// add it to the sources queue
while (!sources.empty()) {
// If there are more than one source
if (sources.size() > 1) {
// Multiple sequences exist
return false;
}
// If the next source is different from the origin
if (originalSeq[sortedOrder.size()] !=
sources.front()) {
return false;
}
int vertex = sources.front();
sources.pop();
sortedOrder.push_back(vertex);
vector children = graph[vertex];
for (auto child : children) {
// Decrement the node's in-degree
inDegree[child]--;
if (inDegree[child] == 0) {
sources.push(child);
}
}
}
// Compare the sizes of sortedOrder
// and the original sequence
return sortedOrder.size() == originalSeq.size();
}
int main(int argc, char* argv[])
{
vector arr = { 1, 2, 6, 7, 3, 5, 4 };
vector > seqs = { { 1, 2, 3 },
{ 7, 3, 5 },
{ 1, 6, 3, 4 },
{ 2, 6, 5, 4 } };
bool result = canConstruct(arr, seqs);
if (result)
cout << "Yes" << endl;
else
cout << "No" << endl;
} Java
// Java program to Check if
// the given array can be constructed
// uniquely from the given set of subsequences
import java.io.*;
import java.util.*;
class GFG {
static boolean canConstruct(int[] originalSeq,
int[][] sequences)
{
List sortedOrder
= new ArrayList();
if (originalSeq.length <= 0) {
return false;
}
// Count of incoming edges for every vertex
Map inDegree
= new HashMap();
// Adjacency list graph
Map > graph
= new HashMap >();
for (int[] seq : sequences)
{
for (int i = 0; i < seq.length; i++)
{
inDegree.put(seq[i], 0);
graph.put(seq[i], new ArrayList());
}
}
// Build the graph
for (int[] seq : sequences)
{
for (int i = 1; i < seq.length; i++)
{
int parent = seq[i - 1], child = seq[i];
graph.get(parent).add(child);
inDegree.put(child,
inDegree.get(child) + 1);
}
}
// if ordering rules for all the numbers
// are not present
if (inDegree.size() != originalSeq.length)
{
return false;
}
// Find all sources i.e., all vertices
// with 0 in-degrees
List sources = new ArrayList();
for (Map.Entry entry :
inDegree.entrySet())
{
if (entry.getValue() == 0)
{
sources.add(entry.getKey());
}
}
// For each source, add it to the sortedOrder
// and subtract one from all of in-degrees
// if a child's in-degree becomes zero
// add it to the sources queue
while (!sources.isEmpty())
{
// If there are more than one source
if (sources.size() > 1)
{
// Multiple sequences exist
return false;
}
// If the next source is different from the
// origin
if (originalSeq[sortedOrder.size()]
!= sources.get(0))
{
return false;
}
int vertex = sources.get(0);
sources.remove(0);
sortedOrder.add(vertex);
List children = graph.get(vertex);
for (int child : children)
{
// Decrement the node's in-degree
inDegree.put(child,
inDegree.get(child) - 1);
if (inDegree.get(child) == 0)
{
sources.add(child);
}
}
}
// Compare the sizes of sortedOrder
// and the original sequence
return sortedOrder.size() == originalSeq.length;
}
// Driver code
public static void main(String[] args)
{
int[] arr = { 1, 2, 6, 7, 3, 5, 4 };
int[][] seqs = { { 1, 2, 3 },
{ 7, 3, 5 },
{ 1, 6, 3, 4 },
{ 2, 6, 5, 4 } };
boolean result = canConstruct(arr, seqs);
if (result)
System.out.println("Yes");
else
System.out.println("No");
}
}
// This code is contributed by jitin Python3
# Python 3 program to Check if
# the given array can be constructed
# uniquely from the given set of subsequences
def canConstruct(originalSeq, sequences):
sortedOrder = []
if (len(originalSeq) <= 0):
return False
# Count of incoming edges for every vertex
inDegree = {i : 0 for i in range(100)}
# Adjacency list graph
graph = {i : [] for i in range(100)}
for seq in sequences:
for i in range(len(seq)):
inDegree[seq[i]] = 0
graph[seq[i]] = []
# Build the graph
for seq in sequences:
for i in range(1, len(seq)):
parent = seq[i - 1]
child = seq[i]
graph[parent].append(child)
inDegree[child] += 1
# If ordering rules for all the numbers
# are not present
if (len(inDegree) != len(originalSeq)):
return False
# Find all sources i.e., all vertices
# with 0 in-degrees
sources = []
for entry in inDegree:
if (entry[1] == 0):
sources.append(entry[0])
# For each source, add it to the sortedOrder
# and subtract one from all of in-degrees
# if a child's in-degree becomes zero
# add it to the sources queue
while (len(sources) > 0):
# If there are more than one source
if (len(sources) > 1):
# Multiple sequences exist
return False
# If the next source is different from the origin
if (originalSeq[len(sortedOrder)] != sources[0]):
return False
vertex = sources[0]
sources.remove(sources[0])
sortedOrder.append(vertex)
children = graph[vertex]
for child in children:
# Decrement the node's in-degree
inDegree[child] -= 1
if (inDegree[child] == 0):
sources.append(child)
# Compare the sizes of sortedOrder
# and the original sequence
return len(sortedOrder) == len(originalSeq)
if __name__ == '__main__':
arr = [ 1, 2, 6, 7, 3, 5, 4 ]
seqs = [[ 1, 2, 3 ],
[ 7, 3, 5 ],
[ 1, 6, 3, 4 ],
[ 2, 6, 5, 4 ]]
result = canConstruct(arr, seqs)
if (result):
print("Yes")
else:
print("No")
# This code is contributed by Bhupendra_Singh输出：
No时间复杂度：
上述算法的时间复杂度为O(N + E)，其中“ N”是元素数，“ E”是规则总数。由于最多每个数字对可以给我们一个规则，因此我们可以得出结论，规则的上限为O(M)，其中“ M”是所有序列中的数字计数。因此，可以说我们算法的时间复杂度为O(N + M)。
辅助空间： O(N + M)，因为我们存储每个元素的所有可能规则。