Find if an Array of Strings can be Chained to form a Circle in Java

Find whether an array of strings may be linked together to create a circle. If the last character of string X and the first character of string Y are the same, then string X can be positioned in a circle before string Y.

Example 1:

Input:

String a = {"python", "nodejs", "scripted-php"}

Output:

Yes, the strings can be chained to form a circle.

Explanation:

For the given array of strings, the strings that can be formed as chains are python ? nodejs; nodejs ? scripted-php; scripted-php ? python. Hence, the strings can be chained to form a circle.

Example 2:

Input:

String a = {"bac", "cda", "aaa", "aab"}

Output:

Yes, the strings can be chained to form a circle.

Explanation:

For the given array of strings, the strings that can be formed as chains are bac ? cda; cda ? aaa; aaa ? aab; aab ? bac. Hence, the strings can be chained to form a circle.

Example 3:

Input:

String a = {"ijk", "kji", "abc", "cba"}

Output:

No, the strings cannot be chained to form a circle.

Explanation:

For the given array of strings, the strings that can be formed as chains are ijk ? kji; abc ? cba, but they cannot be formed as a cycle. Hence, the strings cannot be chained to form a circle.

Approach: Using Directed Graphs

The approach implements into practice an algorithm to determine if a directed graph can form an Eulerian cycle. It accomplishes this by verifying two conditions:

Strong Connectivity (isSC): It determines if every vertex in the network that has a degree greater than zero is strongly connected, indicating that every vertex can be accessed from every other vertex.

Equivalent in terms of both in and out degrees: It checks if each vertex's in-degree and out-degree are equal, which is an essential requirement for Eulerian cycles.

The technique iterates over the graph using depth-first search (DFS), verifying that all vertices have been visited. In order to verify the connection in both directions, the graph is also constructed in reverse. In the final step, it makes use of the graph structure to determine if the given collection of strings may be chained together to form an Eulerian cycle.

Algorithm:

Step 1: Declare a class called StringChainedCycle.to represent an undirected graph.

Step 2: Initialize the class variables with the following values: "in" indicates an array to store the in-degree of each vertex; "ver" indicates the total number of vertices; and "adj" indicates a dynamic array of adjacency lists to store the graph structure.

Step 3: Set up each vertex's adjacency lists and class variables.

Step 4: Update the destination vertex in in-degree and add an edge connecting two vertices in the graph.

Step 5: Check each vertex's degree and connection to see if the network has an Eulerian cycle.

Step 6: Use Depth First Search (DFS) to confirm that there is strong connectivity between vertices of non-zero degrees.

Step 7: Start with the Depth First Search traversal, beginning at a specified vertex.

Step 8: To verify the connection, obtain the graph's transposition (reverse).

Step 9: Apply an array of strings as a basis, and create a graph in which each string represents an edge.

Step 10: Return true to indicate that the strings can be linked together if the graph contains an Eulerian cycle.

Implementation:

FileName: StringChainedCycle.java

import java.io.*;
import java.util.ArrayList;
import java.util.List;
// A class that operates as an undirected graph representation
public class StringChainedCycle
{
    static final int ch = 26;
    // total number of vertices
    int Ver; 
    // declaring a dynamic array of adjacency lists
    List<List<Integer>> adj; 
    int[] in;
    // with the use of Constructor
    StringChainedCycle(int Ver)
    {
    	this.Ver = Ver;
    	in = new int[Ver];
    	adj = new ArrayList<>(ch);
    	for(int i = 0; i < ch; i++)
    	{
    	    adj.add(i, new ArrayList<>());
    	}
    }
    // Function for adding an edge to graph
    void additionEdge(int vertex, int edge)
    {
    	adj.get(vertex).add(edge);
    	in[edge]++;
    }
    // A method to determine whether the graph is Eulerian or not 
    boolean CheckEulerianCycle() 
    {
    	// Verify that every vertex with a degree 
    	// other than zero is connected.
    	if (!VertexConnected())
    		return false;
    	// Verify that each vertex's in and 
    	// out degrees are the same.
    	for(int i = 0; i < Ver; i++)
    	if (adj.get(i).size() != in[i])
    		return false;
    	return true;
    }
    // If there is strong connectivity among all 
    // the non-zero degree vertices in the network, 
    // then this function returns true. 
    boolean VertexConnected() 
    {
    	// Identify every vertex as not having 
    	// been visited (for the first DFS).
    	boolean[] visit = new boolean[Ver];
    	for(int i = 0; i < Ver; i++)
    	visit[i] = false;
    	// Determine which vertex has a 
    	// degree that is not zero.
    	int N;
    	for(N = 0; N < Ver; N++)
    	if (adj.get(N).size() > 0)
    		break;
    	// Start the DFS traversal at the 
    	// first non-zero degree vertex.
    	DFS(N, visit);
    	// Return false if the DFS traversal
    	// doesn't visit every vertex.
    	for(int i = 0; i < Ver; i++)
    	if (adj.get(i).size() > 0 && !visit[i])
    		return false;
    	// Create a reversed graph
    	StringChainedCycle revgr = getTranspose();
        // Identify every vertex as not having 
        // been visited (for the second DFS).
    	for(int i = 0; i < Ver; i++)
    	visit[i] = false;
    	// Perform DFS on a reversed graph, beginning 
    	// at the first vertex. Beginning Vertex 
    	// must be identical to the first DFS's starting point.
    	revgr.DFS(N, visit);
    	// Return false if none of the vertices 
    	// in the second DFS are visited.
    	for(int i = 0; i < Ver; i++)
    	if (adj.get(i).size() > 0 && !visit[i])
    		return false;
    	return true;
    }
    // Function to perform DFS from the vertex.
    // Used in isConnected(); a recursive procedure 
    // for DFS that begins at the vertex
    void DFS(int vertex, boolean[] visit)
    {
    	// Identify the visited node as 
    	// the current one and print it.
    	visit[vertex] = true;
    	// Repeat for each vertex that is next to this vertex.
    	for(Integer i : adj.get(vertex))
    	if (!visit[i])
    	{
    		DFS(i, visit);
    	}
    }
    // Function that returns this 
    // graph's transposition,
    // or reverse It takes this function 
    // to use vertexConnected().
    StringChainedCycle getTranspose()
    {
    	StringChainedCycle g = new StringChainedCycle(Ver);
    	for(int vertex = 0; vertex < Ver; vertex++)
    	{
        	// Repeat for each vertex that
        	// is next to this vertex.
        	for(Integer i : adj.get(vertex))
        	{
        		g.adj.get(i).add(vertex);
        		g.in[vertex]++;
        	}
    	}
    	return g;
    }
    // This function accepts an array of 
    // strings as input and returns true 
    // if the array of strings can be linked
    // together to create a cycle.
    static boolean ChainedCycle(String[] arr, int N)
    {
        // creating a graph
    	StringChainedCycle gra = new StringChainedCycle(ch);
    	// Create an edge for each string starting 
    	// at the first and ending at the final character.
    	for(int i = 0; i < N; i++)
    	{
        	String str = arr[i];
        	gra.additionEdge(str.charAt(0) - 'a', str.charAt(str.length() - 1) - 'a');
    	}
    	// If an Eulerian cycle exists in the generated graph, 
    	//The given set of strings can be chained.
    	return gra.CheckEulerianCycle();
    }
    public static void main(String[] args) throws Exception
    {
    	String[] arr = { "bac", "cda", "aaa", "aab" };
    	int N = arr.length;
    	System.out.println((ChainedCycle(arr, N) ?
    					"Yes, it can be chained " : "No, it cannot be chained "));
    }
}

Output: