Count the nodes of a tree whose weighted string is an anagram of the given string
Last Updated :
11 Jun, 2021
Given a tree, and the weights (in the form of strings) of all the nodes, the task is to count the nodes whose weighted string is an anagram with the given string str.
Examples:
Input:
str = “geek”
Output: 2
Only the weighted strings of the nodes 2 and 6
are anagrams of the given string “geek”.
Approach: Perform dfs on the tree and for every node, check if it’s weighted string is anagram with the given string or not, If not then increment the count.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
string s;
int cnt = 0;
vector<int> graph[100];
vector<string> weight(100);
bool anagram(string x, string s)
{
sort(x.begin(), x.end());
sort(s.begin(), s.end());
if (x == s)
return true;
else
return false;
}
void dfs(int node, int parent)
{
if (anagram(weight[node], s))
cnt += 1;
for (int to : graph[node]) {
if (to == parent)
continue;
dfs(to, node);
}
}
int main()
{
s = "geek";
weight[1] = "eeggk";
weight[2] = "geek";
weight[3] = "gekrt";
weight[4] = "tree";
weight[5] = "eetr";
weight[6] = "egek";
graph[1].push_back(2);
graph[2].push_back(3);
graph[2].push_back(4);
graph[1].push_back(5);
graph[5].push_back(6);
dfs(1, 1);
cout << cnt;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static String s;
static int cnt = 0;
static Vector<Integer>[] graph = new Vector[100];
static String[] weight = new String[100];
static boolean anagram(String x, String s)
{
x = sort(x);
s = sort(s);
if (x.equals(s))
return true;
else
return false;
}
static String sort(String inputString)
{
char tempArray[] = inputString.toCharArray();
Arrays.sort(tempArray);
return new String(tempArray);
}
static void dfs(int node, int parent)
{
if (anagram(weight[node], s))
cnt += 1;
for (int to : graph[node])
{
if (to == parent)
continue;
dfs(to, node);
}
}
public static void main(String[] args)
{
s = "geek";
for (int i = 0; i < 100; i++)
graph[i] = new Vector<Integer>();
weight[1] = "eeggk";
weight[2] = "geek";
weight[3] = "gekrt";
weight[4] = "tree";
weight[5] = "eetr";
weight[6] = "egek";
graph[1].add(2);
graph[2].add(3);
graph[2].add(4);
graph[1].add(5);
graph[5].add(6);
dfs(1, 1);
System.out.print(cnt);
}
}
|
Python3
cnt = 0
graph = [[] for i in range(100)]
weight = [0] * 100
def anagram(x, s):
x = sorted(list(x))
s = sorted(list(s))
if (x == s):
return True
else:
return False
def dfs(node, parent):
global cnt, s
if (anagram(weight[node], s)):
cnt += 1
for to in graph[node]:
if (to == parent):
continue
dfs(to, node)
s = "geek"
weight[1] = "eeggk"
weight[2] = "geek"
weight[3] = "gekrt"
weight[4] = "tree"
weight[5] = "eetr"
weight[6] = "egek"
graph[1].append(2)
graph[2].append(3)
graph[2].append(4)
graph[1].append(5)
graph[5].append(6)
dfs(1, 1)
print(cnt)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static String s;
static int cnt = 0;
static List<int>[] graph = new List<int>[100];
static String[] weight = new String[100];
static bool anagram(String x, String s)
{
x = sort(x);
s = sort(s);
if (x.Equals(s))
return true;
else
return false;
}
static String sort(String inputString)
{
char []tempArray = inputString.ToCharArray();
Array.Sort(tempArray);
return new String(tempArray);
}
static void dfs(int node, int parent)
{
if (anagram(weight[node], s))
cnt += 1;
foreach (int to in graph[node])
{
if (to == parent)
continue;
dfs(to, node);
}
}
public static void Main(String[] args)
{
s = "geek";
for (int i = 0; i < 100; i++)
graph[i] = new List<int>();
weight[1] = "eeggk";
weight[2] = "geek";
weight[3] = "gekrt";
weight[4] = "tree";
weight[5] = "eetr";
weight[6] = "egek";
graph[1].Add(2);
graph[2].Add(3);
graph[2].Add(4);
graph[1].Add(5);
graph[5].Add(6);
dfs(1, 1);
Console.Write(cnt);
}
}
|
Javascript
<script>
let s;
let cnt = 0;
let graph = new Array(100);
let weight = new Array(100);
for(let i = 0; i < 100; i++)
{
graph[i] = [];
weight[i] = 0;
}
const sort1 = str => str.split('').sort((a, b) => a.localeCompare(b)).join('');
function anagram(x, s)
{
x = sort1(x);
s = sort1(s);
if (x == s)
return true;
else
return false;
}
function dfs(node, parent)
{
if (anagram(weight[node], s))
cnt += 1;
for(let to = 0; to < graph[node].length; to++)
{
if(graph[node][to] == parent)
continue
dfs(graph[node][to], node);
}
}
s = "geek";
weight[1] = "eeggk";
weight[2] = "geek";
weight[3] = "gekrt";
weight[4] = "tree";
weight[5] = "eetr";
weight[6] = "egek";
graph[1].push(2);
graph[2].push(3);
graph[2].push(4);
graph[1].push(5);
graph[5].push(6);
dfs(1, 1);
document.write(cnt);
</script>
|
Complexity Analysis:
- Time Complexity : O(N*(S*log(S))).
In dfs, every node of the tree is processed once and hence the complexity due to the dfs is O(N) if there are total N nodes in the tree. Also, for processing each node the sort() function is used which has a complexity of O(S*log(S)) where S is the length of the weighted string. Therefore, the time complexity is O(N*(S*log(S))) where S is the maximum length of the weight string in the tree.
- Auxiliary Space : O(1).
Any extra space is not required, so the space complexity is constant.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...