Codeforces Round #652 (Div. 2) #B. AccurateLee

B. AccurateLee

time limit per test2 seconds memory limit per test256 megabytes input:standard input output:standard output

Lee was cleaning his house for the party when he found a messy string under the carpets. Now he’d like to make it clean accurately and in a stylish way.

The string s he found is a binary string of length n (i. e. string consists only of 0-s and 1-s).

In one move he can choose two consecutive characters $s_i$ and $s_{i+1}$, and if $s_i$ is 1 and $s_{i+1}$ is 0, he can erase exactly one of them (he can choose which one to erase but he can’t erase both characters simultaneously). The string shrinks after erasing.

Lee can make an arbitrary number of moves (possibly zero) and he’d like to make the string s as clean as possible. He thinks for two different strings x and y, the shorter string is cleaner, and if they are the same length, then the lexicographically smaller string is cleaner.

Now you should answer t test cases: for the $i$-th test case, print the cleanest possible string that Lee can get by doing some number of moves.

Small reminder: if we have two strings x and y of the same length then x is lexicographically smaller than y if there is a position $i$ such that $x_1=y_1,x_2=y_2,...,x_{i-1}=y_{i-1}and{x}_i<y_i$.

Input

The first line contains the integer t ($1\le t\le 10^4$) — the number of test cases.

Next 2t lines contain test cases — one per two lines.

The first line of each test case contains the integer n ($1\le n\le 10^5$) — the length of the string s.

The second line contains the binary string s. The string s is a string of length n which consists only of zeroes and ones.

It’s guaranteed that sum of n over test cases doesn’t exceed $10^5$.

Output

For each polygon, print ‘YES’ if it’s beautiful or NO otherwise (case insensitive).

Example

• Input:
  5
  10
  0001111111
  4
  0101
  8
  11001101
  10
  1110000000
  1
  1

• Output:
  0001111111
  001
  01
  0
  1

  该题让你将给定0-1字符串改写成最简形式（字符串长度最短，如果有多种条件使得字符串长度相同，则取字典序最小的结果。），仅有10形式的字符串可以任意去掉0或1。所以，我们可以观察到，最左边的0和最右边的1都是无法删去的。在此，我们可以把字符串分成三类来讨论。

• 1、全部为$0$或者$1$的序列，无法删去任何一个字符，直接输出即可。
• 2、形如$000011111$的序列，左边全为$0$，右边全为1，也可以直接输出。
• 3、在字符串中既包含$0$，又包含$1$的序列。由于该字符串中至少包含一个$0$和一个$1$，故可以推出，最右边的$0$左边的$1$皆可消去，最左边的$1$右边所有$0$均可消去。我们可以将字符串$s$拆分成三部分：
  • （1）最左边的1左边的所有0；
  • （2）最左边的1~最右边的0之间的所有字符；
  • （3）最右边的0右边的所有1；

  我们可以得到，结果字符串为第一部分和第三部分拼接而成。而中间的以1开头，0结尾的字符串都可以消去，最终可以只剩下一个0或者一个1；由于结果要按照字典序排布，故取剩下的那个0；

代码如下：

#include<iostream>
using namespace std;
void solve();
int main()
{
    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}
void solve()
{
    char* s;
    int n;
    cin >> n;
    s = new char[n + 1];
    cin >> s;
    int c0 = 0, c1 = 0;
    for (int i = 0; i < n; i++)
    {
        if (s[i] == '0')c0++;
        else c1++;
    }
    if (c1 == 0 || c0 == 0) cout << s << endl;
    else {
        int postlast = 0, postfirst = -1;
        int i0 = 0;
        while (s[i0] == '0') {
            postfirst++;
            i0++;
        }
        for (int i = n - 1; i >= 0; i--)
        {
            if (s[i] == '0') {
                postlast = i;
                break;
            }
        }
        if (postfirst >= postlast) {
            cout << s << endl;
        }
        else {
            for (int i = 0; i <= postfirst; i++)
                cout << s[i];
            for (int i = postlast; i < n; i++)
                cout << s[i];
            cout << endl;
        }
    }
}

  该题思路不算复杂，但是需要注意的就是中间只要时1开头，0结尾的所有字符串都是可以消去，达到最简形式的，根据字典序排布，都可以变成0；但是不能只着眼于中间某一段，有可能你将前面消去了之后反而使后面的0无法消去，从而造成得到的字符串不是最简字符串的形式。