Finding Lexicographically smallest arrangement of some string - c++

Question

The Title might seem as if it is a very common question but please bear with me.
Basically lets say at each index of the string you know which alphabets could be in that index, and then you want to find lexicographically smallest arrangement.
So for example:
Index | Options
-------|----------
1 | 'b'
2 | 'c', 'a'
3 | 'd', 'c'
4 | 'c', 'a'
So hence, o/p should be badc. And yes btw, characters cannot repeat so no greedy algorithm.
I think we could use some sort of Breadth First Search by creating a queue or something of the string and each time we found we could not create another permutation, you pop that out of the list. Doubt this is optimal though, must be something in O(N). Any ideas?
And no, I don't think C is bad, but I would prefer code snippets in C/C++ :p
Thanks!

Answer 1

This can be solved by matching algorithm. You can use a network flow solution to solve this. This can be broken down into a bi-partite graph problem.
To be precise maximum weight assignment problem or maximum cost maximum matching would be a solution.
Below is the bipartite set of vertices -
LEVEL Alphabets
1 a
2 b
3 c
4 d
e
.
.
.
z
Now assign edges from set Level to set Alphabet, only and only if those are the options for that level. So these will be edges here - {1,b} , {2,a}, {2,c} , {3,c} , {3,d} ,{4,a} ,{4,c}
Now, to get the lexicographically least result you need to assign weight to the edges in this fashion -
Edge Wt. = 26^(N-Level) * ('z' - Alphabet)
So for example edge weight for edge {2,c} would be
26^(4-2) * (26-3) = 26^2*23
Now you can use a standard maximum cost maximum matching solution. Which is a polynomial solution. And this would be the best approach as far as I can think now. The naive solution is an exponential solution 26^N, so I think you would be happy with a polynomial solution.

Answer 2

The naive approach is to use backtracking and try every possible solution, however it won't be efficient enough(26!). Then you can improve this backtrack solution by using dynamic programming with the help of bitmask. A bitmask can help you store which characters you have used so far.
Write a recursive function that takes an two inputs, the index which should assign a character to, and a bitmask which indicates which characters we have used so far. Initially the bitmask contains 26 zeros which means we haven't used any characters. After assigning a character to some index we change the bitmask accordingly. For example if we use character a we set the first bit of the bitmask to 1. This way you won't solve a lot of overlapping sub-problems.
#include <iostream>
#include <queue>
#include <vector>
#include <map>
using namespace std;
vector<vector<char> > data;
map< pair<int,int>, string > dp;
string func( int index, int bitmask ){
pair<int,int> p = make_pair(index,bitmask);
if ( dp.count( p ) )
return dp[p];
string min_str = "";
for ( int i=0; i<data[index].size(); ++i ){
if ( (bitmask&(1<<(data[index][i]-'a'))) == 0 ){
string cur_str = "";
cur_str += data[index][i];
if ( index+1 != data.size() ){
int mask = bitmask;
mask |= 1<<(data[index][i]-'a');
string sub = func(index+1, mask);
if (sub == "")
continue;
cur_str += sub;
}
if ( min_str == "" || cur_str < min_str ){
min_str = cur_str;
}
}
}
dp[p] = min_str;
return min_str;
}
int main()
{
data.resize(4);
data[0].push_back('b');
data[1].push_back('c');
data[1].push_back('a');
data[2].push_back('d');
data[2].push_back('c');
data[3].push_back('c');
data[3].push_back('a');
cout << func(0,0) << endl;
}