给定一个由不同元素组成的数组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)，因为我们为每个元素存储了所有可能的规则。