给定一个由N个顶点和M 个边组成的无向图和一个数组edge[][] ，每行代表由一条边连接的两个顶点，任务是找到图中形成三角形的三个节点的最小度数。如果图中不存在任何三角形，则打印“-1” 。
例子：
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:
- One formed by nodes {1, 2, 3}. Degree of the triangle = 5.
- 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
方法：可以通过找到形成三角形的每个三元组节点的度数并计算该三角形中每个节点的度数来解决给定的问题。请按照以下步骤解决问题：
- 初始化一个变量，表示如ANS INT_MAX，其存储形成三角形的节点的最低的程度。
- 从给定的边集创建一个邻接矩阵。
- 将给定图的每个节点的度数存储在辅助数组中，例如degree[] 。
- 现在，在[1, N]范围内迭代所有可能的节点(i, j, k)三元组并执行以下步骤：
- 如果每对三元组之间都有边，则存在一个三角形。因此，将ans的值更新为ans和(degree[i] + degree[j] + degree[k] – 6)的最小值。
- 否则，继续下一次迭代。
- 完成上述步骤后，如果ans值为INT_MAX ，则打印“-1” 。否则，将an的值打印为图中任何三角形的最小度数。
下面是上述方法的实现：
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 29AjayKumarPython3
# 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 29AjayKumarJavascript
输出：
4时间复杂度： O(N 3 )
辅助空间： O(N 2 )
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live