Kth largest node among all directly connected nodes to the given node in an undirected graph
Last Updated :
05 Aug, 2021
Given two arrays u and v, representing a graph such that there is an undirected edge from u[i] to v[i] (0 ? v[i], u[i] < N) and each node has some value val[i] (0 ? i < N). For each node, if the nodes connected directly to it are sorted in descending order according to their values (in case of equal values, sort it according to their indices in ascending order), print the number of the node at kth position. If total nodes are < k then print -1.
Examples:
Input: u[] = {0, 0, 1}, v[] = {2, 1, 2}, val[] = {2, 4, 3}, k = 2
Output:
2
0
0
For 0 node, the nodes directly connected to it are 1 and 2
having values 4 and 3 respectively, thus node with 2nd largest value is 2.
For 1 node, the nodes directly connected to it are 0 and 2
having values 2 and 3 respectively, thus node with 2nd largest value is 0.
For 2 node, the nodes directly connected to it are 0 and 1
having values 2 and 4 respectively, thus node with 2nd largest value is 0.
Input: u[] = {0, 2}, v[] = {2, 1}, val[] = {2, 4, 3}, k = 2
Output:
-1
-1
0
Approach: The idea is to store the nodes directly connected to a node along with their values in a vector and sort them in increasing order, and the kth largest value for a node, having n number of nodes directly connected to it, will be (n - k)th node from last.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
// Function to print Kth node for each node
void findKthNode(int u[], int v[], int n, int val[], int V, int k)
{
// Vector to store nodes directly
// connected to ith node along with
// their values
vector<pair<int, int> > g[V];
// Add edges to the vector along with
// the values of the node
for (int i = 0; i < n; i++) {
g[u[i]].push_back(make_pair(val[v[i]], v[i]));
g[v[i]].push_back(make_pair(val[u[i]], u[i]));
}
// Sort neighbors of every node
// and find the Kth node
for (int i = 0; i < V; i++) {
if (g[i].size() > 0)
sort(g[i].begin(), g[i].end());
// Get the kth node
if (k <= g[i].size())
printf("%d\n", g[i][g[i].size() - k].second);
// If total nodes are < k
else
printf("-1\n");
}
return;
}
// Driver code
int main()
{
int V = 3;
int val[] = { 2, 4, 3 };
int u[] = { 0, 0, 1 };
int v[] = { 2, 1, 2 };
int n = sizeof(u) / sizeof(int);
int k = 2;
findKthNode(u, v, n, val, V, k);
return 0;
}
// Java implementation of the approach
import java.util.*;
class GFG
{
// pair class
static class pair
{
int first,second;
pair(int a,int b)
{
first = a;
second = b;
}
}
// Function to print Kth node for each node
static void findKthNode(int u[], int v[], int n,
int val[], int V, int k)
{
// Vector to store nodes directly
// connected to ith node along with
// their values
Vector<Vector<pair >> g = new Vector<Vector<pair>>();
for(int i = 0; i < V; i++)
g.add(new Vector<pair>());
// Add edges to the Vector along with
// the values of the node
for (int i = 0; i < n; i++)
{
g.get(u[i]).add(new pair(val[v[i]], v[i]));
g.get(v[i]).add(new pair(val[u[i]], u[i]));
}
// Sort neighbors of every node
// and find the Kth node
for (int i = 0; i < V; i++)
{
if (g.get(i).size() > 0)
Collections.sort(g.get(i),new Comparator<pair>()
{
public int compare(pair p1, pair p2)
{
return p1.first - p2.first;
}
});
// Get the kth node
if (k <= g.get(i).size())
System.out.printf("%d\n", g.get(i).get(g.get(i).size() - k).second);
// If total nodes are < k
else
System.out.printf("-1\n");
}
return;
}
// Driver code
public static void main(String args[])
{
int V = 3;
int val[] = { 2, 4, 3 };
int u[] = { 0, 0, 1 };
int v[] = { 2, 1, 2 };
int n = u.length;
int k = 2;
findKthNode(u, v, n, val, V, k);
}
}
// This code is contributed by Arnab Kundu
# Python3 implementation of the approach
# Function to print Kth node for each node
def findKthNode(u, v, n, val, V, k):
# Vector to store nodes directly connected
# to ith node along with their values
g = [[] for i in range(V)]
# Add edges to the vector along
# with the values of the node
for i in range(0, n):
g[u[i]].append((val[v[i]], v[i]))
g[v[i]].append((val[u[i]], u[i]))
# Sort neighbors of every node
# and find the Kth node
for i in range(0, V):
if len(g[i]) > 0:
g[i].sort()
# Get the kth node
if k <= len(g[i]):
print(g[i][-k][1])
# If total nodes are < k
else:
print("-1")
return
# Driver code
if __name__ == "__main__":
V = 3
val = [2, 4, 3]
u = [0, 0, 1]
v = [2, 1, 2]
n, k = len(u), 2
findKthNode(u, v, n, val, V, k)
# This code is contributed by Rituraj Jain
// C# implementation of the approach
using System;
using System.Collections;
using System.Collections.Generic;
class GFG
{
// pair class
class pair
{
public int first,second;
public pair(int a,int b)
{
first = a;
second = b;
}
}
class sortHelper : IComparer
{
int IComparer.Compare(object a, object b)
{
pair first = (pair)a;
pair second = (pair)b;
return first.first - second.first;
}
}
// Function to print Kth node for each node
static void findKthNode(int []u, int []v, int n,
int []val, int V, int k)
{
// Vector to store nodes directly
// connected to ith node along with
// their values
ArrayList g = new ArrayList();
for(int i = 0; i < V; i++)
g.Add(new ArrayList());
// Add edges to the Vector along with
// the values of the node
for (int i = 0; i < n; i++)
{
((ArrayList)g[u[i]]).Add(new pair(val[v[i]], v[i]));
((ArrayList)g[v[i]]).Add(new pair(val[u[i]], u[i]));
}
// Sort neighbors of every node
// and find the Kth node
for (int i = 0; i < V; i++)
{
if (((ArrayList)g[i]).Count > 0)
{
ArrayList tmp = (ArrayList)g[i];
tmp.Sort(new sortHelper());
g[i] = tmp;
}
// Get the kth node
if (k <= ((ArrayList)g[i]).Count)
Console.Write(((pair)((ArrayList)g[i])[((ArrayList)g[i]).Count - k]).second+"\n");
// If total nodes are < k
else
Console.Write("-1\n");
}
return;
}
// Driver code
public static void Main(string []args)
{
int V = 3;
int []val = { 2, 4, 3 };
int []u = { 0, 0, 1 };
int []v = { 2, 1, 2 };
int n = u.Length;
int k = 2;
findKthNode(u, v, n, val, V, k);
}
}
// This code is contributed by Pratham76
<script>
// Javascript implementation of the approach
// Function to print Kth node for each node
function findKthNode(u, v, n, val, V, k)
{
// Vector to store nodes directly
// connected to ith node along with
// their values
var g = Array.from(Array(V), () => Array());
// Add edges to the vector along with
// the values of the node
for(var i = 0; i < n; i++)
{
g[u[i]].push([val[v[i]], v[i]]);
g[v[i]].push([val[u[i]], u[i]]);
}
// Sort neighbors of every node
// and find the Kth node
for(var i = 0; i < V; i++)
{
if (g[i].length > 0)
g[i].sort();
// Get the kth node
if (k <= g[i].length)
document.write(
g[i][g[i].length - k][1] + "<br>");
// If total nodes are < k
else
document.write("-1<br>");
}
return;
}
// Driver code
var V = 3;
var val = [ 2, 4, 3 ];
var u = [ 0, 0, 1 ];
var v = [ 2, 1, 2 ];
var n = u.length;
var k = 2;
findKthNode(u, v, n, val, V, k);
// This code is contributed by rutvik_56
</script>
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Largest subarray sum of all connected components in undirected graph Given an undirected graph with V vertices and E edges, the task is to find the maximum contiguous subarray sum among all the connected components of the graph. Examples: Input: E = 4, V = 7 Output: Maximum subarray sum among all connected components = 5 Explanation: Connected Components and maximum
14 min read
Minimum cost of path between given nodes containing at most K nodes in a directed and weighted graph Given a directed weighted graph represented by a 2-D array graph[][] of size n and 3 integers src, dst, and k representing the source point, destination point, and the available number of stops. The task is to minimize the cost of the path between two nodes containing at most K nodes in a directed a
10 min read
Size of the Largest Trees in a Forest formed by the given Graph Given an undirected acyclic graph having N nodes and M edges, the task is to find the size of the largest tree in the forest formed by the graph. A forest is a collection of disjoint trees. In other words, we can also say that forest is a collection of an acyclic graph which is not connected. Exampl
8 min read
Maximum product of a pair of nodes from largest connected component in a Graph Given an undirected weighted graph G consisting of N vertices and M edges, and two arrays Edges[][2] and Weight[] consisting of M edges of the graph and weights of each edge respectively, the task is to find the maximum product of any two vertices of the largest connected component of the graph, for
15+ min read
Maximize count of nodes disconnected from all other nodes in a Graph Given two integers N and E which denotes the number of nodes and the number of edges of an undirected graph, the task is to maximize the number of nodes which is not connected to any other node in the graph, without using any self-loops. Examples: Input: N = 5, E = 1 Output: 3 Explanation: Since the
4 min read