> For the complete documentation index, see [llms.txt](https://protegejj.gitbook.io/algorithm-practice/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://protegejj.gitbook.io/algorithm-practice/leetcode/recursion/761-special-binary-string.md).

# 761 Special Binary String

## 761. [Special Binary String](https://leetcode.com/problems/special-binary-string/description/)

## 1. Question

Special binary strings are binary strings with the following two properties:

The number of 0's is equal to the number of 1's.

Every prefix of the binary string has at least as many 1's as 0's.

Given a special string`S`, amoveconsists of choosing two consecutive, non-empty, special substrings of`S`, and swapping them.(Two strings are consecutive if the last character of the first string is exactly one index before the first character of the second string.)

At the end of any number of moves, what is the lexicographically largest resulting string possible?

**Example 1:**

```
Input: S = "11011000"

Output: "11100100"

Explanation:
The strings "10" [occuring at S[1]] and "1100" [at S[3]] are swapped.
This is the lexicographically largest string possible after some number of swaps.
```

**Note:**

1. `S`has length at most`50`.
2. `S`is guaranteed to be a special binary string as defined above.

## 2. Implementation

**(1) Recursion**

```java
class Solution {
    public String makeLargestSpecial(String S) {
        StringBuilder res = new StringBuilder();
        List<String> vp = new ArrayList();
        int count = 0, startIndex = 0;

        for (int i = 0; i < S.length(); i++) {
            count += S.charAt(i) == '1'? 1 : -1;

            if (count == 0) {
                vp.add("1" + makeLargestSpecial(S.substring(startIndex + 1, i)) + "0");
                startIndex = i + 1;
            }
        }

        Collections.sort(vp, Collections.reverseOrder());

        for (String p : vp) {
            res.append(p);
        }
        return res.toString();
    }
}
```

## 3. Time & Space Complexity

**Recursion:** 时间复杂度O(), 空间复杂度O()