0

I have a tree (non-binary, unbalanced, no cycles), all nodes have flags (green=active, red=inactive). I'm starting from the root node and I have to find a complete path (from root to leaf) where all nodes are active. (To find at least one path is fine.) As a result, I need the path, not just the info if there is any.

I was thinking of using a depth-first search, but I can't figure out how to include the filtering by active/inactive. Any ideas?

Tree with flags

Misa
  • 23
  • 4

3 Answers3

1

It's straightforward. As you know, DFS can be implemented by a stack. Such that we push the root of the tree into the stack, and afterward pop the top of the stack and push children of the popped node. We continue this process up to have an empty stack.

Now, for your case, just before pushing the nodes into the stack, you need to check whether the specified node (i.e., children of the popped node) is active or inactive. In that case, you will not search down when reaching an inactive node. Finally, only report all generated paths that their end node is a leaf (you can easily find the leaves during the search, a node that does not have any child).

OmG
  • 18,337
  • 10
  • 57
  • 90
1

Your DFS recursion will have two base cases:

  • A negative one: the current node is not green.
  • A positive one: the current node is a green leaf, i.e. it has no children.

In all other cases recursive call(s) have to be made on the node's children. As soon as a positive result comes back from the recursive call, that positive result can be extended with the current node and returned immediately, interrupting the loop.

There are several ways to implement a tree, so I made some choices in this JavaScript implementation:

function findGreenPath(tree, label) {
    let root = tree[label];
    if (!root.green) return null; // No path through none-green node
    if (root.children == "") return label; // It is a leaf, start a path
    for (let child of root.children) {
        let path = findGreenPath(tree, child);
        if (path != null) return label + path; // prepend this node to a good path
    }
    return null; // No path found
}

// Implementation of the example tree in the question:
let tree = { // Dictionary of nodes by their label
    "A": {green: true, children: "BC"},
    "B": {green: true, children: "DE"},
    "C": {green: true, children: "FG"},
    "D": {green: true, children: "HI"},
    "E": {green: false, children: ""},
    "F": {green: false, children: ""},
    "G": {green: true, children: "J"},
    "H": {green: false, children: ""},
    "I": {green: true, children: ""},
    "J": {green: true, children: "K"},
    "K": {green: false, children: ""}
};

let path = findGreenPath(tree, "A"); 

console.log(path); // ABDI
trincot
  • 317,000
  • 35
  • 244
  • 286
0

Suppose that

        A                              1
       / \                            / \
      B   C -- G                     2   3 -- 7
     / \   \    \        <=>        / \   \    \
    D   E   F    J                 4   5   6    10
   / \            \               / \            \
  H   I            K             8   9            11

Therefore, I can offer the solution of your problem, using the algorithm Depth first search.

/*
A - 1,
B - 2,
C - 3,
D - 4,
E - 5,
F - 6,
G - 7,
H - 8,
I - 9,
J - 10,
K - 11.
*/
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
const int maximumSize=20;
int vertices, edges;
vector<int> visited0(maximumSize, 0);
vector<int> visited1(maximumSize, 0);
vector<int> graph[maximumSize];
vector<int> distances(maximumSize, 0);
vector<string> graphPaths;
string path;
vector<int> green(maximumSize, 0);
template<class Type>
void showContent1D(Type& input)
{
    for(int i=0; i<input.size(); ++i)
    {
        cout<<input[i]<<", ";
    }
    return;
}
void showContentVectorString(vector<string>& input)
{
    for(int i=0; i<input.size(); ++i)
    {
        cout<<input[i]<<", ";
    }
    return;
}
void createGraph()
{
    cin>>vertices>>edges;
    int vertex0, vertex1;
    for(int i=1; i<=edges; ++i)
    {
        cin>>vertex0>>vertex1;
        graph[vertex0].push_back(vertex1);
        graph[vertex1].push_back(vertex0);
    }
    for(int i=1; i<=vertices; ++i)
    {
        cin>>green[i];
    }
    return;
}
void dfs0(int current, int previous)
{
    if(visited0[current]==1)
    {
        return;
    }
    visited0[current]=1;
    distances[current]=0;
    for(int next : graph[current])
    {
        if(next==previous)
        {
            continue;
        }
        dfs0(next, current);
        distances[current]=max(distances[current], distances[next]+1);
    }
    return;
}
void dfs1(int root, int current, int previous)
{
    if(visited1[current]==1)
    {
        return;
    }
    visited1[current]=1;
    if(green[current]==1)
    {
        if(distances[current]!=0)
        {
            path.append(to_string(current));
            path.append("->");
        }
        else
        {
            path.append(to_string(current));
            graphPaths.push_back(path);
            path.pop_back();
        }
    }
    for(int next : graph[current])
    {
        if(next==previous)
        {
            continue;
        }
        dfs1(root, next, current);
    }
    if(root==previous)
    {
        path.clear();
        path.append(to_string(root));
        path.append("->");
    }
    return;
}
void solve()
{
    createGraph();
    dfs0(1, 0);
    dfs1(1, 1, 0);
    cout<<"graphPaths: ";
    showContentVectorString(graphPaths);
    cout<<endl;
    return;
}
int main()
{
    solve();
    return 0;
}

Input:

11 10
1 2
1 3
2 4
2 5
4 8
4 9
3 6
3 7
7 10
10 11
1
1
1
1
0
0
1
0
1
1
0

Here is the result:

graphPaths: 1->2->4->9,

If you will need an explanation of the solution, write the corresponding comment.

Vadim Chernetsov
  • 370
  • 1
  • 2
  • 14