[LeetCode 984] String Without AAA or BBB

Given two integers A and B, return any string S such that:

• S has length A + B and contains exactly A 'a' letters, and exactly B 'b' letters;
• The substring 'aaa' does not occur in S;
• The substring 'bbb' does not occur in S.

 

Example 1:

Input: A = 1, B = 2
Output: "abb"
Explanation: "abb", "bab" and "bba" are all correct answers.

Example 2:

Input: A = 4, B = 1
Output: "aabaa"

 

Note:

1. 0 <= A <= 100
2. 0 <= B <= 100
3. It is guaranteed such an S exists for the given A and B.

 

Solution 1. DFS

 

The naive solution is to use dfs to search one correct answer. 

1. if counts of a > 0, pick a and search recursively to find an answer. If there is one, return true, else backtrack.

2. At this point, either counts of a == 0 or picking a does not generate a correct answer. If counts of b > 0, we repeat step 1 by picking b. If there is no correct answer, backtrack.

3. If we've exhausted both options(either pick a or b) but still do not find a correct answer, it means we must backtrack to previous recursive calls. So return false.

 

Recurisve call termination condition: First check if there is aaa or bbb when the current string's length >= 3 and return false if there is. Then check if we've used all a and b, if we have, return true.

 

The runtime of this solution is O(2^(A + B)) in the worst case.  The space complexity is O(A+B) for constructing the result string and A + B possible call stacks.

class Solution {
    private String ans = null;
    public String strWithout3a3b(int A, int B) {
        int[] counts = new int[2];
        counts[0] = A;
        counts[1] = B;
        dfs(counts, new StringBuilder());
        return ans;
    }
    private boolean dfs(int[] counts, StringBuilder sb) {
        if(sb.length() >= 3) {
            String sub = sb.substring(sb.length() - 3);
            if(sub.equals("aaa") || sub.equals("bbb")) {
                return false;
            }
        }
        if(counts[0] == 0 && counts[1] == 0) {
            return true;
        }
        //if there are a available, try pick a first
        if(counts[0] > 0) {
            sb.append('a');
            counts[0]--;
            if(dfs(counts, sb)) {
                ans = sb.toString();
                return true;
            }
            sb.deleteCharAt(sb.length() - 1);
            counts[0]++;
        }
        //if using a does not work, or there are no a, pick b
        if(counts[1] > 0) {
            sb.append('b');
            counts[1]--;
            if(dfs(counts, sb)) {
                ans = sb.toString();
                return true;
            }
            sb.deleteCharAt(sb.length() - 1);
            counts[1]++; 
        }
        //both options are explored with no right answer, return false to backtrack
        return false;
    }
}

 

Solution 2. Greedy 

Solution 1 is very inefficient in finding any correct answer. It is suited for finding all possible correct answers. We can use the following greedy algorithm.

At any step, pick the more common character as long as it does not generate subtring aaa or bbb. If the previous two characters are both a, then we have to pick b, vice versa. 

The runtime is O(A + B) with space complexity of O(A + B) as well. This greedy algorithm is correct since there is at least one correct answer. Even if we loose the problem condition to possibly not have any right answers, this algorithm will still work with a small modification. For a and b,  if max(count(a), count(b)) > (1 + min(count(a), count(b))) * 2,  there would be no right answers.

class Solution {
    public String strWithout3a3b(int A, int B) {
        StringBuilder sb = new StringBuilder();
        while(A > 0 || B > 0) {
            if(sb.length() < 2 || sb.charAt(sb.length() - 1) != sb.charAt(sb.length() - 2)) {
                if(A >= B) {
                    sb.append('a');
                    A--;
                }
                else {
                    sb.append('b');
                    B--;
                }
            }
            else if(sb.charAt(sb.length() - 1) == 'a') {
                sb.append('b');
                B--;
            }
            else {
                sb.append('a');
                A--;
            }
        }
        return sb.toString();
    }
}