hdu5583

Kingdom of Black and White

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 2718 Accepted Submission(s): 846

Problem Description
In the Kingdom of Black and White (KBW), there are two kinds of frogs: black frog and white frog.

Now N frogs are standing in a line, some of them are black, the others are white. The total strength of those frogs are calculated by dividing the line into minimum parts, each part should still be continuous, and can only contain one kind of frog. Then the strength is the sum of the squared length for each part.

However, an old, evil witch comes, and tells the frogs that she will change the color of at most one frog and thus the strength of those frogs might change.

The frogs wonder the maximum possible strength after the witch finishes her job.

Input
First line contains an integer T, which indicates the number of test cases.

Every test case only contains a string with length N, including only 0 (representing
a black frog) and 1 (representing a white frog).

⋅ 1≤T≤50.

⋅ for 60% data, 1≤N≤1000.

⋅ for 100% data, 1≤N≤105.

⋅ the string only contains 0 and 1.

Output
For every test case, you should output “Case #x: y”,where x indicates the case number and counts from 1 and y is the answer.

Sample Input
2
000011
0101

Sample Output
Case #1: 26
Case #2: 10

题意：给你一个0，1串，这个串的力量定义为所有连续的0，或1的字串的长度的平方和，比如，000111 的力量为3^2 + 3^2,0011011 的力量为2^2 + 2^2 + 1^2 + 2^2,然后给你一个串，你可以最多一次把里面的0变成1或者1变成0，让你求出这个串的最大力量。

解题思路：首先最多只能改变一个位置的值，我门可以想到枚举，我们可以发现，枚举一个连续串的中间的位置肯定无意义，所以我们只需要枚举交界处的位置就行，要注意的是可能会出现长度为1的字串，把这个字串改变之后会导致三个字串连起来。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 10;
int N;
char s[maxn];
ll a[maxn];
int cnt;
int main()
{
    int T;
    scanf("%d",&T);
    for(int j = 1; j <= T; j++)
    {
        scanf("%s",s);
        int N = strlen(s);
        ll sum = 0;
        int last = 0;
        cnt = 1;
        memset(a,0,sizeof(a));
        for(int i = 0; i < N; i++)
        {
            if(s[i] == s[last])
            {
                a[cnt]++;
            }
            else
            {
                cnt++;
                last = i;
                i--;
            }
        }
        for(int i = 1; i <= cnt; i++)
        {
            sum += a[i]*a[i];
        }
        ll Max = sum;
        ll ans1,ans2;
        for(int i = 1; i <= cnt; i++)
        {
            if(i == 1)
            {
                if(cnt == 2)
                {
                    ans1 = sum - a[1]*a[1] - a[2]*a[2];
                    ans1 += (a[1] - 1)*(a[1] - 1) + (a[2] + 1)*(a[2] + 1);
                    Max = max(Max,ans1);
                    ans2 = sum - a[1]*a[1] - a[2]*a[2];
                    ans2 += (a[1] + 1)*(a[1] + 1) + (a[2] - 1)*(a[2] - 1);
                    Max = max(Max,ans2);
                }
                else if(cnt > 2)
                {
                    ans1 = sum - a[1]*a[1] - a[2]*a[2];
                    ans1 += (a[1] - 1)*(a[1] - 1) + (a[2] + 1)*(a[2] + 1);
                    Max = max(Max,ans1);
                    if(a[2] == 1)
                    {
                        ans2 = sum - a[1]*a[1] - a[2]*a[2] - a[3]*a[3];
                        ans2 += (a[1] + a[2] + a[3])*(a[1] + a[2] + a[3]);
                        Max = max(Max,ans2);
                    }
                    else
                    {
                        ans2 = sum - a[1]*a[1] - a[2]*a[2];
                        ans2 += (a[1] + 1)*(a[1] + 1) + (a[2] - 1)*(a[2] - 1);
                        Max = max(Max,ans2);
                    }
                }


            }
            else if(i == cnt)
            {
                if(cnt == 2)
                {
                    ans1 = sum - a[cnt]*a[cnt] - a[cnt - 1]*a[cnt - 1];
                    ans1 += (a[cnt] - 1)*(a[cnt] - 1) + (a[cnt - 1] + 1)*(a[cnt - 1] + 1);
                    Max = max(Max,ans1);
                    ll ans2 = sum - a[cnt]*a[cnt] - a[cnt - 1]*a[cnt - 1];
                    ans2 += (a[cnt] + 1)*(a[cnt] + 1) + (a[cnt - 1] - 1)*(a[cnt - 1] - 1);
                    Max = max(Max,ans2);
                }
                else if(cnt > 2)
                {
                    ans1 = sum - a[cnt]*a[cnt] - a[cnt - 1]*a[cnt - 1];
                    ans1 += (a[cnt] - 1)*(a[cnt] - 1) + (a[cnt - 1] + 1)*(a[cnt - 1] + 1);
                    Max = max(Max,ans1);
                    if(a[cnt - 1] == 1)
                    {
                        ll ans2 = sum - a[cnt]*a[cnt] - a[cnt - 1]*a[cnt - 1] - a[cnt - 2]*a[cnt - 2];
                        ans2 += (a[cnt] + a[cnt - 1] + a[cnt - 2])*(a[cnt] + a[cnt - 1] + a[cnt - 2]);
                        Max = max(ans2,Max);
                    }
                    else
                    {
                        ll ans2 = sum - a[cnt]*a[cnt] - a[cnt - 1]*a[cnt - 1];
                        ans2 += (a[cnt] + 1)*(a[cnt] + 1) + (a[cnt - 1] - 1)*(a[cnt - 1] - 1);
                        Max = max(Max,ans2);
                    }
                }
            }
            else
            {
                ans1 = sum - a[i]*a[i] - a[i + 1]*a[i + 1];
                ans1 += (a[i] + 1)*(a[i] + 1) + (a[i + 1] - 1)*(a[i + 1] - 1);
                Max = max(Max,ans1);
                ans1 = sum - a[i]*a[i] - a[i + 1]*a[i + 1];
                ans1 += (a[i] - 1)*(a[i] - 1) + (a[i + 1] + 1)*(a[i + 1] + 1);
                Max = max(Max,ans1);
                if(a[i + 1] == 1&&i + 2 <= cnt)
                {
                    ans1 = sum - a[i]*a[i] - a[i + 1]*a[i + 1] - a[i + 2]*a[i + 2];
                    ans1 += (a[i] + a[i + 1] + a[i + 2])*(a[i] + a[i + 1] + a[i + 2]);
                    Max = max(Max,ans1);
                }

            }
        }
        printf("Case #%d: %lld\n",j,Max);
    }
    return 0;
}