📌  相关文章
📜  检查给定的数组是否可以从给定的子序列集唯一构造

📅  最后修改于: 2021-10-25 03:10:23             🧑  作者: Mango

给定一个由不同元素组成的数组arr和该数组的子序列seqs列表,任务是检查给定的数组是否可以从给定的子序列集唯一构造。
例子:

方法:
为了解决这个问题,我们需要找到所有数组元素的拓扑排序,并检查是否只有一个元素的拓扑排序存在,这可以通过在寻找拓扑时每一时刻只存在一个源来确认元素的排序。
下面是上述方法的实现:

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),因为我们为每个元素存储了所有可能的规则。