Posted on by Kalkicode
Code Graph

# Minimum weight cycle in an undirected weighted graph in java

Java program for Minimum weight cycle in an undirected weighted graph. Here problem description and other solutions.

``````/*
Java program for
Minimum weight cycle in an undirected graph
*/
class AjlistNode
{
// Vertices node key
public int id;
public int weight;
public AjlistNode next;
public AjlistNode(int id, int weight)
{
// Set value of node key
this.id = id;
this.weight = weight;
this.next = null;
}
}
class Vertices
{
public int data;
public AjlistNode next;
public AjlistNode last;
public Vertices(int data)
{
this.data = data;
this.next = null;
this.last = null;
}
}
public class Graph
{
// Number of Vertices
public int size;
public int result;
public Vertices[] node;
public Graph(int size)
{
// Set value
this.size = size;
this.result = 0;
this.node = new Vertices[size];
this.setData();
}
// Set initial node value
public void setData()
{
if (size <= 0)
{
System.out.println("\nEmpty Graph");
}
else
{
for (int index = 0; index < size; index++)
{
// Set initial node value
node[index] = new Vertices(index);
}
}
}
public void connection(int start, int last, int weight)
{
// Safe connection
AjlistNode edge = new AjlistNode(last, weight);
if (node[start].next == null)
{
node[start].next = edge;
}
else
{
// Add edge at the end
node[start].last.next = edge;
}
// Get last edge
node[start].last = edge;
}
//  Handling the request of adding new edge
public void addEdge(int start, int last, int weight)
{
if (start >= 0 && start < this.size &&
last >= 0 && last < this.size)
{
// Connect edge with weight
this.connection(start, last, weight);
this.connection(last, start, weight);
}
else
{
// When invalid nodes
System.out.printf("\nNode missing (%d,%d)",start,last);
}
}
public void printGraph()
{
if (size > 0)
{
// Print graph ajlist
for (int index = 0; index < size; ++index)
{
System.out.print("\nAdjacency list of vertex " + index + " :");
AjlistNode edge = node[index].next;
while (edge != null)
{
// Display graph node value and weight
System.out.print("  " +
node[edge.id].data + "[" +
edge.weight + "]");
// Visit to next edge
edge = edge.next;
}
}
}
}
public void minimumCycle(int start,
int last,
boolean[] visit,
int sum, int length)
{
if (start >= this.size || last >= this.size ||
start < 0 || last < 0 || this.size <= 0)
{
return;
}
if (visit[start] == true)
{
// Here length are indicate loop length
if (length > 2 && start == last && sum < this.result)
{
// Here length is indicate number of nodes
// Because graph is undirected so we consider all cycle
// Which contains more than 2 node
// ---------------------
// When find a new min weight cycle
this.result = sum;
}
return;
}
// Here modified  the value of visited node
visit[start] = true;
// This is used to iterate nodes edges
AjlistNode edge = node[start].next;
while (edge != null)
{
//  Find solution using recursion
minimumCycle(edge.id,
last,
visit,
sum + (edge.weight),
length + 1);
// Visit to next edge
edge = edge.next;
}
// Reset the value of visited node status
visit[start] = false;
}
public void minWeightCycle()
{
if (this.size <= 0)
{
// Empty graph
return;
}
// Auxiliary space which is used to store
boolean[] visit = new boolean[this.size];
// Set initial visited node status
for (int i = 0; i < size; ++i)
{
visit[i] = false;
}
this.result = Integer.MAX_VALUE;
for (int i = 0; i < size; ++i)
{
// Check cycle of node i to i
// Here initial cycle weight is zero
minimumCycle(i, i, visit, 0, 0);
}
// Display result
System.out.println("\nMin weight cycle : " + this.result);
}
public static void main(String[] args)
{
// 6 implies the number of nodes in graph
Graph g = new Graph(6);
// Connect node with an edge
// First and second parameter indicate node
// Last parameter is indicate weight
// Print graph element
g.printGraph();
// Test
g.minWeightCycle();
}
}``````

Output

``````Adjacency list of vertex 0 :  1[3]  3[-3]  4[7]  5[1]
Adjacency list of vertex 1 :  0[3]  2[11]  4[8]  5[0]
Adjacency list of vertex 2 :  1[11]  3[1]  5[4]
Adjacency list of vertex 3 :  0[-3]  2[1]  4[2]
Adjacency list of vertex 4 :  0[7]  1[8]  3[2]  5[8]
Adjacency list of vertex 5 :  0[1]  2[4]  4[8]  1[0]
Min weight cycle : 3``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post