Minimum cost to sort strings using reversals of different costs

Last Updated : 19 Apr, 2025

Given an array of strings arr[] and an array cost[] representing the cost to reverse each corresponding string. We are not allowed to move or reorder the strings in the array, we can only reverse individual strings if needed. The task is to choose which strings to reverse such that the final array is in non-decreasing lexicographic order, and the total cost of reversals is minimized.

Note: If it’s not possible to achieve a sorted array using any combination of reversals, return -1.

Examples:

Input: arr[] = [“aa”, “ba”, “ac”], cost[] = [1, 3, 1]
Output: 1
Explanation: The minimum cost to make the array sorted lexicographically is 1.
-> “aa” at index 0 is fine, whether reversed or not, as “aa” remains the same.
-> “ba” at index 1 is greater than “aa”, so it’s already in correct order.
-> “ac” at index 2 is less than “ba”, so the array is not sorted. Reversing “ac” gives “ca”, which is greater than “ba”, making the array [“aa”, “ba”, “ca”] sorted. This single reversal costs 1, and no other reversal option gives a better result.

Input: arr[] = [“cba”, “bca”, “aaa”], cost[] = [1, 2, 3]
Output: -1
Explanation: No combination of reversals can make the array sorted in lexicographic order. Even reversing all strings results in [“abc”, “acb”, “aaa”], which is also not sorted. Hence, the output is -1.

Table of Content

[Approach 1] Using Dynamic Programming – O(n) Time and O(n) Space

At each index i, we have two choices:

Keep arr[i] as-is
Reverse arr[i] (with cost cost[i])

We recursively decide which choice to make, such that:

The chosen version of arr[i] is lexicographically ≥ the previous chosen string.
We minimize the total cost.

The idea is to use dynamic programming. We maintain a 2D dp table where dp[i][0] means the minimum cost to keep i-th string as it is and dp[i][1] means the cost if it’s reversed. The observation is that a string can only follow the previous one in the list if it’s lexicographically greater than or equal to it (either reversed or not). We try both cases at every index and update the cost only if the order is maintained, and finally return the minimum of both states at the last index.

C++

// C++ program to get minimum cost to sort // strings by reversal operation using DP #include <bits/stdc++.h> using namespace std;  // Function to return minimum cost to make array sorted // using only string reversals. Returns -1 if not possible. int minCost(vector<string> arr, vector<int> cost) {          int n = arr.size();      // dp[i][0] = min cost if i-th string is not reversed     // dp[i][1] = min cost if i-th string is reversed     vector<vector<int>> dp(n, vector<int>(2, INT_MAX));      // First string: cost 0 if kept, cost[0] if reversed     dp[0][0] = 0;     dp[0][1] = cost[0];      // Store reversed versions of strings     vector<string> reversed(n);     for (int i = 0; i < n; i++) {         reversed[i] = arr[i];         reverse(reversed[i].begin(), reversed[i].end());     }      // Fill dp for all strings from second to last     for (int i = 1; i < n; i++) {                  // j = 0 means the string stri[i] is reversed         // j = 1 means not reversed         for (int j = 0; j <= 1; j++) {              // Current string and cost if reversed or not             string currStr = j ? reversed[i] : arr[i];             int currCost = j ? cost[i] : 0;              // If currStr >= previous without reverse             if (currStr >= arr[i - 1] && dp[i - 1][0] != INT_MAX) {                 dp[i][j] = min(dp[i][j],                                   dp[i - 1][0] + currCost);             }              // If currStr >= previous with reverse             if (currStr >= reversed[i - 1] && dp[i - 1][1] != INT_MAX) {                 dp[i][j] = min(dp[i][j],                                   dp[i - 1][1] + currCost);             }         }     }      // Get min of last string reversed or not     int res = min(dp[n - 1][0], dp[n - 1][1]);      return (res == INT_MAX) ? -1 : res; }  // Driver code int main() {      vector<string> arr = {"aa", "ba", "ac"};     vector<int> cost = {1, 3, 1};      cout << minCost(arr, cost);      return 0; }

Java

// Java program to get minimum cost to sort // strings by reversal operation using DP import java.util.*;  class GfG {      // Function to return minimum cost to make array sorted     // using only string reversals. Returns -1 if not possible.     static int minCost(String[] arr, int[] cost) {                  int n = arr.length;          // dp[i][0] = min cost if i-th string is not reversed         // dp[i][1] = min cost if i-th string is reversed         int[][] dp = new int[n][2];         for (int[] row : dp)             Arrays.fill(row, Integer.MAX_VALUE);          // First string: cost 0 if kept, cost[0] if reversed         dp[0][0] = 0;         dp[0][1] = cost[0];          // Store reversed versions of strings         String[] reversed = new String[n];         for (int i = 0; i < n; i++) {             reversed[i] = new StringBuilder(arr[i]).reverse().toString();         }          // Fill dp for all strings from second to last         for (int i = 1; i < n; i++) {                                       // j = 0 means the string stri[i] is reversed             // j = 1 means not reversed             for (int j = 0; j <= 1; j++) {                  // Current string and cost if reversed or not                 String currStr = (j == 1) ? reversed[i] : arr[i];                 int currCost = (j == 1) ? cost[i] : 0;                  // If currStr >= previous without reverse                 if (currStr.compareTo(arr[i - 1]) >= 0 && dp[i - 1][0] != Integer.MAX_VALUE) {                     dp[i][j] = Math.min(dp[i][j],                                               dp[i - 1][0] + currCost);                 }                  // If currStr >= previous with reverse                 if (currStr.compareTo(reversed[i - 1]) >= 0 && dp[i - 1][1] != Integer.MAX_VALUE) {                     dp[i][j] = Math.min(dp[i][j],                                               dp[i - 1][1] + currCost);                 }             }         }          // Get min of last string reversed or not         int res = Math.min(dp[n - 1][0], dp[n - 1][1]);          return (res == Integer.MAX_VALUE) ? -1 : res;     }      public static void main(String[] args) {          String[] arr = {"aa", "ba", "ac"};         int[] cost = {1, 3, 1};          System.out.println(minCost(arr, cost));     } }

Python

import sys  def minCost(arr, cost):     n = len(arr)          # Initialize dp table with max values     dp = [[sys.maxsize] * 2 for _ in range(n)]          # First string: cost 0 if not reversed, cost[0] if reversed     dp[0][0] = 0     dp[0][1] = cost[0]          # Precompute reversed strings     reversed_arr = [s[::-1] for s in arr]          for i in range(1, n):                  # j = 0 means not reversed and 1 means reversed         for j in range(2):             curr_str = reversed_arr[i] if j == 1 else arr[i]             curr_cost = cost[i] if j == 1 else 0              # Compare with previous not reversed             if curr_str >= arr[i - 1] and dp[i - 1][0] != sys.maxsize:                 dp[i][j] = min(dp[i][j], dp[i - 1][0] + curr_cost)              # Compare with previous reversed             if curr_str >= reversed_arr[i - 1] and dp[i - 1][1] != sys.maxsize:                 dp[i][j] = min(dp[i][j], dp[i - 1][1] + curr_cost)      result = min(dp[n - 1][0], dp[n - 1][1])     return -1 if result == sys.maxsize else result  # Driver code if __name__ == "__main__":     arr = ["aa", "ba", "ac"]     cost = [1, 3, 1]     print(minCost(arr, cost))

// C# program to get minimum cost to sort // strings by reversal operation using DP using System; using System.Linq;  class GfG {      // Function to return minimum cost to make array sorted     // using only string reversals. Returns -1 if not possible.     static int MinCost(string[] arr, int[] cost) {         int n = arr.Length;          // dp[i][0] = min cost if i-th string is not reversed         // dp[i][1] = min cost if i-th string is reversed         int[,] dp = new int[n, 2];         for (int i = 0; i < n; i++)             dp[i, 0] = dp[i, 1] = int.MaxValue;          // First string: cost 0 if kept, cost[0] if reversed         dp[0, 0] = 0;         dp[0, 1] = cost[0];          // Store reversed versions of strings         string[] reversed = new string[n];         for (int i = 0; i < n; i++) {             char[] charArray = arr[i].ToCharArray();             Array.Reverse(charArray);             reversed[i] = new string(charArray);         }          // Fill dp for all strings from second to last         for (int i = 1; i < n; i++) {             // j = 0 means the string stri[i] is reversed             // j = 1 means not reversed             for (int j = 0; j <= 1; j++) {                 // Current string and cost if reversed or not                 string currStr = (j == 1) ? reversed[i] : arr[i];                 int currCost = (j == 1) ? cost[i] : 0;                  // If currStr >= previous without reverse                 if (string.Compare(currStr, arr[i - 1]) >= 0 && dp[i - 1, 0] != int.MaxValue) {                     dp[i, j] = Math.Min(dp[i, j], dp[i - 1, 0] + currCost);                 }                  // If currStr >= previous with reverse                 if (string.Compare(currStr, reversed[i - 1]) >= 0 && dp[i - 1, 1] != int.MaxValue) {                     dp[i, j] = Math.Min(dp[i, j], dp[i - 1, 1] + currCost);                 }             }         }          // Get min of last string reversed or not         int res = Math.Min(dp[n - 1, 0], dp[n - 1, 1]);          return (res == int.MaxValue) ? -1 : res;     }      public static void Main(string[] args) {         string[] arr = {"aa", "ba", "ac"};         int[] cost = {1, 3, 1};          Console.WriteLine(MinCost(arr, cost));     } }

JavaScript

// Importing required modules  function minCost(arr, cost) {     const n = arr.length;          // Initialize dp table with max values     const dp = Array.from({ length: n }, () => [Infinity, Infinity]);          // First string: cost 0 if not reversed, cost[0] if reversed     dp[0][0] = 0;     dp[0][1] = cost[0];          // Precompute reversed strings     const reversedArr = arr.map(s => s.split('').reverse().join(''));          for (let i = 1; i < n; i++) {                  // j = 0 means not reversed and 1 means reversed         for (let j = 0; j < 2; j++) {             const currStr = j === 1 ? reversedArr[i] : arr[i];             const currCost = j === 1 ? cost[i] : 0;              // Compare with previous not reversed             if (currStr >= arr[i - 1] && dp[i - 1][0] !== Infinity) {                 dp[i][j] = Math.min(dp[i][j], dp[i - 1][0] + currCost);             }              // Compare with previous reversed             if (currStr >= reversedArr[i - 1] && dp[i - 1][1] !== Infinity) {                 dp[i][j] = Math.min(dp[i][j], dp[i - 1][1] + currCost);             }         }     }      const result = Math.min(dp[n - 1][0], dp[n - 1][1]);     return result === Infinity ? -1 : result; }  // Driver code const arr = ["aa", "ba", "ac"]; const cost = [1, 3, 1]; console.log(minCost(arr, cost));

Output

[Approach 2] Using Space Optimized DP – O(n) Time and O(1) Space

The idea is to reduce space complexity by avoiding the use of a full 2D dp array. Instead of storing the minimum costs for all indices, we only track the previous state using two variables, which is sufficient for the current computation. This optimization brings down the space complexity from O(n) to O(1).

Steps to implement the above idea:

Initialize dp0 and dp1 to track minimum cost for original and reversed first string respectively.
Loop through the array from index 1 to n-1 and compute cur0 and cur1 as INT_MAX initially.
For each string, update cur0 if it’s lexicographically greater than previous original or reversed string.
Reverse current and previous strings to compute cur1 based on comparisons with original and reversed forms.
Add cost[i] while updating cur1 since reversal incurs a cost in those valid transitions.
Update dp0 and dp1 to current cur0 and cur1 respectively for the next iteration.
Return the minimum of dp0 and dp1, or -1 if both are still INT_MAX, indicating it’s unsortable.

C++

// C++ program to get minimum cost to sort // strings by reversal operation using  // Space Optimized DP #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(vector<string> arr, vector<int> cost) {     int n = arr.size();      // Minimum cost for the previous string     // in original order     int dp0 = 0;      // Minimum cost for the previous      // string in reversed order     int dp1 = cost[0];      for (int i = 1; i < n; i++) {                  // Minimum cost for the current          // string in original order         int cur0 = INT_MAX;          // Minimum cost for the current          // string in reversed order         int cur1 = INT_MAX;          // 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         string revCurr = string(arr[i].rbegin(), arr[i].rend());         string revPrev = string(arr[i - 1].rbegin(), arr[i - 1].rend());          if (revCurr >= arr[i - 1]) {             cur1 = min(cur1, dp0 + cost[i]);         }          if (revCurr >= revPrev) {             cur1 = min(cur1, dp1 + cost[i]);         }          // Update the minimum cost for          // the previous string         dp0 = cur0;         dp1 = cur1;     }      // Get the minimum from both entries      // of the last index     int res = min(dp0, dp1);      return (res == INT_MAX) ? -1 : res; }  // Driver code int main() {      vector<string> arr = {"aa", "ba", "ac"};     vector<int> cost = {1, 3, 1};      cout << minCost(arr, cost);;       return 0; }

Java

// Java program to get minimum cost to sort // strings by reversal operation using  // Space Optimized DP 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 = arr.length;          // Minimum cost for the previous string         // in original order         int dp0 = 0;          // Minimum cost for the previous          // string in reversed order         int dp1 = cost[0];          for (int i = 1; i < n; i++) {                          // Minimum cost for the current              // string in original order             int cur0 = Integer.MAX_VALUE;              // Minimum cost for the current              // string in reversed order             int cur1 = Integer.MAX_VALUE;              // Update dp values only if the current string is             // lexicographically larger             if (arr[i].compareTo(arr[i - 1]) >= 0) {                 cur0 = Math.min(cur0, dp0);             }              String revPrev = new StringBuilder(arr[i - 1]).reverse().toString();             if (arr[i].compareTo(revPrev) >= 0) {                 cur0 = Math.min(cur0, dp1);             }              // Update dp values for reversed strings             String revCurr = new StringBuilder(arr[i]).reverse().toString();              if (revCurr.compareTo(arr[i - 1]) >= 0) {                 cur1 = Math.min(cur1, dp0 + cost[i]);             }              if (revCurr.compareTo(revPrev) >= 0) {                 cur1 = Math.min(cur1, dp1 + cost[i]);             }              // Update the minimum cost for              // the previous string             dp0 = cur0;             dp1 = cur1;         }          // Get the minimum from both entries          // of the last index         int res = Math.min(dp0, dp1);          return (res == Integer.MAX_VALUE) ? -1 : res;     }      public static void main(String[] args) {         String[] arr = {"aa", "ba", "ac"};         int[] cost = {1, 3, 1};          System.out.println(minCost(arr, cost));     } }

Python

# Python program to get minimum cost to sort # strings by reversal operation using  # Space Optimized DP  # Returns minimum cost for sorting arr # using reverse operation. This function # returns -1 if it is not possible to sort. def minCost(arr, cost):     n = len(arr)      # Minimum cost for the previous string     # in original order     dp0 = 0      # Minimum cost for the previous      # string in reversed order     dp1 = cost[0]      for i in range(1, n):          # Minimum cost for the current          # string in original order         cur0 = float('inf')          # Minimum cost for the current          # string in reversed order         cur1 = float('inf')          # 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         revCurr = arr[i][::-1]         revPrev = arr[i - 1][::-1]          if revCurr >= arr[i - 1]:             cur1 = min(cur1, dp0 + cost[i])          if revCurr >= revPrev:             cur1 = min(cur1, dp1 + cost[i])          # Update the minimum cost for          # the previous string         dp0 = cur0         dp1 = cur1      # Get the minimum from both entries      # of the last index     res = min(dp0, dp1)      return -1 if res == float('inf') else res   if __name__ == "__main__":     arr = ["aa", "ba", "ac"]     cost = [1, 3, 1]      print(minCost(arr, cost))

// C# program to get minimum cost to sort // strings by reversal operation using  // Space Optimized DP using System;  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 = arr.Length;          // Minimum cost for the previous string         // in original order         int dp0 = 0;          // Minimum cost for the previous          // string in reversed order         int dp1 = cost[0];          for (int i = 1; i < n; i++) {                          // Minimum cost for the current              // string in original order             int cur0 = int.MaxValue;              // Minimum cost for the current              // string in reversed order             int cur1 = int.MaxValue;              // 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);             }              string revPrev = new string(arr[i - 1].ToCharArray().Reverse().ToArray());             if (String.Compare(arr[i], revPrev) >= 0) {                 cur0 = Math.Min(cur0, dp1);             }              // Update dp values for reversed strings             string revCurr = new string(arr[i].ToCharArray().Reverse().ToArray());              if (String.Compare(revCurr, arr[i - 1]) >= 0) {                 cur1 = Math.Min(cur1, dp0 + cost[i]);             }              if (String.Compare(revCurr, revPrev) >= 0) {                 cur1 = Math.Min(cur1, dp1 + cost[i]);             }              // Update the minimum cost for              // the previous string             dp0 = cur0;             dp1 = cur1;         }          // Get the minimum from both entries          // of the last index         int res = Math.Min(dp0, dp1);          return (res == int.MaxValue) ? -1 : res;     }      public static void Main() {         string[] arr = {"aa", "ba", "ac"};         int[] cost = {1, 3, 1};          Console.WriteLine(minCost(arr, cost));     } }

JavaScript

// JavaScript program to get minimum cost to sort // strings by reversal operation using  // Space Optimized DP  // Returns minimum cost for sorting arr // using reverse operation. This function // returns -1 if it is not possible to sort. function minCost(arr, cost) {     let n = arr.length;      // Minimum cost for the previous string     // in original order     let dp0 = 0;      // Minimum cost for the previous      // string in reversed order     let dp1 = cost[0];      for (let i = 1; i < n; i++) {          // Minimum cost for the current          // string in original order         let cur0 = Infinity;          // Minimum cost for the current          // string in reversed order         let cur1 = Infinity;          // 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         let revCurr = arr[i].split('').reverse().join('');         let revPrev = arr[i - 1].split('').reverse().join('');          if (revCurr >= arr[i - 1]) {             cur1 = Math.min(cur1, dp0 + cost[i]);         }          if (revCurr >= revPrev) {             cur1 = Math.min(cur1, dp1 + cost[i]);         }          // Update the minimum cost for          // the previous string         dp0 = cur0;         dp1 = cur1;     }      // Get the minimum from both entries      // of the last index     let res = Math.min(dp0, dp1);      return (res === Infinity) ? -1 : res; }  // Driver code let arr = ["aa", "ba", "ac"]; let cost = [1, 3, 1];  console.log(minCost(arr, cost));

Output

Count of AP (Arithmetic Progression) Subsequences in an array

Utkarsh Trivedi

Improve

Article Tags :

Practice Tags :

Minimum cost to sort strings using reversals of different costs

[Approach 1] Using Dynamic Programming – O(n) Time and O(n) Space

[Approach 2] Using Space Optimized DP – O(n) Time and O(1) Space

Similar Reads

Advanced Topics

Easy problems in Dynamic programming

Medium problems on Dynamic programming