Kingdom of Black and White
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 33 Accepted Submission(s): 17
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.
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.
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
Source
题意:例如000011,有连续为0的子序列长度为4,连续为1的子序列长度为2,所以这段字符串的价值为4*4+2*2=20,女巫最多可以将一个0或1改成1或0,那么把第5个字符1改成0,最后可以得到5*5+1*1=26
例如0101,连续为0的子序列有2段,长度皆为1,连续为1的子序列也是两段,长度皆为1。当前价值为1*1*4=4,把第二个字符改0或者把第三个字符改1可以得到3*3+1*1=10
可以先用结构体把连续的部分的字符和长度记下,然后遍历一遍记录内容,对于每段连续的部分,如果长度大于一,比较改变一个字符对左边和对右边的影响,取能得到的最大价值。如果长度等于1,则要比较原先的和去掉后左右合并的之后的价值,取最大。不用直接模拟,只要计算一下就可以.
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define maxn 100005
#define ll long long
struct node
{
ll flag;
ll len;
}p[maxn];
char s[maxn];
ll max(ll a, ll b)
{
return a>b?a:b;
}
int main()
{
ll up, sum;
int t, n, r, k, len, i;
scanf("%d", &t);
k = 1;
while(t--)
{
scanf("%s", s);
len = strlen(s);
r = 0;
p[r].flag = s[0] - 48;
p[r].len = 1;
for(i = 1;i < len;i++)
{
if(s[i]-48==p[r].flag)
p[r].len++;
else
{
r++;
p[r].flag = s[i]-48;
p[r].len = 1;
}
}
up = 0;
for(i = 0;i <= r;i++)
up += p[i].len*p[i].len;
sum = up;
//printf("--%lld\n", up);
for(i = 0;i <= r;i++)
{
{
if(p[i].len - 1 > 0)//左右选一个
{
if(i - 1 >=0)
{
ll New = (p[i].len-1)*(p[i].len-1)+(p[i-1].len+1)*(p[i-1].len+1);
ll old = (p[i].len)*(p[i].len)+(p[i-1].len)*(p[i-1].len);
up = max(up, sum-old+New);
}
else if(i + 1 <= r)
{
ll New = (p[i].len-1)*(p[i].len-1)+(p[i+1].len+1)*(p[i+1].len+1);
ll old = (p[i].len)*(p[i].len)+(p[i+1].len)*(p[i+1].len);
up = max(up, sum-old+New);
}
}
else //左右全选
{
//printf("%lld\n", up);
ll New = 1;
ll old = (p[i].len)*(p[i].len);
//printf("----%lld %lld\n", New, old);
if(i - 1 >= 0)
{
New += (p[i-1].len);
old += (p[i-1].len)*(p[i-1].len);
}
//printf("--%lld %lld\n", New, old);
if(i + 1 <= r)
{
New += (p[i+1].len);
old += (p[i+1].len)*(p[i+1].len);
}
//printf("%lld\n", New);
up = max(up, sum-old+New*New);
//printf("---%lld\n", up);
}
}
}
printf("Case #%d: %lld\n",k++, up);
}
}