Open In App
Related Articles

Minimum cost to sort strings using reversal operations of different costs

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given an array of strings and costs of reversing all strings, we need to sort the array. We cannot move strings in array, only string reversal is allowed. We need to reverse some of the strings in such a way that all strings make a lexicographic order and cost is also minimized. If it is not possible to sort strings in any way, output not possible. 

Examples: 

Input  : arr[] = {?”, ?”, ?”}, 
reverseCost[] = {1, 3, 1}
Output : Minimum cost of sorting = 1
Explanation : We can make above string array sorted
by reversing one of 2nd or 3rd string, but reversing
2nd string cost 3, so we will reverse 3rd string to
make string array sorted with a cost 1 which is
minimum.

We can solve this problem using dynamic programming. We make a 2D array for storing the minimum cost of sorting.

dp[i][j] represents the minimum cost to make first i
strings sorted.
j = 1 means i'th string is reversed.
j = 0 means i'th string is not reversed.
Value of dp[i][j] is computed using dp[i-1][1] and
dp[i-1][0].
Computation of dp[i][0]
If arr[i] is greater than str[i-1], we update dp[i][0]
by dp[i-1][0]
If arr[i] is greater than reversal of previous string
we update dp[i][0] by dp[i-1][1]
Same procedure is applied to compute dp[i][1], we
reverse str[i] before applying the procedure.
At the end we will choose minimum of dp[N-1][0] and
dp[N-1][1] as our final answer if both of them not
updated yet even once, we will flag that sorting is
not possible.

Below is the implementation of above idea. 

C++

// C++ program to get minimum cost to sort
// strings by reversal operation
#include <bits/stdc++.h>
using namespace std;
 
// Returns minimum cost for sorting arr[]
// using reverse operation. This function
// returns -1 if it is not possible to sort.
int minCost(string arr[], int cost[], int N)
{
    // dp[i][j] represents the minimum cost to
    // make first i strings sorted.
    // j = 1 means i'th string is reversed.
    // j = 0 means i'th string is not reversed.
    int dp[N][2];
 
    // initializing dp array for first string
    dp[0][0] = 0;
    dp[0][1] = cost[0];
 
    // getting array of reversed strings
    string revStr[N];
    for (int i = 0; i < N; i++)
    {
        revStr[i] = arr[i];
        reverse(revStr[i].begin(), revStr[i].end());
    }
 
    string curStr;
    int curCost;
 
    // looping for all strings
    for (int i = 1; i < N; i++)
    {
        // Looping twice, once for string and once
        // for reversed string
        for (int j = 0; j < 2; j++)
        {
            dp[i][j] = INT_MAX;
 
            // getting current string and current
            // cost according to j
            curStr = (j == 0) ? arr[i] : revStr[i];
            curCost = (j == 0) ? 0 : cost[i];
 
            // Update dp value only if current string
            // is lexicographically larger
            if (curStr >= arr[i - 1])
                dp[i][j] = min(dp[i][j], dp[i-1][0] + curCost);
            if (curStr >= revStr[i - 1])
                dp[i][j] = min(dp[i][j], dp[i-1][1] + curCost);
        }
    }
 
    // getting minimum from both entries of last index
    int res = min(dp[N-1][0], dp[N-1][1]);
 
    return (res == INT_MAX)? -1 : res;
}
 
// Driver code to test above methods
int main()
{
    string arr[] = {"aa", "ba", "ac"};
    int cost[] = {1, 3, 1};
    int N = sizeof(arr) / sizeof(arr[0]);
 
    int res = minCost(arr, cost, N);
    if (res == -1)
        cout << "Sorting not possible\n";
    else
        cout << "Minimum cost to sort strings is "
            << res;
}

                    

Java

// Java program to get minimum cost to sort
// strings by reversal operation
import java.util.*;
 
class GFG
{
 
// Returns minimum cost for sorting arr[]
// using reverse operation. This function
// returns -1 if it is not possible to sort.
static int minCost(String arr[], int cost[], int N)
{
    // dp[i][j] represents the minimum cost to
    // make first i strings sorted.
    // j = 1 means i'th string is reversed.
    // j = 0 means i'th string is not reversed.
    int [][]dp = new int[N][2];
 
    // initializing dp array for first string
    dp[0][0] = 0;
    dp[0][1] = cost[0];
 
    // getting array of reversed strings
    String []revStr = new String[N];
    for (int i = 0; i < N; i++)
    {
        revStr[i] = arr[i];
        revStr[i] = reverse(revStr[i], 0,
                            revStr[i].length() - 1);
    }
 
    String curStr = "";
    int curCost;
 
    // looping for all strings
    for (int i = 1; i < N; i++)
    {
        // Looping twice, once for string and once
        // for reversed string
        for (int j = 0; j < 2; j++)
        {
            dp[i][j] = Integer.MAX_VALUE;
 
            // getting current string and current
            // cost according to j
            curStr = (j == 0) ? arr[i] : revStr[i];
            curCost = (j == 0) ? 0 : cost[i];
 
            // Update dp value only if current string
            // is lexicographically larger
            if (curStr.compareTo(arr[i - 1]) >= 0)
                dp[i][j] = Math.min(dp[i][j],
                                    dp[i - 1][0] + curCost);
            if (curStr.compareTo(revStr[i - 1]) >= 0)
                dp[i][j] = Math.min(dp[i][j],
                                    dp[i - 1][1] + curCost);
        }
    }
 
    // getting minimum from both entries of last index
    int res = Math.min(dp[N - 1][0], dp[N - 1][1]);
 
    return (res == Integer.MAX_VALUE)? -1 : res;
}
 
static String reverse(String s, int start, int end)
{
 
    // Temporary variable to store character
    char temp;
    char []str = s.toCharArray();
    while (start <= end)
    {
         
        // Swapping the first and last character
        temp = str[start];
        str[start] = str[end];
        str[end] = temp;
        start++;
        end--;
    }
    return String.valueOf(str);
}
 
// Driver Code
public static void main(String[] args)
{
    String arr[] = {"aa", "ba", "ac"};
    int cost[] = {1, 3, 1};
    int N = arr.length;
 
    int res = minCost(arr, cost, N);
    if (res == -1)
        System.out.println("Sorting not possible\n");
    else
        System.out.println("Minimum cost to " +
                           "sort strings is " + res);
    }
}
 
// This code is contributed by Rajput-Ji

                    

Python3

# Python program to get minimum cost to sort
# strings by reversal operation
 
# Returns minimum cost for sorting arr[]
# using reverse operation. This function
# returns -1 if it is not possible to sort.
def ReverseStringMin(arr, reverseCost, n):
     
    # dp[i][j] represents the minimum cost to
    # make first i strings sorted.
    # j = 1 means i'th string is reversed.
    # j = 0 means i'th string is not reversed.
     
    dp = [[float("Inf")] * 2 for i in range(n)]
 
    # initializing dp array for first string
    dp[0][0] = 0
 
    dp[0][1] = reverseCost[0]
 
    # getting array of reversed strings
    rev_arr = [i[::-1] for i in arr]
 
    # looping for all strings
    for i in range(1, n):
 
        # Looping twice, once for string and once
        # for reversed string
        for j in range(2):
 
            # getting current string and current
            # cost according to j
            curStr = arr[i] if j==0 else rev_arr[i]
 
            curCost = 0 if j==0 else reverseCost[i]
 
            # Update dp value only if current string
            # is lexicographically larger
            if (curStr >= arr[i - 1]):
 
                dp[i][j] = min(dp[i][j], dp[i-1][0] + curCost)
 
            if (curStr >= rev_arr[i - 1]):
 
                dp[i][j] = min(dp[i][j], dp[i-1][1] + curCost)
 
    # getting minimum from both entries of last index
    res = min(dp[n-1][0], dp[n-1][1])
 
    return res if res != float("Inf") else -1
 
 
# Driver code
def main():
 
 
    arr = ["aa", "ba", "ac"]
 
    reverseCost = [1, 3, 1]
 
    n = len(arr)
 
    dp = [float("Inf")] * n
 
    res = ReverseStringMin(arr, reverseCost,n)
 
    if res != -1 :
 
        print ("Minimum cost to sort sorting is" , res)
 
    else :
        print ("Sorting not possible")
 
 
if __name__ == '__main__':
    main()
 
#This code is contributed by Neelam Yadav

                    

C#

// C# program to get minimum cost to sort
// strings by reversal operation
using System;
 
class GFG
{
 
// Returns minimum cost for sorting arr[]
// using reverse operation. This function
// returns -1 if it is not possible to sort.
static int minCost(String []arr,
                   int []cost, int N)
{
    // dp[i,j] represents the minimum cost to
    // make first i strings sorted.
    // j = 1 means i'th string is reversed.
    // j = 0 means i'th string is not reversed.
    int [,]dp = new int[N, 2];
 
    // initializing dp array for first string
    dp[0, 0] = 0;
    dp[0, 1] = cost[0];
 
    // getting array of reversed strings
    String []revStr = new String[N];
    for (int i = 0; i < N; i++)
    {
        revStr[i] = arr[i];
        revStr[i] = reverse(revStr[i], 0,
                            revStr[i].Length - 1);
    }
 
    String curStr = "";
    int curCost;
 
    // looping for all strings
    for (int i = 1; i < N; i++)
    {
        // Looping twice, once for string and once
        // for reversed string
        for (int j = 0; j < 2; j++)
        {
            dp[i, j] = int.MaxValue;
 
            // getting current string and current
            // cost according to j
            curStr = (j == 0) ? arr[i] : revStr[i];
            curCost = (j == 0) ? 0 : cost[i];
 
            // Update dp value only if current string
            // is lexicographically larger
            if (curStr.CompareTo(arr[i - 1]) >= 0)
                dp[i, j] = Math.Min(dp[i, j],
                                    dp[i - 1, 0] + curCost);
            if (curStr.CompareTo(revStr[i - 1]) >= 0)
                dp[i, j] = Math.Min(dp[i, j],
                                    dp[i - 1, 1] + curCost);
        }
    }
 
    // getting minimum from both entries of last index
    int res = Math.Min(dp[N - 1, 0],
                       dp[N - 1, 1]);
 
    return (res == int.MaxValue) ? -1 : res;
}
 
static String reverse(String s, int start, int end)
{
 
    // Temporary variable to store character
    char temp;
    char []str = s.ToCharArray();
    while (start <= end)
    {
         
        // Swapping the first and last character
        temp = str[start];
        str[start] = str[end];
        str[end] = temp;
        start++;
        end--;
    }
    return String.Join("", str);
}
 
// Driver Code
public static void Main(String[] args)
{
    String []arr = {"aa", "ba", "ac"};
    int []cost = {1, 3, 1};
    int N = arr.Length;
 
    int res = minCost(arr, cost, N);
    if (res == -1)
        Console.WriteLine("Sorting not possible\n");
    else
        Console.WriteLine("Minimum cost to " +
                          "sort strings is " + res);
    }
}
 
// This code is contributed by Princi Singh

                    

Javascript

<script>
 
// Javascript program to get minimum cost to sort
// strings by reversal operation
     
    // Returns minimum cost for sorting arr[]
    // using reverse operation. This function
    // returns -1 if it is not possible to sort.
    function minCost(arr,cost,N)
    {
        // dp[i][j] represents the minimum cost to
        // make first i strings sorted.
        // j = 1 means i'th string is reversed.
        // j = 0 means i'th string is not reversed.
         
        let dp=new Array(N);
        for(let i=0;i<N;i++)
        {
            dp[i]=new Array(2);
            for(let j=0;j<2;j++)
            {
                dp[i][j]=0;
            }
        }
         
        // initializing dp array for first string
        dp[0][0] = 0;
        dp[0][1] = cost[0];
       
        // getting array of reversed strings
        let revStr = new Array(N);
        for(let i=0;i<N;i++)
        {
            revStr[i]="";
        }
         
        for (let i = 0; i < N; i++)
        {
            revStr[i] = arr[i];
            revStr[i] = reverse(revStr[i], 0,
                                revStr[i].length - 1);
        }
       
        let curStr = "";
        let curCost;
       
        // looping for all strings
        for (let i = 1; i < N; i++)
        {
            // Looping twice, once for string and once
            // for reversed string
            for (let j = 0; j < 2; j++)
            {
                dp[i][j] = Number.MAX_VALUE;
       
                // getting current string and current
                // cost according to j
                curStr = (j == 0) ? arr[i] : revStr[i];
                curCost = (j == 0) ? 0 : cost[i];
       
                // Update dp value only if current string
                // is lexicographically larger
                if (curStr>=arr[i - 1])
                    dp[i][j] = Math.min(dp[i][j],
                                        dp[i - 1][0] + curCost);
                if (curStr>=revStr[i - 1])
                    dp[i][j] = Math.min(dp[i][j],
                                        dp[i - 1][1] + curCost);
            }
        }
       
        // getting minimum from both entries of last index
        let res = Math.min(dp[N - 1][0], dp[N - 1][1]);
       
        return (res == Number.MAX_VALUE)? -1 : res;
    }
     
     
    function reverse(s,start,end)
    {
        // Temporary variable to store character
        let temp;
        let str=s.split("");
        while (start <= end)
        {
               
            // Swapping the first and last character
            temp = str[start];
            str[start] = str[end];
            str[end] = temp;
            start++;
            end--;
        }
        return str.toString();
         
    }
     
    // Driver Code
    let arr=["aa", "ba", "ac"];
    let cost=[1, 3, 1];
    let N = arr.length;
    let res = minCost(arr, cost, N);
    if (res == -1)
        document.write("Sorting not possible\n");
    else
        document.write("Minimum cost to " +
                           "sort strings is " + res);
     
     
    // This code is contributed by avanitrachhadiya2155
     
</script>

                    

PHP

<?php
// PHP program to get minimum cost to sort
// strings by reversal operation
 
// Returns minimum cost for sorting arr[]
// using reverse operation. This function
// returns -1 if it is not possible to sort.
function minCost(&$arr, &$cost, $N)
{
    // dp[i][j] represents the minimum cost
    // to make first i strings sorted.
    // j = 1 means i'th string is reversed.
    // j = 0 means i'th string is not reversed.
    $dp = array_fill(0, $N,
          array_fill(0, 2, NULL));
 
    // initializing dp array for
    // first string
    $dp[0][0] = 0;
    $dp[0][1] = $cost[0];
 
    // getting array of reversed strings
    $revStr = array_fill(false, $N, NULL);
    for ($i = 0; $i < $N; $i++)
    {
        $revStr[$i] = $arr[$i];
        $revStr[$i] = strrev($revStr[$i]);
    }
 
    $curStr = "";
 
    // looping for all strings
    for ($i = 1; $i < $N; $i++)
    {
        // Looping twice, once for string
        // and once for reversed string
        for ($j = 0; $j < 2; $j++)
        {
            $dp[$i][$j] = PHP_INT_MAX;
 
            // getting current string and
            // current cost according to j
            if($j == 0)
                $curStr = $arr[$i];
            else
                $curStr = $revStr[$i];
                 
            if($j == 0)
                $curCost = 0 ;
            else
                $curCost = $cost[$i];
 
            // Update dp value only if current string
            // is lexicographically larger
            if ($curStr >= $arr[$i - 1])
                $dp[$i][$j] = min($dp[$i][$j],
                                  $dp[$i - 1][0] +
                                  $curCost);
            if ($curStr >= $revStr[$i - 1])
                $dp[$i][$j] = min($dp[$i][$j],
                                  $dp[$i - 1][1] +
                                  $curCost);
        }
    }
 
    // getting minimum from both entries
    // of last index
    $res = min($dp[$N - 1][0], $dp[$N - 1][1]);
 
    if($res == PHP_INT_MAX)
        return -1 ;
    else
        return $res;
}
 
// Driver Code
$arr = array("aa", "ba", "ac");
$cost = array(1, 3, 1);
$N = sizeof($arr);
$res = minCost($arr, $cost, $N);
if ($res == -1)
    echo "Sorting not possible\n";
else
    echo "Minimum cost to sort strings is " . $res;
 
// This code is contributed by ita_c
?>

                    

Output
Minimum cost to sort strings is 1







Time Complexity: O(N)
Auxiliary Space: O(N)

Efficient approach : Space Optimization O(1)

To optimize the space complexity of the above approach, we can eliminate the need for a 2D array dp and instead use variables to store the previous minimum costs. This will reduce the space complexity from O(N) to O(1).

Implementations Steps:

  • Initialize dp0 as 0 and dp1 as the cost of the first string.
  • Iterate from i = 1 to N-1, where N is the number of strings.
  • Inside the loop, initialize cur0 and cur1 as INT_MAX.
  • Compare arr[i] with arr[i-1] and update cur0 if arr[i] is larger or equal.
  • Compare reversed arr[i] with arr[i-1] and update cur1 if it is larger or equal.
  • Update dp0 with cur0 and dp1 with cur1.
  • Get the minimum cost from dp0 and dp1 at the last index.
  • If the minimum cost is still INT_MAX, return -1; otherwise, return the minimum cost.

Implementation:

C++

#include <bits/stdc++.h>
using namespace std;
 
// Returns minimum cost for sorting arr[]
// using reverse operation. This function
// returns -1 if it is not possible to sort.
int minCost(string arr[], int cost[], int N)
{
    int dp0 = 0; // Minimum cost for the previous string in original order
    int dp1 = cost[0]; // Minimum cost for the previous string in reversed order
 
    for (int i = 1; i < N; i++)
    {
        int cur0 = INT_MAX; // Minimum cost for the current string in original order
        int cur1 = INT_MAX; // Minimum cost for the current string in reversed order
 
        // Update dp values only if the current string is lexicographically larger
        if (arr[i] >= arr[i - 1])
            cur0 = min(cur0, dp0);
        if (arr[i] >= string(arr[i - 1].rbegin(), arr[i - 1].rend()))
            cur0 = min(cur0, dp1);
 
        // Update dp values for reversed strings
        if (string(arr[i].rbegin(), arr[i].rend()) >= arr[i - 1])
            cur1 = min(cur1, dp0 + cost[i]);
        if (string(arr[i].rbegin(), arr[i].rend()) >= string(arr[i - 1].rbegin(), arr[i - 1].rend()))
            cur1 = min(cur1, dp1 + cost[i]);
 
        dp0 = cur0; // Update the minimum cost for the previous string in original order
        dp1 = cur1; // Update the minimum cost for the previous string in reversed order
    }
 
    // Get the minimum from both entries of the last index
    int res = min(dp0, dp1);
 
    return (res == INT_MAX) ? -1 : res;
}
 
// Driver code to test above methods
int main()
{
    string arr[] = {"aa", "ba", "ac"};
    int cost[] = {1, 3, 1};
    int N = sizeof(arr) / sizeof(arr[0]);
 
    int res = minCost(arr, cost, N);
    if (res == -1)
        cout << "Sorting not possible\n";
    else
        cout << "Minimum cost to sort strings is " << res;
 
    return 0;
}

                    

Java

import java.util.Arrays;
 
public class GFG {
 
    // Returns minimum cost for sorting arr[]
    // using reverse operation. This function
    // returns -1 if it is not possible to sort.
    public static int minCost(String[] arr, int[] cost, int N) {
        int dp0 = 0; // Minimum cost for the previous string in original order
        int dp1 = cost[0]; // Minimum cost for the previous string in reversed order
 
        for (int i = 1; i < N; i++) {
            int cur0 = Integer.MAX_VALUE; // Minimum cost for the current string in original order
            int cur1 = Integer.MAX_VALUE; // Minimum cost for the current string in reversed order
 
            // Update dp values only if the current string is lexicographically larger
            if (arr[i].compareTo(arr[i - 1]) >= 0)
                cur0 = Math.min(cur0, dp0);
            if (arr[i].compareTo(new StringBuilder(arr[i - 1]).reverse().toString()) >= 0)
                cur0 = Math.min(cur0, dp1);
 
            // Update dp values for reversed strings
            if (new StringBuilder(arr[i]).reverse().toString().compareTo(arr[i - 1]) >= 0)
                cur1 = Math.min(cur1, dp0 + cost[i]);
            if (new StringBuilder(arr[i]).reverse().toString().compareTo(
                    new StringBuilder(arr[i - 1]).reverse().toString()) >= 0)
                cur1 = Math.min(cur1, dp1 + cost[i]);
 
            dp0 = cur0; // Update the minimum cost for the previous string in original order
            dp1 = cur1; // Update the minimum cost for the previous string in reversed order
        }
 
        // Get the minimum from both entries of the last index
        int res = Math.min(dp0, dp1);
 
        return (res == Integer.MAX_VALUE) ? -1 : res;
    }
 
    // Driver code to test above methods
    public static void main(String[] args) {
        String[] arr = {"aa", "ba", "ac"};
        int[] cost = {1, 3, 1};
        int N = arr.length;
 
        int res = minCost(arr, cost, N);
        if (res == -1)
            System.out.println("Sorting not possible");
        else
            System.out.println("Minimum cost to sort strings is " + res);
    }
}

                    

Python3

def min_cost(arr, cost, N):
    dp0 = 0  # Minimum cost for the previous string in original order
    dp1 = cost[0# Minimum cost for the previous string in reversed order
 
    for i in range(1, N):
        cur0 = float('inf'# Minimum cost for the current string in original order
        cur1 = float('inf'# Minimum cost for the current string in reversed order
 
        # Update dp values only if the current string is lexicographically larger
        if arr[i] >= arr[i - 1]:
            cur0 = min(cur0, dp0)
        if arr[i] >= arr[i - 1][::-1]:
            cur0 = min(cur0, dp1)
 
        # Update dp values for reversed strings
        if arr[i][::-1] >= arr[i - 1]:
            cur1 = min(cur1, dp0 + cost[i])
        if arr[i][::-1] >= arr[i - 1][::-1]:
            cur1 = min(cur1, dp1 + cost[i])
 
        dp0 = cur0  # Update the minimum cost for the previous string in original order
        dp1 = cur1  # Update the minimum cost for the previous string in reversed order
 
    # Get the minimum from both entries of the last index
    res = min(dp0, dp1)
 
    return -1 if res == float('inf') else res
 
# Driver code to test the above function
arr = ["aa", "ba", "ac"]
cost = [1, 3, 1]
N = len(arr)
 
res = min_cost(arr, cost, N)
if res == -1:
    print("Sorting not possible")
else:
    print("Minimum cost to sort strings is", res)
 
# This code is contributed by shivamgupta310570

                    

C#

using System;
using System.Linq;
 
class Program
{
    // Returns minimum cost for sorting arr[]
    // using reverse operation. This function
    // returns -1 if it is not possible to sort.
    static int MinCost(string[] arr, int[] cost, int N)
    {
        int dp0 = 0; // Minimum cost for the previous string in original order
        int dp1 = cost[0]; // Minimum cost for the previous string in reversed order
 
        for (int i = 1; i < N; i++)
        {
            int cur0 = int.MaxValue; // Minimum cost for the current string in original order
            int cur1 = int.MaxValue; // Minimum cost for the current string in reversed order
 
            // Update dp values only if the current string is lexicographically larger
            if (string.Compare(arr[i], arr[i - 1]) >= 0)
                cur0 = Math.Min(cur0, dp0);
            if (string.Compare(arr[i], new string(arr[i - 1].Reverse().ToArray())) >= 0)
                cur0 = Math.Min(cur0, dp1);
 
            // Update dp values for reversed strings
            if (string.Compare(new string(arr[i].Reverse().ToArray()), arr[i - 1]) >= 0)
                cur1 = Math.Min(cur1, dp0 + cost[i]);
            if (string.Compare(new string(arr[i].Reverse().ToArray()), new string(arr[i - 1].Reverse().ToArray())) >= 0)
                cur1 = Math.Min(cur1, dp1 + cost[i]);
 
            dp0 = cur0; // Update the minimum cost for the previous string in original order
            dp1 = cur1; // Update the minimum cost for the previous string in reversed order
        }
 
        // Get the minimum from both entries of the last index
        int res = Math.Min(dp0, dp1);
 
        return (res == int.MaxValue) ? -1 : res;
    }
 
    // Driver code to test above methods
    static void Main()
    {
        string[] arr = { "aa", "ba", "ac" };
        int[] cost = { 1, 3, 1 };
        int N = arr.Length;
 
        int res = MinCost(arr, cost, N);
        if (res == -1)
            Console.WriteLine("Sorting not possible");
        else
            Console.WriteLine("Minimum cost to sort strings is " + res);
    }
}

                    

Javascript

function minCost(arr, cost, N) {
    let dp0 = 0;  // Minimum cost for the previous string in original order
    let dp1 = cost[0];  // Minimum cost for the previous string in reversed order
 
    for (let i = 1; i < N; i++) {
        let cur0 = Number.POSITIVE_INFINITY;  // Minimum cost for the current string in original
        let cur1 = Number.POSITIVE_INFINITY;  // Minimum cost for the current string in reversed
 
        // Update dp values only if the current string is lexicographically larger
        if (arr[i] >= arr[i - 1]) {
            cur0 = Math.min(cur0, dp0);
        }
        if (arr[i] >= arr[i - 1].split('').reverse().join('')) {
            cur0 = Math.min(cur0, dp1);
        }
 
        // Update dp values for reversed strings
        if (arr[i].split('').reverse().join('') >= arr[i - 1]) {
            cur1 = Math.min(cur1, dp0 + cost[i]);
        }
        if (arr[i].split('').reverse().join('') >= arr[i - 1].split('').reverse().join('')) {
            cur1 = Math.min(cur1, dp1 + cost[i]);
        }
 
        dp0 = cur0;  // Update the minimum cost for the previous string in original order
        dp1 = cur1;  // Update the minimum cost for the previous string in reversed order
    }
 
    // Get the minimum from both entries of the last index
    let res = Math.min(dp0, dp1);
 
    if (res === Number.POSITIVE_INFINITY) {
        return -1;
    } else {
        return res;
    }
}
 
// Driver code to test the above function
const arr = ["aa", "ba", "ac"];
const cost = [1, 3, 1];
const N = arr.length;
 
const res = minCost(arr, cost, N);
if (res === -1) {
    console.log("Sorting not possible");
} else {
    console.log("Minimum cost to sort strings is", res);
}

                    


Output

Minimum cost to sort strings is 1

Time Complexity: O(N)
Auxiliary Space: O(1)

This article is contributed by Utkarsh Trivedi.  



Last Updated : 06 Nov, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads