# Minimum number of edges that need to be added to form a triangle

Given an undirected graph with N vertices and N edges. No two edges connect the same pair of vertices. A triangle is a set of three distinct vertices such that each pair of those vertices is connected by an edge i.e. three distinct vertices u, v and w are a triangle if the graph contains the edges (u, v), (v, w) and (v, u). The task is to find the minimum number of edges needed to be added to the given graph such that the graph contains at least one triangle.
Examples:

```Input:
1
/ \
2   3
Output: 1

Input:
1     3
/     /
2     4
Output: 2```

Approach: Initialize ans = 3 which is the maximum count of edges required to form a triangle. Now, for every possible vertex triplet there are four cases:

1. Case 1: If there exist nodes i, j and k such that there is an edge from (i, j), (j, k) and (k, i) then the answer is 0.
2. Case 2: If there exist nodes i, j and k such that only two pairs of vertices are connected then a single edge is required to form a triangle. So update ans = min(ans, 1).
3. Case 3: Otherwise, if there only a single pair of vertices is connected then ans = min(ans, 2).
4. Case 4: When there is no edge then ans = min(ans, 3).

Print the ans in the end. Below is the implementation of the above approach.

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the minimum number``// of edges that need to be added to``// the given graph such that it``// contains at least one triangle``int` `minEdges(vector > v, ``int` `n)``{` `    ``// adj is the adjacency matrix such that``    ``// adj[i][j] = 1 when there is an``    ``// edge between i and j``    ``vector > adj;``    ``adj.resize(n + 1);``    ``for` `(``int` `i = 0; i < adj.size(); i++)``        ``adj[i].resize(n + 1, 0);` `    ``// As the graph is undirected``    ``// so there will be an edge``    ``// between (i, j) and (j, i)``    ``for` `(``int` `i = 0; i < v.size(); i++) {``        ``adj[v[i].first][v[i].second] = 1;``        ``adj[v[i].second][v[i].first] = 1;``    ``}` `    ``// To store the required``    ``// count of edges``    ``int` `edgesNeeded = 3;` `    ``// For every possible vertex triplet``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``for` `(``int` `j = i + 1; j <= n; j++) {``            ``for` `(``int` `k = j + 1; k <= n; k++) {` `                ``// If the vertices form a triangle``                ``if` `(adj[i][j] && adj[j][k] && adj[k][i])``                    ``return` `0;` `                ``// If no edges are present``                ``if` `(!(adj[i][j] || adj[j][k] || adj[k][i]))``                    ``edgesNeeded = min(edgesNeeded, 3);` `                ``else` `{` `                    ``// If only 1 edge is required``                    ``if` `((adj[i][j] && adj[j][k])``                        ``|| (adj[j][k] && adj[k][i])``                        ``|| (adj[k][i] && adj[i][j])) {``                        ``edgesNeeded = 1;``                    ``}` `                    ``// Two edges are required``                    ``else``                        ``edgesNeeded = min(edgesNeeded, 2);``                ``}``            ``}``        ``}``    ``}``    ``return` `edgesNeeded;``}` `// Driver code``int` `main()``{` `    ``// Number of nodes``    ``int` `n = 3;` `    ``// Storing the edges in a vector of pairs``    ``vector > v = { { 1, 2 }, { 1, 3 } };` `    ``cout << minEdges(v, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.io.*;``import` `java.util.*;` `class` `Pair ``{``    ``V first;``    ``E second;` `    ``Pair(V first, E second) ``    ``{``        ``this``.first = first;``        ``this``.second = second;``    ``}``}` `class` `GFG ``{` `    ``// Function to return the minimum number``    ``// of edges that need to be added to``    ``// the given graph such that it``    ``// contains at least one triangle``    ``static` `int` `minEdges(Vector> v, ``int` `n) ``    ``{` `        ``// adj is the adjacency matrix such that``        ``// adj[i][j] = 1 when there is an``        ``// edge between i and j``        ``int``[][] adj = ``new` `int``[n + ``1``][n + ``1``];` `        ``// As the graph is undirected``        ``// so there will be an edge``        ``// between (i, j) and (j, i)``        ``for` `(``int` `i = ``0``; i < v.size(); i++) ``        ``{``            ``adj[v.elementAt(i).first]``               ``[v.elementAt(i).second] = ``1``;``            ``adj[v.elementAt(i).second]``               ``[v.elementAt(i).first] = ``1``;``        ``}` `        ``// To store the required``        ``// count of edges``        ``int` `edgesNeeded = ``0``;` `        ``// For every possible vertex triplet``        ``for` `(``int` `i = ``1``; i <= n; i++)``        ``{``            ``for` `(``int` `j = i + ``1``; j <= n; j++) ``            ``{``                ``for` `(``int` `k = j + ``1``; k <= n; k++) ``                ``{` `                    ``// If the vertices form a triangle``                    ``if` `(adj[i][j] == ``1` `&& ``                        ``adj[j][k] == ``1` `&& adj[k][i] == ``1``)``                        ``return` `0``;` `                    ``// If no edges are present``                    ``if` `(!(adj[i][j] == ``1` `|| ``                          ``adj[j][k] == ``1` `|| adj[k][i] == ``1``))``                        ``edgesNeeded = Math.min(edgesNeeded, ``3``);` `                    ``else``                    ``{` `                        ``// If only 1 edge is required``                        ``if` `((adj[i][j] == ``1` `&& adj[j][k] == ``1``) || ``                            ``(adj[j][k] == ``1` `&& adj[k][i] == ``1``) || ``                            ``(adj[k][i] == ``1` `&& adj[i][j] == ``1``)) ``                        ``{``                            ``edgesNeeded = ``1``;``                        ``}` `                        ``// Two edges are required``                        ``else``                            ``edgesNeeded = Math.min(edgesNeeded, ``2``);``                    ``}``                ``}``            ``}``        ``}``        ``return` `edgesNeeded;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args) ``    ``{` `        ``// Number of nodes``        ``int` `n = ``3``;` `        ``// Storing the edges in a vector of pairs``        ``Vector> v = ``new` `Vector<>(Arrays.asList(``new` `Pair<>(``1``, ``2``), ``                                                             ``new` `Pair<>(``1``, ``3``)));` `        ``System.out.println(minEdges(v, n));``    ``}``}` `// This code is contributed by``// sanjeev2552`

## Python3

 `# Python3 implementation of the approach ` `# Function to return the minimum number ``# of edges that need to be added to ``# the given graph such that it ``# contains at least one triangle ``def` `minEdges(v, n) : ` `    ``# adj is the adjacency matrix such that ``    ``# adj[i][j] = 1 when there is an ``    ``# edge between i and j ``    ``adj ``=` `dict``.fromkeys(``range``(n ``+` `1``)); ``    ` `    ``# adj.resize(n + 1); ``    ``for` `i ``in` `range``(n ``+` `1``) :``        ``adj[i] ``=` `[``0``] ``*` `(n ``+` `1``); ` `    ``# As the graph is undirected ``    ``# so there will be an edge ``    ``# between (i, j) and (j, i) ``    ``for` `i ``in` `range``(``len``(v)) :``        ``adj[v[i][``0``]][v[i][``1``]] ``=` `1``; ``        ``adj[v[i][``1``]][v[i][``0``]] ``=` `1``; ` `    ``# To store the required ``    ``# count of edges ``    ``edgesNeeded ``=` `3``; ` `    ``# For every possible vertex triplet ``    ``for` `i ``in` `range``(``1``, n ``+` `1``) : ``        ``for` `j ``in` `range``(i ``+` `1``, n ``+` `1``) :``            ``for` `k ``in` `range``(j ``+` `1``, n ``+` `1``) :` `                ``# If the vertices form a triangle ``                ``if` `(adj[i][j] ``and` `adj[j][k] ``and` `adj[k][i]) :``                    ``return` `0``; ` `                ``# If no edges are present ``                ``if` `(``not` `(adj[i][j] ``or` `adj[j][k] ``or` `adj[k][i])) :``                    ``edgesNeeded ``=` `min``(edgesNeeded, ``3``); ` `                ``else` `:` `                    ``# If only 1 edge is required ``                    ``if` `((adj[i][j] ``and` `adj[j][k])``                        ``or` `(adj[j][k] ``and` `adj[k][i]) ``                        ``or` `(adj[k][i] ``and` `adj[i][j])) : ``                        ``edgesNeeded ``=` `1``; ` `                    ``# Two edges are required ``                    ``else` `:``                        ``edgesNeeded ``=` `min``(edgesNeeded, ``2``); ``    ` `    ``return` `edgesNeeded; ` `# Driver code ``if` `__name__ ``=``=` `"__main__"` `: ` `    ``# Number of nodes ``    ``n ``=` `3``; ` `    ``# Storing the edges in a vector of pairs ``    ``v ``=` `[ [ ``1``, ``2` `], [ ``1``, ``3` `] ]; ` `    ``print``(minEdges(v, n)); ``    ` `# This code is contributed by kanugargng`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `Pair ``{``    ``public` `int` `first;``    ``public` `int` `second;` `    ``public` `Pair(``int` `first, ``int` `second) ``    ``{``        ``this``.first = first;``        ``this``.second = second;``    ``}``}` `class` `GFG ``{` `    ``// Function to return the minimum number``    ``// of edges that need to be added to``    ``// the given graph such that it``    ``// contains at least one triangle``    ``static` `int` `minEdges(List v, ``int` `n) ``    ``{` `        ``// adj is the adjacency matrix such that``        ``// adj[i,j] = 1 when there is an``        ``// edge between i and j``        ``int``[,] adj = ``new` `int``[n + 1, n + 1];` `        ``// As the graph is undirected``        ``// so there will be an edge``        ``// between (i, j) and (j, i)``        ``for` `(``int` `i = 0; i < v.Count; i++) ``        ``{``            ``adj[v[i].first,v[i].second] = 1;``            ``adj[v[i].second,v[i].first] = 1;``        ``}` `        ``// To store the required``        ``// count of edges``        ``int` `edgesNeeded = 0;` `        ``// For every possible vertex triplet``        ``for` `(``int` `i = 1; i <= n; i++)``        ``{``            ``for` `(``int` `j = i + 1; j <= n; j++) ``            ``{``                ``for` `(``int` `k = j + 1; k <= n; k++) ``                ``{` `                    ``// If the vertices form a triangle``                    ``if` `(adj[i, j] == 1 && ``                        ``adj[j, k] == 1 && adj[k, i] == 1)``                        ``return` `0;` `                    ``// If no edges are present``                    ``if` `(!(adj[i, j] == 1 || ``                        ``adj[j, k] == 1 || adj[k, i] == 1))``                        ``edgesNeeded = Math.Min(edgesNeeded, 3);` `                    ``else``                    ``{` `                        ``// If only 1 edge is required``                        ``if` `((adj[i, j] == 1 && adj[j, k] == 1) || ``                            ``(adj[j, k] == 1 && adj[k, i] == 1) || ``                            ``(adj[k, i] == 1 && adj[i, j] == 1)) ``                        ``{``                            ``edgesNeeded = 1;``                        ``}` `                        ``// Two edges are required``                        ``else``                            ``edgesNeeded = Math.Min(edgesNeeded, 2);``                    ``}``                ``}``            ``}``        ``}``        ``return` `edgesNeeded;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args) ``    ``{` `        ``// Number of nodes``        ``int` `n = 3;` `        ``// Storing the edges in a vector of pairs``        ` `        ``List v = ``new` `List();``        ``v.Add(``new` `Pair(1, 2));``        ``v.Add(``new` `Pair(1, 3));``        ``Console.WriteLine(minEdges(v, n));``    ``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 `// JavaScript implementation of the approach``function` `minEdges(v, n) {``  ``// adj is the adjacency matrix such that``  ``// adj[i][j] = 1 when there is an``  ``// edge between i and j``  ``let adj = [];``  ``for` `(let i = 0; i <= n; i++) {``    ``adj[i] = [];``    ``for` `(let j = 0; j <= n; j++) {``      ``adj[i][j] = 0;``    ``}``  ``}` `  ``// As the graph is undirected``  ``// so there will be an edge``  ``// between (i, j) and (j, i)``  ``for` `(let i = 0; i < v.length; i++) {``    ``adj[v[i][0]][v[i][1]] = 1;``    ``adj[v[i][1]][v[i][0]] = 1;``  ``}` `  ``// To store the required``  ``// count of edges``  ``let edgesNeeded = 3;` `  ``// For every possible vertex triplet``  ``for` `(let i = 1; i <= n; i++) {``    ``for` `(let j = i + 1; j <= n; j++) {``      ``for` `(let k = j + 1; k <= n; k++) {``        ``// If the vertices form a triangle``        ``if` `(adj[i][j] && adj[j][k] && adj[k][i]) ``return` `0;` `        ``// If no edges are present``        ``if` `(!(adj[i][j] || adj[j][k] || adj[k][i])) {``          ``edgesNeeded = Math.min(edgesNeeded, 3);``        ``} ``else` `{``          ``// If only 1 edge is required``          ``if` `(``            ``(adj[i][j] && adj[j][k]) ||``            ``(adj[j][k] && adj[k][i]) ||``            ``(adj[k][i] && adj[i][j])``          ``) {``            ``edgesNeeded = 1;``          ``} ``else` `{``            ``// Two edges are required``            ``edgesNeeded = Math.min(edgesNeeded, 2);``          ``}``        ``}``      ``}``    ``}``  ``}``  ``return` `edgesNeeded;``}` `// Driver code``let n = 3;` `// Storing the edges in an array of arrays``let v = [[1, 2], [1, 3]];` `console.log(minEdges(v, n));`

Output:
`1`

Time complexity : O(n^3)

Space complexity : O(n^2)

Previous
Next