# Minimum degree of three nodes forming a triangle in a given Graph

• Last Updated : 28 May, 2021

Given an undirected graph consisting of N vertices and M edges and an array edges[][], with each row representing two vertices connected by an edge, the task is to find the minimum degree of three nodes forming a triangle in the graph. If there doesn’t exist any triangle in the graph, then print “-1”.

Examples:

Input: N = 7, Edges = [[1, 2], [1, 3], [2, 3], [1, 4], [2, 5], [2, 7], [3, 6], [3, 7]]
Output: 4
Explanation: Below is the representation of the above graph:

There are two connected triangles:

1. One formed by nodes {1, 2, 3}. Degree of the triangle = 5.
2. Second triangle formed by nodes {2, 3, 7}. Degree of the triangle = 4.

The minimum degree is 4.

Input: N = 6, Edges = [[1, 2], [1, 3], [2, 3], [1, 6], [3, 4], [4, 5]]
Output: 2

Approach: The given problem can be solved by finding the degree of every triplet of nodes forming a triangle and count the degree of each node in that triangle. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the minimum degree` `// of a connected triangle in the graph` `int` `minTrioDegree(``int` `N,` `                  ``vector >& Edges)` `{` `    ``// Store the degree of each node` `    ``// in the graph` `    ``int` `degree[N + 1] = { 0 };`   `    ``// Stores the representation of` `    ``// graph in an adjancency matrix` `    ``int` `adj[N + 1][N + 1] = { 0 };`   `    ``// Create the adjacency matrix and` `    ``// count the degree of nodes` `    ``for` `(``int` `i = 0; i < Edges.size(); i++) {`   `        ``// u & v are the endpoint of` `        ``// the ith edge` `        ``int` `u = Edges[i][0];` `        ``int` `v = Edges[i][1];`   `        ``// Mark both edges i.e.,` `        ``// edge u->v and v->u` `        ``adj[u][v] = adj[u][v] = 1;`   `        ``// Increment degree by 1` `        ``// of both endnodes` `        ``degree[u]++;` `        ``degree[v]++;` `    ``}`   `    ``// Stores the required result` `    ``int` `ans = INT_MAX;`   `    ``// Traverse for the first node` `    ``for` `(``int` `i = 1; i <= N; i++) {`   `        ``// Traverse for the second node` `        ``for` `(``int` `j = i + 1; j <= N; j++) {`   `            ``// If there is an edge between` `            ``// these two nodes` `            ``if` `(adj[i][j] == 1) {`   `                ``// Traverse all possible` `                ``// third nodes` `                ``for` `(``int` `k = j + 1;` `                     ``k <= N; k++) {`   `                    ``// If there is an edge` `                    ``// between third node` `                    ``// and the previous two` `                    ``if` `(adj[i][k] == 1` `                        ``&& adj[j][k] == 1) {`   `                        ``// Update ans` `                        ``ans = min(ans,` `                                  ``degree[i]` `                                      ``+ degree[j]` `                                      ``+ degree[k] - 6);` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Return the result` `    ``return` `ans == INT_MAX ? -1 : ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``vector > Edges;` `    ``Edges = { { 1, 2 }, { 1, 3 }, ` `              ``{ 2, 3 }, { 1, 4 }, ` `              ``{ 2, 5 }, { 2, 7 }, ` `              ``{ 3, 6 }, { 3, 7 } };` `    ``int` `N = 7;`   `    ``cout << minTrioDegree(N, Edges);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to find the minimum degree` `// of a connected triangle in the graph` `static` `int` `minTrioDegree(``int` `N,``int` `[][]Edges)` `{` `    ``// Store the degree of each node` `    ``// in the graph` `    ``int` `degree[] = ``new` `int``[N + ``1``];`   `    ``// Stores the representation of` `    ``// graph in an adjancency matrix` `    ``int` `adj[][] = ``new` `int``[N + ``1``][N + ``1``];`   `    ``// Create the adjacency matrix and` `    ``// count the degree of nodes` `    ``for` `(``int` `i = ``0``; i < Edges.length; i++) {`   `        ``// u & v are the endpoint of` `        ``// the ith edge` `        ``int` `u = Edges[i][``0``];` `        ``int` `v = Edges[i][``1``];`   `        ``// Mark both edges i.e.,` `        ``// edge u.v and v.u` `        ``adj[u][v] = adj[u][v] = ``1``;`   `        ``// Increment degree by 1` `        ``// of both endnodes` `        ``degree[u]++;` `        ``degree[v]++;` `    ``}`   `    ``// Stores the required result` `    ``int` `ans = Integer.MAX_VALUE;`   `    ``// Traverse for the first node` `    ``for` `(``int` `i = ``1``; i <= N; i++) {`   `        ``// Traverse for the second node` `        ``for` `(``int` `j = i + ``1``; j <= N; j++) {`   `            ``// If there is an edge between` `            ``// these two nodes` `            ``if` `(adj[i][j] == ``1``) {`   `                ``// Traverse all possible` `                ``// third nodes` `                ``for` `(``int` `k = j + ``1``;` `                     ``k <= N; k++) {`   `                    ``// If there is an edge` `                    ``// between third node` `                    ``// and the previous two` `                    ``if` `(adj[i][k] == ``1` `                        ``&& adj[j][k] == ``1``) {`   `                        ``// Update ans` `                        ``ans = Math.min(ans,` `                                  ``degree[i]` `                                      ``+ degree[j]` `                                      ``+ degree[k] - ``6``);` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Return the result` `    ``return` `ans == Integer.MAX_VALUE ? -``1` `: ans;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `[][]Edges = { { ``1``, ``2` `}, { ``1``, ``3` `}, ` `              ``{ ``2``, ``3` `}, { ``1``, ``4` `}, ` `              ``{ ``2``, ``5` `}, { ``2``, ``7` `}, ` `              ``{ ``3``, ``6` `}, { ``3``, ``7` `} };` `    ``int` `N = ``7``;`   `    ``System.out.print(minTrioDegree(N, Edges));`   `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach` `import` `sys`   `# Function to find the minimum degree` `# of a connected triangle in the graph` `def` `minTrioDegree(N, Edges):`   `    ``# Store the degree of each node` `    ``# in the graph` `    ``degree ``=` `[``0``] ``*` `(N``+``1``)`   `    ``# Stores the representation of` `    ``# graph in an adjancency matrix` `    ``adj ``=` `[]`   `    ``for` `i ``in` `range``(``0``, N``+``1``):` `        ``temp ``=` `[]` `        ``for` `j ``in` `range``(``0``, N``+``1``):` `            ``temp.append(``0``)`   `        ``adj.append(temp)`   `    ``# Create the adjacency matrix and` `    ``# count the degree of nodes` `    ``for` `i ``in` `range``(``len``(Edges)):`   `        ``# u & v are the endpoint of` `        ``# the ith edge` `        ``u ``=` `Edges[i][``0``]` `        ``v ``=` `Edges[i][``1``]` `        `  `        ``# Mark both edges i.e.,` `        ``# edge u->v and v->u` `        ``adj[u][v] ``=` `adj[u][v] ``=` `1`   `        ``# Increment degree by 1` `        ``# of both endnodes` `        ``degree[u] ``+``=` `1` `        ``degree[v] ``+``=` `1`   `    ``# Stores the required result` `    ``ans ``=` `sys.maxsize`   `    ``# Traverse for the first node` `    ``for` `i ``in` `range``(``1``, N``+``1``, ``1``):`   `        ``# Traverse for the second node` `        ``for` `j ``in` `range``(i ``+` `1``, N``+``1``, ``1``):`   `            ``# If there is an edge between` `            ``# these two nodes` `            ``if` `adj[i][j] ``=``=` `1``:`   `                ``# Traverse all possible` `                ``# third nodes` `                ``for` `k ``in` `range``(j ``+` `1``, N``+``1``, ``1``):`   `                    ``# If there is an edge` `                    ``# between third node` `                    ``# and the previous two` `                    ``if` `(adj[i][k] ``=``=` `1``) ``and` `(adj[j][k] ``=``=` `1``):`   `                        ``# Update ans` `                        ``ans ``=` `min``(ans, degree[i] ``+` `degree[j] ``+` `degree[k] ``-` `6``)`   `    ``# Return the result` `    ``if` `ans ``=``=` `sys.maxsize:` `        ``return` `-``1` `    ``return` `ans`   `# Driver Code` `Edges ``=` `[[``1``, ``2``], [``1``, ``3``], [``2``, ``3``], [``1``, ``4``], [``2``, ``5``], [``2``, ``7``], [``3``, ``6``], [``3``, ``7``]]` `N ``=` `7`   `print``(minTrioDegree(N, Edges))`   `# This code is contributed by Dharanendra L V.`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `GFG` `{`   `// Function to find the minimum degree` `// of a connected triangle in the graph` `static` `int` `minTrioDegree(``int` `N, ``int` `[,]Edges)` `{` `  `  `    ``// Store the degree of each node` `    ``// in the graph` `    ``int` `[]degree = ``new` `int``[N + 1];`   `    ``// Stores the representation of` `    ``// graph in an adjancency matrix` `    ``int` `[,]adj = ``new` `int``[N + 1, N + 1];`   `    ``// Create the adjacency matrix and` `    ``// count the degree of nodes` `    ``for` `(``int` `i = 0; i < Edges.GetLength(0); i++) ` `    ``{`   `        ``// u & v are the endpoint of` `        ``// the ith edge` `        ``int` `u = Edges[i, 0];` `        ``int` `v = Edges[i, 1];`   `        ``// Mark both edges i.e.,` `        ``// edge u.v and v.u` `        ``adj[u, v] = adj[u, v] = 1;`   `        ``// Increment degree by 1` `        ``// of both endnodes` `        ``degree[u]++;` `        ``degree[v]++;` `    ``}`   `    ``// Stores the required result` `    ``int` `ans = ``int``.MaxValue;`   `    ``// Traverse for the first node` `    ``for` `(``int` `i = 1; i <= N; i++) {`   `        ``// Traverse for the second node` `        ``for` `(``int` `j = i + 1; j <= N; j++) {`   `            ``// If there is an edge between` `            ``// these two nodes` `            ``if` `(adj[i,j] == 1) {`   `                ``// Traverse all possible` `                ``// third nodes` `                ``for` `(``int` `k = j + 1;` `                     ``k <= N; k++) {`   `                    ``// If there is an edge` `                    ``// between third node` `                    ``// and the previous two` `                    ``if` `(adj[i,k] == 1` `                        ``&& adj[j,k] == 1) {`   `                        ``// Update ans` `                        ``ans = Math.Min(ans,` `                                  ``degree[i]` `                                      ``+ degree[j]` `                                      ``+ degree[k] - 6);` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Return the result` `    ``return` `ans == ``int``.MaxValue ? -1 : ans;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[,]Edges = { { 1, 2 }, { 1, 3 }, ` `              ``{ 2, 3 }, { 1, 4 }, ` `              ``{ 2, 5 }, { 2, 7 }, ` `              ``{ 3, 6 }, { 3, 7 } };` `    ``int` `N = 7;`   `    ``Console.Write(minTrioDegree(N, Edges));` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`4`

Time Complexity: O(N3
Auxiliary Space: O(N2)

My Personal Notes arrow_drop_up
Recommended Articles
Page :