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 
		// information about visited node
		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
		g.addEdge(0, 1, 3);
		g.addEdge(0, 3, -3);
		g.addEdge(0, 4, 7);
		g.addEdge(0, 5, 1);
		g.addEdge(1, 2, 11);
		g.addEdge(1, 4, 8);
		g.addEdge(2, 3, 1);
		g.addEdge(2, 5, 4);
		g.addEdge(3, 4, 2);
		g.addEdge(4, 5, 8);
		g.addEdge(5, 1, 0);
		// 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.

New Comment