Skip to content
Related Articles

Related Articles

Improve Article

Arrange array elements such that last digit of an element is equal to first digit of the next element

  • Last Updated : 05 Feb, 2021

Given an array arr[] of integers, the task is to arrange the array elements such that the last digit of an element is equal to first digit of the next element.

Examples: 

Input: arr[] = {123, 321} 
Output: 123 321

Input: arr[] = {451, 378, 123, 1254} 
Output: 1254 451 123 378 
 

Naive approach: Find all the permutations of the array elements and then print the arranged array which meets the required condition. The time complexity of this approach is O(N!)



Efficient approach: Create a directed graph where there will be a directed edge from a node A to node B if the last digit of the number represented by Node A is equal to the first digit of the number represented by Node B. Now, find the Eulerian path for the graph formed. The complexity of the above algorithm is O(E * E) where E is the number of edges in the graph.

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// To store the array elements
vector<string> arr;
 
// Adjacency list for the graph nodes
vector<vector<int> > graph;
 
// To store the euler path
vector<string> path;
 
// Print eulerian path
bool print_euler(int i, int visited[], int count)
{
    // Mark node as visited
    // and increase the count
    visited[i] = 1;
    count++;
 
    // If all the nodes are visited
    // then we have traversed the euler path
    if (count == graph.size()) {
        path.push_back(arr[i]);
        return true;
    }
 
    // Check if the node lies in euler path
    bool b = false;
 
    // Traverse through remaining edges
    for (int j = 0; j < graph[i].size(); j++)
        if (visited[graph[i][j]] == 0) {
            b |= print_euler(graph[i][j], visited, count);
        }
 
    // If the euler path is found
    if (b) {
        path.push_back(arr[i]);
        return true;
    }
 
    // Else unmark the node
    else {
        visited[i] = 0;
        count--;
        return false;
    }
}
 
// Function to create the graph and
// print the required path
void connect()
{
    int n = arr.size();
    graph.clear();
    graph.resize(n);
 
    // Connect the nodes
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j)
                continue;
 
            // If the last character matches with the
            // first character
            if (arr[i][arr[i].length() - 1] == arr[j][0]) {
                graph[i].push_back(j);
            }
        }
    }
 
    // Print the path
    for (int i = 0; i < n; i++) {
        int visited[n] = { 0 }, count = 0;
 
        // If the euler path starts
        // from the ith node
        if (print_euler(i, visited, count))
            break;
    }
 
    // Print the euler path
    for (int i = path.size() - 1; i >= 0; i--) {
        cout << path[i];
        if (i != 0)
            cout << " ";
    }
}
// Driver code
int main()
{
    arr.push_back("451");
    arr.push_back("378");
    arr.push_back("123");
    arr.push_back("1254");
 
    // Create graph and print the path
    connect();
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
 
class GFG{
 
// To store the array elements
static List<String> arr = new ArrayList<String>();
 
// Adjacency list for the graph nodes
static List<List<Integer>> graph = new ArrayList<List<Integer>>();
 
// To store the euler path
static List<String> path = new ArrayList<String>();
 
// Print eulerian path
static boolean print_euler(int i, int []visited,
                           int count)
{
     
    // Mark node as visited
    // and increase the count
    visited[i] = 1;
    count++;
 
    // If all the nodes are visited
    // then we have traversed the euler path
    if (count == graph.size())
    {
        path.add(arr.get(i));
        return true;
    }
 
    // Check if the node lies in euler path
    boolean b = false;
 
    // Traverse through remaining edges
    for(int j = 0; j < graph.get(i).size(); j++)
        if (visited[graph.get(i).get(j)] == 0)
        {
            b |= print_euler(graph.get(i).get(j),
                             visited, count);
        }
 
    // If the euler path is found
    if (b)
    {
        path.add(arr.get(i));
        return true;
    }
 
    // Else unmark the node
    else
    {
        visited[i] = 0;
        count--;
        return false;
    }
}
 
// Function to create the graph and
// print the required path
static void connect()
{
    int n = arr.size();
    graph = new ArrayList<List<Integer>>(n);
 
    for(int i = 0; i < n; i++)
    {
        graph.add(new ArrayList<Integer>());
    }
     
    // Connect the nodes
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if (i == j)
                continue;
 
            // If the last character matches with the
            // first character
            if (arr.get(i).charAt((arr.get(i).length()) - 1) ==
                arr.get(j).charAt(0))
            {
                graph.get(i).add(j);
            }
        }
    }
 
    // Print the path
    for(int i = 0; i < n; i++)
    {
        int []visited = new int[n];
        int count = 0;
 
        // If the euler path starts
        // from the ith node
        if (print_euler(i, visited, count))
            break;
    }
 
    // Print the euler path
    for(int i = path.size() - 1; i >= 0; i--)
    {
        System.out.print(path.get(i));
         
        if (i != 0)
            System.out.print(" ");
    }
}
 
// Driver code
public static void main(String []args)
{
    arr.add("451");
    arr.add("378");
    arr.add("123");
    arr.add("1254");
 
    // Create graph and print the path
    connect();
}
}
 
// This code is contributed by pratham76
Python3



# Python3 implementation of the approach
 
# Print eulerian path
 
 
def print_euler(i, visited, count):
 
    # Mark node as visited
    # and increase the count
    visited[i] = 1
    count += 1
 
    # If all the nodes are visited then
    # we have traversed the euler path
    if count == len(graph):
        path.append(arr[i])
        return True
 
    # Check if the node lies in euler path
    b = False
 
    # Traverse through remaining edges
    for j in range(0, len(graph[i])):
        if visited[graph[i][j]] == 0:
            b |= print_euler(graph[i][j], visited, count)
 
    # If the euler path is found
    if b:
        path.append(arr[i])
        return True
 
    # Else unmark the node
    else:
        visited[i] = 0
        count -= 1
        return False
 
# Function to create the graph
# and print the required path
 
 
def connect():
 
    n = len(arr)
    # Connect the nodes
    for i in range(0, n):
        for j in range(0, n):
            if i == j:
                continue
 
            # If the last character matches
            # with the first character
            if arr[i][-1] == arr[j][0]:
                graph[i].append(j)
 
    # Print the path
    for i in range(0, n):
        visited = [0] * n
        count = 0
 
        # If the euler path starts
        # from the ith node
        if print_euler(i, visited, count):
            break
 
    # Print the euler path
    for i in range(len(path) - 1, -1, -1):
        print(path[i], end="")
        if i != 0:
            print(" ", end="")
 
 
# Driver code
if __name__ == "__main__":
 
    # To store the array elements
    arr = []
    arr.append("451")
    arr.append("378")
    arr.append("123")
    arr.append("1254")
 
    # Adjacency list for the graph nodes
    graph = [[] for i in range(len(arr))]
 
    # To store the euler path
    path = []
 
    # Create graph and print the path
    connect()
 
# This code is contributed by Rituraj Jain
C#



// C# implementation of the approach
using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG
{
 
// To store the array elements
static List<string> arr = new List<string>();
 
// Adjacency list for the graph nodes
static List<List<int> > graph=  new List<List<int>>();
 
// To store the euler path
static List<string> path = new List<string>();
 
// Print eulerian path
static bool print_euler(int i, int []visited, int count)
{
    // Mark node as visited
    // and increase the count
    visited[i] = 1;
    count++;
 
    // If all the nodes are visited
    // then we have traversed the euler path
    if (count == graph.Count) {
        path.Add(arr[i]);
        return true;
    }
 
    // Check if the node lies in euler path
    bool b = false;
 
    // Traverse through remaining edges
    for (int j = 0; j < graph[i].Count; j++)
        if (visited[graph[i][j]] == 0) {
            b |= print_euler(graph[i][j], visited, count);
        }
 
    // If the euler path is found
    if (b) {
        path.Add(arr[i]);
        return true;
    }
 
    // Else unmark the node
    else {
        visited[i] = 0;
        count--;
        return false;
    }
}
 
// Function to create the graph and
// print the required path
static void connect()
{
    int n = arr.Count;
    graph=new List<List<int>>(n);
 
    for(int i = 0; i < n; i++)
    {
        graph.Add(new List<int>());
    }
     
    // Connect the nodes
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j)
                continue;
 
            // If the last character matches with the
            // first character
            if (arr[i][(arr[i].Length) - 1] == arr[j][0]) {
                graph[i].Add(j);
            }
        }
    }
 
    // Print the path
    for (int i = 0; i < n; i++) {
 
        int []visited = new int[n];
        int count = 0;
 
        // If the euler path starts
        // from the ith node
        if (print_euler(i, visited, count))
            break;
    }
 
    // Print the euler path
    for (int i = path.Count - 1; i >= 0; i--) {
        Console.Write(path[i]);
        if (i != 0)
            Console.Write(" ");
    }
}
 
// Driver code
public static void Main(params string []args)
{
    arr.Add("451");
    arr.Add("378");
    arr.Add("123");
    arr.Add("1254");
 
    // Create graph and print the path
    connect();
}
}
 
// This code is contributed by rutvik_56.
Output: 
1254 451 123 378
 
Time Complexity : O(N* log(N))
Auxiliary Space: O(N)
 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Previous
ReactJS | Introduction to Babel
Next

Minimizing array sum by applying XOR operation on all elements of the array
Recommended Articles
Page :
Count distinct sequences obtained by replacing all elements of subarrays having equal first and last elements with the first element any number of times
29, Jun 21
Remaining array element after repeated removal of last element and subtraction of each element from next adjacent element
23, Feb 21
Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
11, Jul 19
Sort Array such that smallest is at 0th index and next smallest it at last index and so on
08, Jul 20
Check if sum of array can be made equal to X by removing either the first or last digits of every array element
23, Mar 21
Count all N-length arrays made up of distinct consecutive elements whose first and last elements are equal
06, Jan 21
Count non-palindromic array elements having same first and last digit
03, Sep 20
Longest Subarray with first element greater than or equal to Last element
18, Aug 18
Arrange the array such that upon performing given operations an increasing order is obtained
04, Feb 20
Find next Smaller of next Greater in an array
10, Dec 16
Last element of an array after repeatedly removing the first element and appending it to the end of the array twice exactly K times
27, Jun 21
Count array elements exceeding all previous elements as well as the next array element
18, Jan 21
Maximum sum subsequence made up of at most K distant elements including the first and last array elements
22, Feb 21
Minimize swaps required to make the first and last elements the largest and smallest elements in the array respectively
23, Mar 21
Sort an array having first N elements sorted and last M elements are unsorted
15, Jun 21
Maximum element in an array such that its previous and next element product is maximum
02, Jul 19
Count of elements which are equal to the XOR of the next two elements
24, Sep 19
Count of Array elements greater than all elements on its left and next K elements on its right
05, Aug 20
Last seen array element (last appearance is earliest)
19, Nov 17
Count L-length arrays possible made up of first N natural numbers and each element dividing the next element
29, Jun 21
Minimize swaps required to place largest and smallest array elements at first and last array indices
28, Jan 21
Generate an N-length array having length of non-decreasing subarrays maximized and minimum difference between first and last array elements
23, Jul 21
Longest subsequence with first and last element greater than all other elements
11, Jun 19
Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
17, Apr 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
andrew1234
@andrew1234
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox