Merge two string and produce the lexicographical smallest merged string - string

Question

I was solving a problem when I encountered a rather simple sub problem. Given two string S1 and S2, merge(S1,S2) denotes any string that's obtained by interspersing the two strings S1 and S2, maintaining the order of characters in both such that the resultant string is lexicographically smallest.
Example
S1 = abad
S2 = bbde
merge(S1, S2) = ababbdde
Now, i tried to solve the problem by applying a greedy technique starting from the first element of both the string and then looking for the smallest element and adding it to the result. But, soon I found out that this doesn't always lead to the optimal solution. The code looked something like below.
int n = a.size(), m = b.size();
int i =0, j=0, k=0; char array[n+m];
for(; i< n && j<n;) {
if(a[i] < b[j]) {
array[k] = a[i];
++i;
}
else {
array[k] = b[j];
++j;
}
++k;
}
while(i<n) {
array[k] = a[i];
++i;
++k;
}
while(j<m) {
array[k] = b[j];
++j;
++k;
}
for (int i = 0; i < n+m; ++i) {
cout<<array[i];
}
cout<<endl;
I thought of traversing it backwards and choosing the largest character and started adding it from behind. With the limited testing I performed this looked good.
int n = a.size(), m = b.size();
int i =n-1, j=m-1, k=n+m-1; char array[n+m];
for(; i>=0 && j>=0;) {
if(a[i] > b[j]) {
array[k] = a[i];
--i;
}
else {
array[k] = b[j];
--j;
}
--k;
}
while(i>=0) {
array[k] = a[i];
--i;
--k;
}
while(j>=0) {
array[k] = b[j];
--j;
--k;
}
for (int i = 0; i < n + m; ++i) {
cout<<array[i];
}
cout<<endl;
But, I'm unsure if this will always give the optimal solution always.
Is this solution correct in the first place and if yes can someone give me a slight proof as to why this produces the optimal solution always too.

Answer 1

The greedy approach works, however,
if(a[i] < b[j]) {
array[k] = a[i];
++i;
}
else {
array[k] = b[j];
++j;
}
this part is incorrect because when a[i] == b[j] you can't simply assign b[j] to array[k].
Instead, you need to compare the substring a[i:] and b[j:] when a[i] == b[j], and you can just operate on the std::string itself:
if(s1[i] < s2[j])
{
array[k] = s1[i];
++i;
}
else if (s1[i] == s2[j] && s1.substr(i) < s2.substr(j))
{
array[k] = s1[i];
++i;
}
else
{
array[k] = s2[j];
++j;
}
The time complexity would be quadratic (O(n^2)) since substr operation takes O(n).

Answer 2

Here's full solution based on my comment earlier.
import string
import random
global brute_force_lowest
global almost_greedy_lowest
global brute_force_calls
global almost_greedy_calls
def brute_force(p, a, b):
global brute_force_lowest
global brute_force_calls
brute_force_calls += 1
if len(a) > 0: brute_force(p + a[0], a[1:], b)
if len(b) > 0: brute_force(p + b[0], a, b[1:])
if len(a) == 0 and len(b) == 0:
if p < brute_force_lowest: brute_force_lowest = p
def almost_greedy(p, a, b):
global almost_greedy_lowest
global almost_greedy_calls
almost_greedy_calls += 1
if len(a) == 0 and len(b) == 0:
if p < almost_greedy_lowest: almost_greedy_lowest = p
elif len(b) == 0:
almost_greedy(p + a, '', '')
elif len(a) == 0:
almost_greedy(p + b, '', '')
elif a[0] < b[0]:
almost_greedy(p + a[0], a[1:], b)
elif a[0] > b[0]:
almost_greedy(p + b[0], a, b[1:])
else:
almost_greedy(p + a[0], a[1:], b)
almost_greedy(p + b[0], a, b[1:])
for j in range(10000):
a = ''.join(random.choice(string.ascii_lowercase) for _ in range(random.randint(2, 10)))
b = ''.join(random.choice(string.ascii_lowercase) for _ in range(random.randint(2, 10)))
brute_force_lowest = a + b
brute_force_calls = 0
brute_force('', a, b)
almost_greedy_calls = 0
almost_greedy_lowest = a + b
almost_greedy('', a, b)
print('%s, %s -> %s vs. %s (%.3f)' % (a, b, brute_force_lowest, almost_greedy_lowest, float(almost_greedy_calls) / brute_force_calls))
if almost_greedy_lowest != brute_force_lowest: print 'ERROR'
One interesting statistic is that this algorithm works about ten times faster then brute force algorithm on average if we limit alphabet to 'ab'.
UPDATE Some optimizations:
def prefix_length(a):
for i in range(len(a)):
if a[i] != a[0]: return i
return len(a)
def almost_greedy(p, a, b):
global almost_greedy_lowest
global almost_greedy_calls
almost_greedy_calls += 1
if p > almost_greedy_lowest: return
if len(a) == 0 and len(b) == 0:
if p < almost_greedy_lowest: almost_greedy_lowest = p
elif len(b) == 0:
almost_greedy(p + a, '', '')
elif len(a) == 0:
almost_greedy(p + b, '', '')
elif a[0] < b[0]:
almost_greedy(p + a[0], a[1:], b)
elif a[0] > b[0]:
almost_greedy(p + b[0], a, b[1:])
else:
la = prefix_length(a)
almost_greedy(p + a[0] * la, a[la:], b)
lb = prefix_length(b)
almost_greedy(p + b[0] * lb, a, b[lb:])

Answer 3

Greedy will solve the problem. to solve this problem you will have to visit both string for sure.
In your code you are missing at one place i.e. your first for loop if(a[i] < b[j]) it should be if(a[i] <= b[j]).
check the code here

Answer 4

Greedy will not give the correct solution and forking will increase the time complexity of the algorithm as you would have to continually revisit the substring that was the same in both strings. Instead, use a dequeue to store the characters that are common, and compare the next char to be chosen from either the deque, or the first string, or the second string
Look at the solution below (replace ints with char from the string, and switch the comparatror signs)
def maxNumber(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:type k: int
:rtype: List[int]
"""
d = deque()
arr = []
i, j = 0, 0
while i < len(nums1) and j < len(nums2):
if len(d) and d[0] > nums1[i] and d[0] > nums2[j]:
arr.append(d.popleft())
else:
if nums1[i] > nums2[j]:
arr.append(nums1[i])
i += 1
elif nums1[i] < nums2[j]:
arr.append(nums2[j])
j += 1
else:
arr.append(nums1[i])
d.append(nums2[j])
i += 1
j += 1
while i < len(nums1):
if len(d) and d[0] > nums1[i]:
arr.append(d.popleft())
else:
arr.append(nums1[i])
i += 1
while j < len(nums2):
if len(d) and d[0] > nums2[j]:
arr.append(d.popleft())
else:
arr.append(nums2[j])
j += 1
while len(d):
arr.append(d.popleft())
return arr