Problem:
Score : 500 points

Problem Statement

You are given a string S consisting of 0 and 1.
Find the maximum integer K not greater than |S| such that we can turn all the characters of S into 0 by repeating the following operation some number of times.

Choose a contiguous segment [l,r] in S whose length is at least K (that is, r-l+1\geq K must be satisfied). For each integer i such that l\leq i\leq r, do the following: if S_i is 0, replace it with 1; if S_i is 1, replace it with 0.

Constraints

1\leq |S|\leq 10^5

S_i(1\leq i\leq N) is either 0 or 1.

Input

Input is given from Standard Input in the following format:

S

Output

Print the maximum integer K such that we can turn all the characters of S into 0 by repeating the operation some number of times.

Sample Input 1

010

Sample Output 1

2

We can turn all the characters of S into 0 by the following operations:

Perform the operation on the segment S[1,3] with length 3. S is now 101.

Perform the operation on the segment S[1,2] with length 2. S is now 011.

Perform the operation on the segment S[2,3] with length 2. S is now 000.

Sample Input 2

100000000

Sample Output 2

8

Sample Input 3

00001111

Sample Output 3

4

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <map>
#include <vector>
#include <deque>
#include <list>
#include <stack>
#include <queue>
#include <algorithm>
#include <iostream>
#include <iterator>

using namespace std;

#if 1
#define PRINT(x) { cout << #x << ": " << (x) << endl; }
#define PRINT_CONTAINER(x)  { cout << #x << ": ";                       \
        for (size_t ix = 0; ix < (x).size(); ++ix) cout << (x)[ix] << ", "; \
        cout << endl; }
#else
#define PRINT(x)
#define PRINT_CONTAINER(x)
#endif


char s[100001];
vector<int> chunks;

#define MAX_LEN 100000
vector<int> bt[MAX_LEN];
int k[MAX_LEN];
int depth;

int dfs()
{
    if (bt[depth].size() == 1) return k[depth - 1];

    int kmax = 0;
    for (int l = 0; l < bt[depth].size(); ++l)
    {
        for (int r = l + 1; r < bt[depth].size() + 1; ++r)
        {
            if (l == 0 && r == bt[depth].size()) continue;
            int k0 = 0;
            for (int i = l; i < r; ++i)
                k0 += bt[depth][i];
            bt[depth + 1] = bt[depth];
            if (r != bt[depth].size())
            {
                bt[depth + 1][r - 1] += bt[depth + 1][r];
                bt[depth + 1].erase(bt[depth + 1].begin() + r);
            }
            if (l != 0)
            {
                bt[depth + 1][l] += bt[depth + 1][l - 1];
                bt[depth + 1].erase(bt[depth + 1].begin() + l - 1);
            }
            // PRINT(depth);
            // PRINT_CONTAINER(bt[depth + 1]);
            if (depth > 0)
                k[depth] = min(k[depth - 1], k0);
            else
                k[depth] = k0;
            ++depth;
            kmax = max(kmax, dfs());
            --depth;
        }
    }
    return kmax;
}

int main(int argc, char *argv[])
{
    scanf("%s", s);
    int n = strlen(s);
    int l = 0;
    char lc = s[0];
    for (int i = 1; i < n; ++i)
    {
        if (s[i] != lc)
        {
            chunks.push_back(i - l);
            l = i;
            lc = s[i];
        }
    }
    chunks.push_back(n - l);
    // if (chunks.size() == 1)
    // {
    //     printf("%d\n", n);
    // }
    // else if (chunks.size() == 2)
    // {
    //     printf("%d\n", max(chunks[0], chunks[1]));
    // }
    // else
    {
        bt[0] = chunks;
        // PRINT_CONTAINER(bt[0]);
        depth = 0;
        k[0] = 0;
        printf("%d\n", dfs());
    }
}