Check if every vertex triplet in graph contains two vertices connected to third vertex
Last Updated :
02 Jul, 2021
Given an undirected graph with N vertices and K edges, the task is to check if for every combination of three vertices in the graph, there exists two vertices which are connected to third vertex. In other words, for every vertex triplet (a, b, c), if there exists a path between a and c, then there should also exist a path between b and c.
Examples:
Input: N = 4, K = 3
Edges: 1 -> 2, 2 -> 3, 3 -> 4
Output: YES
Explanation:
Since the whole graph is connected, the above condition will always be valid.
Input: N = 5 and K = 3
Edges: 1 -> 3, 3 -> 4, 2 -> 5.
Output: NO
Explanation:
If we consider the triplet (1, 2, 3) then there is a path between vertices 1 and 3 but there is no path between vertices 2 and 3.
Approach: Follow the steps below to solve the problem -
- Traverse the graph by DFS Traversal technique from any component and maintain two variables to store the component minimum and component maximum.
- Store every component maximum and minimum in a vector.
- Now, if any two components have an intersection in their minimum and maximum values interval, then there will exist a valid (a < b < c) triplet. Hence, both of the components should be connected. Otherwise, the graph is not valid.
Below is the implementation of the above approach
C++
// C++ program of the
// above approach
#include <bits/stdc++.h>
using namespace std;
// Function to add edge into
// the graph
void addEdge(vector<int> adj[],
int u, int v)
{
adj[u].push_back(v);
adj[v].push_back(u);
}
void DFSUtil(int u, vector<int> adj[],
vector<bool>& visited,
int& componentMin,
int& componentMax)
{
visited[u] = true;
// Finding the maximum and
// minimum values in each component
componentMax = max(componentMax, u);
componentMin = min(componentMin, u);
for (int i = 0; i < adj[u].size(); i++)
if (visited[adj[u][i]] == false)
DFSUtil(adj[u][i], adj, visited,
componentMin, componentMax);
}
// Function for checking whether
// the given graph is valid or not
bool isValid(vector<pair<int, int> >& v)
{
int MAX = -1;
bool ans = 0;
// Checking for intersecting intervals
for (auto i : v) {
// If intersection is found
if (i.first <= MAX) {
// Graph is not valid
ans = 1;
}
MAX = max(MAX, i.second);
}
return (ans == 0 ? 1 : 0);
}
// Function for the DFS Traversal
void DFS(vector<int> adj[], int V)
{
std::vector<pair<int, int> > v;
// Traversing for every vertex
vector<bool> visited(V, false);
for (int u = 1; u <= V; u++) {
if (visited[u] == false) {
int componentMax = u;
int componentMin = u;
DFSUtil(u, adj, visited,
componentMin, componentMax);
// Storing maximum and minimum
// values of each component
v.push_back({ componentMin,
componentMax });
}
}
bool check = isValid(v);
if (check)
cout << "Yes";
else
cout << "No";
return;
}
// Driver code
int main()
{
int N = 4, K = 3;
vector<int> adj[N + 1];
addEdge(adj, 1, 2);
addEdge(adj, 2, 3);
addEdge(adj, 3, 4);
DFS(adj, N);
return 0;
}
// Java program of the
// above approach
import java.util.*;
import java.lang.*;
class GFG{
static class pair
{
int first, second;
pair(int first, int second)
{
this.first = first;
this.second = second;
}
}
// Function to add edge into
// the graph
static void addEdge(ArrayList<ArrayList<Integer>> adj,
int u, int v)
{
adj.get(u).add(v);
adj.get(v).add(u);
}
static void DFSUtil(int u,
ArrayList<ArrayList<Integer>> adj,
boolean[] visited,
int componentMin,
int componentMax)
{
visited[u] = true;
// Finding the maximum and
// minimum values in each component
componentMax = Math.max(componentMax, u);
componentMin = Math.min(componentMin, u);
for(int i = 0; i < adj.get(u).size(); i++)
if (visited[adj.get(u).get(i)] == false)
DFSUtil(adj.get(u).get(i), adj, visited,
componentMin, componentMax);
}
// Function for checking whether
// the given graph is valid or not
static boolean isValid(ArrayList<pair> v)
{
int MAX = -1;
boolean ans = false;
// Checking for intersecting intervals
for(pair i : v)
{
// If intersection is found
if (i.first <= MAX)
{
// Graph is not valid
ans = true;
}
MAX = Math.max(MAX, i.second);
}
return (ans == false ? true : false);
}
// Function for the DFS Traversal
static void DFS(ArrayList<ArrayList<Integer>> adj,
int V)
{
ArrayList<pair> v = new ArrayList<>();
// Traversing for every vertex
boolean[] visited = new boolean[V + 1];
for(int u = 1; u <= V; u++)
{
if (visited[u] == false)
{
int componentMax = u;
int componentMin = u;
DFSUtil(u, adj, visited,
componentMin,
componentMax);
// Storing maximum and minimum
// values of each component
v.add(new pair(componentMin,
componentMax));
}
}
boolean check = isValid(v);
if (check)
System.out.println("Yes");
else
System.out.println("No");
return;
}
// Driver code
public static void main (String[] args)
{
int N = 4, K = 3;
ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
for(int i = 0; i <= N + 1; i++)
adj.add(new ArrayList<>());
addEdge(adj, 1, 2);
addEdge(adj, 2, 3);
addEdge(adj, 3, 4);
DFS(adj, N);
}
}
// This code is contributed by offbeat
# Python3 program of the
# above approach
# Function to add edge into
# the graph
def addEdge(adj, u, v):
adj[u].append(v)
adj[v].append(u)
return adj
def DFSUtil(u, adj, visited,
componentMin, componentMax):
visited[u] = True
# Finding the maximum and
# minimum values in each component
componentMax = max(componentMax, u)
componentMin = min(componentMin, u)
for i in range(len(adj[u])):
if (visited[adj[u][i]] == False):
visited, componentMax, componentMin = DFSUtil(
adj[u][i], adj, visited, componentMin,
componentMax)
return visited, componentMax, componentMin
# Function for checking whether
# the given graph is valid or not
def isValid(v):
MAX = -1
ans = False
# Checking for intersecting intervals
for i in v:
if len(i) != 2:
continue
# If intersection is found
if (i[0] <= MAX):
# Graph is not valid
ans = True
MAX = max(MAX, i[1])
return (True if ans == False else False)
# Function for the DFS Traversal
def DFS(adj, V):
v = [[]]
# Traversing for every vertex
visited = [False for i in range(V + 1)]
for u in range(1, V + 1):
if (visited[u] == False):
componentMax = u
componentMin = u
visited, componentMax, componentMin = DFSUtil(
u, adj, visited, componentMin,
componentMax)
# Storing maximum and minimum
# values of each component
v.append([componentMin, componentMax])
check = isValid(v)
if (check):
print('Yes')
else:
print('No')
return
# Driver code
if __name__=="__main__":
N = 4
K = 3
adj = [[] for i in range(N + 1)]
adj = addEdge(adj, 1, 2)
adj = addEdge(adj, 2, 3)
adj = addEdge(adj, 3, 4)
DFS(adj, N)
# This code is contributed by rutvik_56
// C# program of the
// above approach
using System;
using System.Collections;
using System.Collections.Generic;
class GFG{
class pair
{
public int first, second;
public pair(int first, int second)
{
this.first = first;
this.second = second;
}
}
// Function to add edge into
// the graph
static void addEdge(ArrayList adj,
int u, int v)
{
((ArrayList)adj[u]).Add(v);
((ArrayList)adj[v]).Add(u);
}
static void DFSUtil(int u, ArrayList adj,
bool[] visited,
int componentMin,
int componentMax)
{
visited[u] = true;
// Finding the maximum and
// minimum values in each component
componentMax = Math.Max(componentMax, u);
componentMin = Math.Min(componentMin, u);
for(int i = 0; i < ((ArrayList)adj[u]).Count; i++)
if (visited[(int)((ArrayList)adj[u])[i]] == false)
DFSUtil((int)((ArrayList)adj[u])[i], adj, visited,
componentMin, componentMax);
}
// Function for checking whether
// the given graph is valid or not
static bool isValid(ArrayList v)
{
int MAX = -1;
bool ans = false;
// Checking for intersecting intervals
foreach(pair i in v)
{
// If intersection is found
if (i.first <= MAX)
{
// Graph is not valid
ans = true;
}
MAX = Math.Max(MAX, i.second);
}
return (ans == false ? true : false);
}
// Function for the DFS Traversal
static void DFS(ArrayList adj,
int V)
{
ArrayList v = new ArrayList();
// Traversing for every vertex
bool[] visited = new bool[V + 1];
for(int u = 1; u <= V; u++)
{
if (visited[u] == false)
{
int componentMax = u;
int componentMin = u;
DFSUtil(u, adj, visited,
componentMin,
componentMax);
// Storing maximum and minimum
// values of each component
v.Add(new pair(componentMin,
componentMax));
}
}
bool check = isValid(v);
if (check)
Console.WriteLine("Yes");
else
Console.WriteLine("No");
return;
}
// Driver code
public static void Main(string[] args)
{
int N = 4;
ArrayList adj = new ArrayList();
for(int i = 0; i <= N + 1; i++)
adj.Add(new ArrayList());
addEdge(adj, 1, 2);
addEdge(adj, 2, 3);
addEdge(adj, 3, 4);
DFS(adj, N);
}
}
// This code is contributed by pratham76
<script>
// JavaScript program of the
// above approach
class pair
{
constructor(first, second)
{
this.first = first;
this.second = second;
}
}
// Function to add edge into
// the graph
function addEdge(adj,u, v)
{
(adj[u]).push(v);
(adj[v]).push(u);
}
function DFSUtil(u, adj, visited, componentMin, componentMax)
{
visited[u] = true;
// Finding the maximum and
// minimum values in each component
componentMax = Math.max(componentMax, u);
componentMin = Math.min(componentMin, u);
for(var i = 0; i < (adj[u]).length; i++)
if (visited[(adj[u])[i]] == false)
DFSUtil((adj[u])[i], adj, visited,
componentMin, componentMax);
}
// Function for checking whether
// the given graph is valid or not
function isValid(v)
{
var MAX = -1;
var ans = false;
// Checking for intersecting intervals
for(var i of v)
{
// If intersection is found
if (i.first <= MAX)
{
// Graph is not valid
ans = true;
}
MAX = Math.max(MAX, i.second);
}
return (ans == false ? true : false);
}
// Function for the DFS Traversal
function DFS(adj, V)
{
var v = [];
// Traversing for every vertex
var visited = Array(V+1).fill(false);
for(var u = 1; u <= V; u++)
{
if (visited[u] == false)
{
var componentMax = u;
var componentMin = u;
DFSUtil(u, adj, visited,
componentMin,
componentMax);
// Storing maximum and minimum
// values of each component
v.push(new pair(componentMin,
componentMax));
}
}
var check = isValid(v);
if (check)
document.write("Yes");
else
document.write("No");
return;
}
// Driver code
var N = 4;
var adj = [];
for(var i = 0; i <= N + 1; i++)
adj.push(new Array());
addEdge(adj, 1, 2);
addEdge(adj, 2, 3);
addEdge(adj, 3, 4);
DFS(adj, N);
</script>
Time Complexity: O(N + E)
Auxiliary Space: O(N)
Similar Reads
Check if vertex X lies in subgraph of vertex Y for the given Graph Given an undirected graph and two vertices X and Y, our task is to check whether the vertex X lies in the subgraph of the vertex Y. Examples: Input: X = 2, Y = 3 Output: No Explanation: Subgraph of a vertex Y = 3 is set of all the vertex which lies below Y and are reachable by Y. Here subgraph of 3
10 min read
Check if incoming edges in a vertex of directed graph is equal to vertex itself or not Given a directed Graph G(V, E) with V vertices and E edges, the task is to check that for all vertices of the given graph, the incoming edges in a vertex is equal to the vertex itself or not. Examples: Input: Output: Yes Explanation: For vertex 0 there are 0 incoming edges, for vertex 1 there is 1 i
6 min read
Queries to check if vertices X and Y are in the same Connected Component of an Undirected Graph Given an undirected graph consisting of N vertices and M edges and queries Q[][] of the type {X, Y}, the task is to check if the vertices X and Y are in the same connected component of the Graph. Examples: Input: Q[][] = {{1, 5}, {3, 2}, {5, 2}} Graph: 1-3-4 2 | 5 Output: Yes No No Explanation: From
11 min read
Find if there is a path between two vertices in an undirected graph Given an undirected graph with N vertices and E edges and two vertices (U, V) from the graph, the task is to detect if a path exists between these two vertices. Print "Yes" if a path exists and "No" otherwise. Examples: U = 1, V = 2 Output: No Explanation: There is no edge between the two points and
15+ min read
Count of connected components in given graph after removal of given Q vertices Given an undirected graph g, the task is to find the number of coalitions formed in it after the removal of Q vertices and maximum vertices among all these connected components. A coalition is defined as the number of connected components left after removal of Q vertices i.e vertices being removed f
10 min read
Find K vertices in the graph which are connected to at least one of remaining vertices Given a connected graph with N vertices. The task is to select k(k must be less than or equals to n/2, not necessarily minimum) vertices from the graph such that all these selected vertices are connected to at least one of the non selected vertex. In case of multiple answers print any one of them. E
8 min read