📜  检查路径是否存在于存在K个顶点的树中,或者最多在距离D处

📅  最后修改于: 2021-06-26 13:17:22             🧑  作者: Mango

给定一棵树,其中N个顶点的编号为[0,n – 1]K个顶点,并且距离为D ,任务是查找是否存在从根到某个顶点的路径,使得K个顶点中的每一个都属于该路径或距离路径最多D。

例子:

Input: 
             0
           /   \
         /       \
       1           2
     /   \        /  \
   /       \     /     \
  3         4   5        8
               /  \        
              /     \
             6       7
                    /
                   /
                  9
K = {6, 7, 8, 5}, D = 1
Output: YES
Explanation: 
The path ( 0 - 2 - 5 - 7 )
satisfies the condition. Vertices 5 
and 7 are a part of the path. 
Vertex 6 is the child of vertex 
5 and 8 is the child of 2. 

Input:
             0
           /   \
         /       \
       1           2
     /   \        /  \
   /       \     /     \
  3         4   5        8
   \           /  \        
    \         /     \
     10      6       7
                    /
                   /
                  9
K = {10, 9, 8, 5}, D = 2
Output: NO
Explanation: 
No such path exists that satisfies the condition.

方法:

  • 对于每个顶点,存储它们各自的父对象和深度。
  • 从给定的K个顶点中选择最深的顶点
  • 继续用其父D倍替换除根和最深顶点以外的K个顶点
  • 如果当前的K个顶点集可以形成连续路径,则答案为或“否”

下面的代码是上述方法的实现:

C++
// C++ implementation of above approach
 
#include 
using namespace std;
 
// Class to represent the Tree
class Tree {
 
    int T;
 
    // Stores the timing of traversals
    vector parent;
 
    // Stores the parent of each vertex
    vector depth;
 
    // Stores the depth of each vertex
    vector tin;
 
    // Stores the time to reach
    // every vertex
    vector tout;
 
    // Stores the time of leaving
    // every vertex after DFS calls
    // from its children
    vector > edges;
 
    // Store the edges
 
public:
    // Constructor
    Tree(int n)
    {
        T = 0;
        parent = depth = vector(n);
        tin = tout = vector(n);
        edges = vector >(n);
    }
 
    // Adding edges
    void addEdge(int u, int v)
    {
        edges[u].push_back(v);
        edges[v].push_back(u);
    }
 
    void dfs(int v, int p = -1, int d = 0)
    {
        // Store the time to reach vertex v
        tin[v] = T++;
 
        // Store the parent of vertex v
        parent[v] = p;
 
        // Store the depth of vertex v
        depth[v] = d;
 
        // Run DFS for all its children of v
        for (auto i : edges[v]) {
            if (i == p)
                continue;
 
            dfs(i, v, d + 1);
        }
 
        // Store the leaving time
        // of vertex v
        tout[v] = T++;
    }
 
    // Checks and returns whether vertex
    // v is parent of vertex u or not
    bool checkTiming(int v, int u)
    {
        if (tin[v] <= tin[u]
            && tout[u] <= tout[v])
            return true;
 
        return false;
    }
 
    // Checks and returns if the path exists
    void pathExistence(vector k, int d)
    {
        int deepest_vertex = k[0];
 
        // Find the deepest vertex among the
        // given K vertices
        for (int i = 0; i < k.size(); i++) {
            if (depth[k[i]] > depth[deepest_vertex])
                deepest_vertex = k[i];
        }
 
        // Replace each of the K vertices
        // except for the root and the
        // deepest vertex
        for (int i = 0; i < k.size(); i++) {
            if (k[i] == deepest_vertex)
                continue;
 
            int count = d;
 
            while (count > 0) {
 
                // Stop when root
                // has been reached
                if (parent[k[i]] == -1)
                    break;
 
                k[i] = parent[k[i]];
                count--;
            }
        }
 
        bool ans = true;
 
        // Check if each of the K-1 vertices
        // are a parent of the deepest vertex
        for (auto i : k)
            ans &= checkTiming(i, deepest_vertex);
 
        if (ans)
            cout << "Yes" << endl;
        else
            cout << "No" << endl;
    }
};
 
// Driver Code
int main()
{
    Tree t(11);
 
    t.addEdge(0, 1);
    t.addEdge(0, 2);
    t.addEdge(1, 3);
    t.addEdge(1, 4);
    t.addEdge(2, 5);
    t.addEdge(2, 8);
    t.addEdge(5, 6);
    t.addEdge(4, 10);
    t.addEdge(3, 7);
    t.addEdge(3, 9);
 
    t.dfs(0);
 
    vector k = { 2, 6, 8, 5 };
 
    int d = 2;
 
    t.pathExistence(k, d);
 
    return 0;
}


Java
// Java implementation of above approach
import java.util.*;
import java.lang.*;
 
class GFG{
     
static int T;
 
// Stores the timing of traversals
static int[] parent;
 
// Stores the parent of each vertex
static int[] depth;
 
// Stores the depth of each vertex
static int[] tin;
 
// Stores the time to reach
// every vertex
static int[] tout;
 
// Stores the time of leaving
// every vertex after DFS calls
// from its children
static ArrayList> edges;
 
// Adding edges
static void addEdge(int u, int v)
{
    edges.get(u).add(v);
    edges.get(v).add(u);
}
 
static void dfs(int v, int p, int d)
{
     
    // Store the time to reach vertex v
    tin[v] = T++;
     
    // Store the parent of vertex v
    parent[v] = p;
     
    // Store the depth of vertex v
    depth[v] = d;
     
    // Run DFS for all its children of v
    for(Integer i : edges.get(v))
    {
        if (i == p)
            continue;
         
        dfs(i, v, d + 1);
    }
     
    // Store the leaving time
    // of vertex v
    tout[v] = T++;
}
 
// Checks and returns whether vertex
// v is parent of vertex u or not
static boolean checkTiming(int v, int u)
{
    if (tin[v] <= tin[u] &&
       tout[u] <= tout[v])
        return true;
     
    return false;
}
 
// Checks and returns if the path exists
static void pathExistence(int[] k, int d)
{
    int deepest_vertex = k[0];
     
    // Find the deepest vertex among the
    // given K vertices
    for(int i = 0; i < k.length; i++)
    {
        if (depth[k[i]] > depth[deepest_vertex])
            deepest_vertex = k[i];
    }
     
    // Replace each of the K vertices
    // except for the root and the
    // deepest vertex
    for(int i = 0; i < k.length; i++)
    {
        if (k[i] == deepest_vertex)
            continue;
         
        int count = d;
         
        while (count > 0)
        {
             
            // Stop when root
            // has been reached
            if (parent[k[i]] == -1)
                break;
             
            k[i] = parent[k[i]];
            count--;
        }
    }
     
    boolean ans = true;
     
    // Check if each of the K-1 vertices
    // are a parent of the deepest vertex
    for(int i : k)
        ans &= checkTiming(i, deepest_vertex);
     
    if (ans)
        System.out.println("Yes");
    else
        System.out.println("No");
}
 
// Driver code
public static void main(String[] args)
{
    int n = 11;
    T = 0;
     
    parent = new int[n];
    depth = new int[n];
    tin = new int[n];
    tout = new int[n];
    edges = new ArrayList<>();
     
    for(int i = 0; i < n; i++)
        edges.add(new ArrayList<>());
     
    addEdge(0, 1);
    addEdge(0, 2);
    addEdge(1, 3);
    addEdge(1, 4);
    addEdge(2, 5);
    addEdge(2, 8);
    addEdge(5, 6);
    addEdge(4, 10);
    addEdge(3, 7);
    addEdge(3, 9);
     
    dfs(0, -1, 0);
     
    int[] k = { 2, 6, 8, 5 };
     
    int d = 2;
     
    pathExistence(k, d);
}
}
 
// This code is contributed by offbeat


输出:
Yes



如果您希望与行业专家一起参加现场课程,请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。