Find the Shortest Superstring in C++

Suppose we have an array A of strings, we have to find any smallest string that contains each string in A as a substring. We can also assume that no string in A is substring of another string in A.

So, if the input is like ["dbsh","dsbbhs","hdsb","ssdb","bshdbsd"], then the output will be "hdsbbhssdbshdbsd"

To solve this, we will follow these steps −

• Define a function calc(), this will take a, b,

• for initialize i := 0, when i < size of a, update (increase i by 1), do −

  • if substring of a from index i to end is at the start of b, then −

    • return size of b - size of a + i

• return size of b

• From main method, do these steps

• ret := empty string

• n := size of A

• Define one 2D array graph of size n x n −

  • for initialize j := 0, when j < n, update (increase j by 1), do −

    • graph[i, j] := calc(A[i], A[j])

    • graph[j, i] := calc(A[j], A[i])

• Define an array dp of size: 2^n x n.

• Define an array path of size: 2^n x n.

• minVal := inf

• last := -1

• for initialize i := 0, when i < 2^n, update (increase i by 1), do −

  • for initialize j := 0, when j < n, update (increase j by 1), do −

    • dp[i, j] := inf

• for initialize i := 0, when i < 2^n, update (increase i by 1), do −

  • for initialize j := 0, when j < n, update (increase j by 1), do −

    • if i AND 2^j is non-zero, then

      • prev := i ^ (2^j)

    • if prev is same as 0, then −

      • dp[i, j] := size of A[j]

    • Otherwise

      • for initialize k := 0, when k < n, update (increase k by 1), do −

        • if prev AND 2^k and df[prev,k] is not inf and df[prev,k] + graph[k,j] < dp[i,j], then

          • dp[i, j] := dp[prev, k] + graph[k, j]

          • path[i, j] := k

  • if i is same as 2^n - 1 and dp[i, j] < minVal, then −

    • minVal := dp[i, j]

    • last := j

• curr := 2^n - 1

• Define one stack st

• while curr > 0, do −

  • insert last into st

  • temp := curr

  • curr := curr - (2^last)

  • last := path[temp, last]

• i := top element of st

• delete element from st

• ret := ret + A[i]

• while (not st is empty), do −

  • j := top element of st

  • delete element from st

  • ret := ret concatenate substring of A[j] from (size of A[j] - graph[i,j] to end)

  • i := j

• return ret

Let us see the following implementation to get better understanding −

Example

 Live Demo

#include <bits/stdc++.h>
using namespace std;
class Solution {
   public:
   int calc(string& a, string& b){
      for (int i = 0; i < a.size(); i++) {
         if (b.find(a.substr(i)) == 0) {
            return b.size() - a.size() + i;
         }
      }
      return (int)b.size();
   }
   string shortestSuperstring(vector<string>& A){
      string ret = "";
      int n = A.size();
      vector<vector<int> > graph(n, vector<int>(n));
      for (int i = 0; i < n; i++) {
         for (int j = 0; j < n; j++) {
            graph[i][j] = calc(A[i], A[j]);
            graph[j][i] = calc(A[j], A[i]);
         }
      }
      int dp[1 << n][n];
      int path[1 << n][n];
      int minVal = INT_MAX;
      int last = -1;
      for (int i = 0; i < (1 << n); i++)
      for (int j = 0; j < n; j++)
      dp[i][j] = INT_MAX;
      for (int i = 1; i < (1 << n); i++) {
         for (int j = 0; j < n; j++) {
            if ((i & (1 << j))) {
               int prev = i ^ (1 << j);
               if (prev == 0) {
                  dp[i][j] = A[j].size();
               } else {
                  for (int k = 0; k < n; k++) {
                     if ((prev & (1 << k)) && dp[prev][k] !=
                     INT_MAX && dp[prev][k] + graph[k][j] < dp[i][j]) {
                        dp[i][j] = dp[prev][k] + graph[k][j];
                        path[i][j] = k;
                     }
                  }
               }
            }
            if (i == (1 << n) - 1 && dp[i][j] < minVal) {
               minVal = dp[i][j];
               last = j;
            }
         }
      }
      int curr = (1 << n) - 1;
      stack<int> st;
      while (curr > 0) {
         st.push(last);
         int temp = curr;
         curr -= (1 << last);
         last = path[temp][last];
      }
      int i = st.top();
      st.pop();
      ret += A[i];
      while (!st.empty()) {
         int j = st.top();
         st.pop();
         ret += (A[j].substr(A[j].size() - graph[i][j]));
         i = j;
      }
      return ret;
   }
};
main(){
   Solution ob;
   vector<string> v = {"dbsh","dsbbhs","hdsb","ssdb","bshdbsd"};
   cout << (ob.shortestSuperstring(v));
}

Input

{"dbsh","dsbbhs","hdsb","ssdb","bshdbsd"}

Output

hdsbbhssdbshdbsd