Codeforces - 327A - Flipping Game

最新推荐文章于 2021-07-27 20:52:05 发布

lilongmark

最新推荐文章于 2021-07-27 20:52:05 发布

阅读量3.3k

点赞数

CC 4.0 BY-SA版权

分类专栏： C++ 文章标签： codeforces

本文链接：https://blog.youkuaiyun.com/lilong_dream/article/details/38342205

C++ 专栏收录该内容

18 篇文章

订阅专栏

本文探讨了由Iahub发明的翻转游戏的解决策略，包括输入解析、游戏规则理解、状态变化分析以及实现算法优化。通过分析游戏流程，提出了一种O(N)复杂度的解决方案，并详细阐述了关键步骤及其实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：http://codeforces.com/problemset/problem/327/A

Iahub got bored, so he invented a game to be played on paper.

He writes n integers a1, a2, ..., an. Each of those integers can be either 0 or 1. He's allowed to do exactly one move: he chooses two indices i and j (1 ≤ i ≤ j ≤ n) and flips all values ak for which their positions are in range [i, j] (that is i ≤ k ≤ j). Flip the value of x means to apply operation x = 1 - x.

The goal of the game is that after exactly one move to obtain the maximum number of ones. Write a program to solve the little game of Iahub.

Input

The first line of the input contains an integer n (1 ≤ n ≤ 100). In the second line of the input there are n integers: a1, a2, ..., an. It is guaranteed that each of those n values is either 0 or 1.

Output

Print an integer — the maximal number of 1s that can be obtained after exactly one move.

   Sample test(s)
 
     input
   
5
1 0 0 1 0

     output
   
4

     input
   
4
1 0 0 1

     output
   
4

Note

In the first case, flip the segment from 2 to 5 (i = 2, j = 5). That flip changes the sequence, it becomes: [1 1 1 0 1]. So, it contains four ones. There is no way to make the whole sequence equal to [1 1 1 1 1].

In the second case, flipping only the second and the third element (i = 2, j = 3) will turn all numbers into 1.

分析：

此题转化的比较巧妙，具体如下：（摘自http://codeforces.com/blog/entry/8274）

O(N) method: For achieve this complexity, we need to make an observation. Suppose I flip an interval (it does not matter what interval, it can be any interval). Also suppose that S is the number of ones before flipiing it. What happens? Every time I flip a 0 value, S increases by 1 (I get a new 1 value). Every time I flip a 1 value, S decreases by 1 (I loose a 1 value). What would be the “gain” from a flip? I consider winning “+1” when I get a 0 value and “-1” when I get a 1 value. The “gain” would be simply a sum of +1 and -1. This gives us idea to make another vector b[]. B[i] is 1 if A[i] is 0 and B[i] is -1 if A[i] is 1. We want to maximize S + gain_after_one_move sum. As S is constant, I want to maximize gain_after_one_move. In other words, I want to find a subsequence in b[] which gives the maximal sum. If I flip it, I get maximal number of 1s too. This can be founded trivially in O(N ^ 2). How to get O(N)? A relative experienced programmer in dynamic programming will immediately recognize it as a classical problem “subsequence of maximal sum”. If you never heard about it, come back to this approach after you learn it.

代码：

#include <iostream>

int main()
{
	int n;
	int num[100];
	int a[100];
	std::cin >> n;

	int count = 0;
	for(int i = 0; i < n; ++i)
	{
		std::cin >> num[i];
		if(num[i] == 1)
		{
			a[i] = -1;
			++count;
		}
		else
		{
			a[i] = 1;
		}
	}

	int max = -2;  // less than -1 is ok
	int sum = 0;
	for(int i = 0; i < n; ++i)
	{
		sum += a[i];

		if(sum > max)
		{
			max = sum;
		}

		if(sum < 0)
		{
			sum = 0;
		}
	}

	std::cout << max + count << std::endl;

	return 0;
}

感谢阅读！