Skip to main content

Minimum weight cycle in an undirected weighted graph in scala

Scala program for Minimum weight cycle in an undirected weighted graph. Here more information.

/*
    Scala program for 
    Minimum weight cycle in an undirected graph
*/
class AjlistNode(
	// Vertices node key
	var id: Int,
		var weight: Int,
			var next: AjlistNode)
{
	def this(id: Int, weight: Int)
	{
		// Set value of node key
		this(id, weight, null);
	}
}
class Vertices(var data: Int,
	var next: AjlistNode,
		var last: AjlistNode)
{
	def this(data: Int)
	{
		this(data, null, null);
	}
}
class Graph(
	// Number of Vertices
	var size: Int,
		var result: Int,
			var node: Array[Vertices])
{
	def this(size: Int)
	{
		// Set value
		this(size, 0, Array.fill[Vertices](size)(null));
        this.setData()
	}
	// Set initial node value
	def setData(): Unit = {
		if (size <= 0)
		{
			println("\nEmpty Graph");
		}
		else
		{
			var index: Int = 0;
			while (index < size)
			{
				// Set initial node value
				node(index) = new Vertices(index);
				index += 1;
			}
		}
	}
	def connection(start: Int, last: Int, weight: Int): Unit = {
		// Safe connection
		var edge: AjlistNode = 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
	def addEdge(start: Int, last: Int, weight: Int): Unit = {
		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
			print("\nNode missing (" + start + " " + last + ")");
		}
	}
	def printGraph(): Unit = {
		if (size > 0)
		{
			var index: Int = 0;
			// Print graph ajlist
			while (index < size)
			{
				print("\nAdjacency list of vertex " + index + " :");
				var edge: AjlistNode = node(index).next;
				while (edge != null)
				{
					// Display graph node value and weight	
					print("  " + node(edge.id).data + "[" + edge.weight + "]");
					// Visit to next edge
					edge = edge.next;
				}
				index += 1;
			}
		}
	}
	def minimumCycle(start: Int, last: Int, 
                     visit: Array[Boolean], sum: Int, 
      				length: Int): Unit = {
		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
		var edge: AjlistNode = 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;
	}
	def minWeightCycle(): Unit = {
		if (this.size <= 0)
		{
			// Empty graph
			return;
		}
		// Auxiliary space which is used to store 
		// information about visited node
		// Set initial visited node status 
		var visit: Array[Boolean] = Array.fill[Boolean](this.size)(false);
		this.result = Int.MaxValue;
		var i: Int = 0;
		while (i < size)
		{
			// Check cycle of node i to i
			// Here initial cycle weight is zero
			minimumCycle(i, i, visit, 0, 0);
			i += 1;
		}
		// Display result
		println("\nMin weight cycle : " + this.result);
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		// 6 implies the number of nodes in graph
		var g: Graph = 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