hdu 4146 Flip Game【思维+暴力】

最新推荐文章于 2019-09-04 09:03:29 发布

原创最新推荐文章于 2019-09-04 09:03:29 发布 · 704 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#hdu 4146 #杭电 4146

思维同时被 2 个专栏收录

692 篇文章

订阅专栏

模拟

75 篇文章

订阅专栏

本文探讨了FlipGame的游戏规则及解决策略，通过分析输入数据并应用特定算法优化，实现快速计算翻转后白色棋子的数量。介绍了暴力解法与更高效的标记法，通过实例演示了如何将复杂度降低，从而提高解决方案的效率。

Flip Game

Time Limit: 15000/5000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 1839 Accepted Submission(s): 604

Problem Description

Flip game is played on a square N*N field with two-sided pieces placed on each of its N^2 squares. One side of each piece is white and the other one is black and each piece is lying either it's black or white side up. The rows are numbered with integers from 1 to N upside down; the columns are numbered with integers from 1 to N from the left to the right. Sequences of commands (x_i, y_i) are given from input, which means that both pieces in row x_i and pieces in column y_i will be flipped (Note that piece (x_i, y_i) will be flipped twice here). Can you tell me how many white pieces after sequences of commands?
Consider the following 4*4 field as an example:

bwww
wbww
wwbw
wwwb

Here "b" denotes pieces lying their black side up and "w" denotes pieces lying their white side up.
Two commands are given in order: (1, 1), (4, 4). Then we can get the final 4*4 field as follows:

bbbw
bbwb
bwbb
wbbb

So the answer is 4 as there are 4 white pieces in the final field.

Input

The first line contains a positive integer T, indicating the number of test cases (1 <= T <= 20).
For each case, the first line contains a positive integer N, indicating the size of field; The following N lines contain N characters each which represent the initial field. The following line contain an integer Q, indicating the number of commands; each of the following Q lines contains two integer (x_i, y_i), represent a command (1 <= N <= 1000, 0 <= Q <= 100000, 1 <= x_i, y_i <= N).

Output

For each case, please print the case number (beginning with 1) and the number of white pieces after sequences of commands.

Sample Input
2
4
bwww
wbww
wwbw
wwwb
2
1 1
4 4
4
wwww
wwww
wwww
wwww
1
1 1

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

暴力敲了两发觉得5000ms时间已经放的很宽了，差不多能过，但是5000ms总归扛不住20*10^8的复杂度。

正确思路：标记上第i行有多少次flip，标记上第i列有多少次flip。然后遍历行和列，对于第i行操作为奇数的情况，直接相当于操作一次，对于操作为偶数的情况，直接相当于没有操作过，这样模拟就从20*10^8变成了20*3*10^6，是一定能过了的。

AC代码：

#include<stdio.h>
#include<string.h>
using namespace std;
char a[1005][1005];
int col[1005];
int row[1005];
int main()
{
    int t;
    int kase=0;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        memset(row,0,sizeof(row));
        memset(col,0,sizeof(col));
        for(int i=1;i<=n;i++)
        {
            scanf("%s",a[i]+1);
        }
        int q;
        scanf("%d",&q);
        while(q--)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            row[x]++;
            col[y]++;
        }
        for(int i=1;i<=n;i++)
        {
            if(row[i]%2==0)continue;
            else
            {
                for(int j=1;j<=n;j++)
                {
                    if(a[i][j]=='w')a[i][j]='b';
                    else  a[i][j]='w';
                }
            }
        }
        for(int i=1;i<=n;i++)
        {
            if(col[i]%2==0)continue;
            else
            {
                for(int j=1;j<=n;j++)
                {
                    if(a[j][i]=='w')a[j][i]='b';
                    else  a[j][i]='w';
                }
            }
        }
        int output=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(a[i][j]=='w')output++;
            }
        }
        printf("Case #%d: %d\n",++kase,output);
    }
}