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