标签：607 ch return s2 s1 Beingawesomeism Div include bz

题目大意

给出一个 r × c r\times c r×c的矩阵，
每次可以利用图中的一个 1 × d 1\times d 1×d或者 d × 1 d\times 1 d×1的子矩阵，并用其向一个方向（上下左右）移动，并用这个子矩阵的值来覆盖其的经过的地方。
问最少需要多少次才能让整个矩阵相同。

时间限制

2s

数据范围

r , c ≤ 60 r,c\le60 r,c≤60

题解

不难发现最多只需要 4 4 4，具体如下：
1.选定一个格子 ( x 0 , y 0 ) \pod{x_0,y_0} (x0​,y0​)，并用其向左覆盖，直到左边界。
2.继续用格子 ( x 0 , y 0 ) \pod{x_0,y_0} (x0​,y0​)向右覆盖，直到右边界。
3.现在已经得到了一行完全相同的，用这一行向上覆盖，直到上边界。
4.继续用这行向下覆盖，直到下边界。

如何减少所需要的步数呢？
假设选取的格子 ( x 0 , y 0 ) \pod{x_0,y_0} (x0​,y0​)在边界上，那么显然它可以节省一次。

假设选取的格子 ( x 0 , y 0 ) \pod{x_0,y_0} (x0​,y0​)恰好在角落，或者已经有现成的一行（列）相同的话，那么就仅仅需要两次。

如果现成相同的行（列）恰好在边界上，那么仅仅需要一次。

这题没有什么难度，但分类讨论需要注意细节。

Code

//#pragma GCC optimize (2)
//#pragma G++ optimize (2)
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <iostream>
#include <vector>
#include <queue>
#define G getchar
#define ll long long
using namespace std;

ll read()
{
    char ch;
    for(ch = G();(ch < '0' || ch > '9') && ch != '-';ch = G());
    ll n = 0 , w;
    if (ch == '-')
    {
        w = -1;
        ch = G();
    } else w = 1;
    for(;'0' <= ch && ch <= '9';ch = G())n = (n<<1)+(n<<3)+ch-48;
    return n * w;
}

const int N = 63;
bool bz[N][N];
int flag;
int n , m , s1[N] , s2[N];
char ch;

bool pd1()
{
    return (s1[1] == m) || (s1[n] == m) || (s2[1] == n) || (s2[m] == n);
}

bool pd3()
{

    return s1[1] || s1[n] || s2[1] || s2[m];
}

bool pd2()
{
    for (int i = 2 ; i < n; i++)
        if (s1[i] == m) return 1;

    for (int i = 2 ; i < m ; i++)
        if (s2[i] == n) return 1;

    return bz[1][1] || bz[1][m] || bz[n][1] || bz[n][m];
}

int main()
{
    //freopen("a.in","r",stdin);
    //freopen("a.out","w",stdout);

    for (int t = read() ; t ; t--)
    {
        n = read();
        m = read();
        flag = 0;
        memset(s1 , 0 , sizeof(s1));
        memset(s2 , 0 , sizeof(s2));
        for (int i = 1 ; i <= n ; i++)
        {
            for (ch = G() ; ch != 'A' && ch !='P' ; ch = G());
            for (int j = 1 ; j <= m ; j++)
            {
                if (ch == 'A')
                {
                    bz[i][j] = 1;
                    flag++;
                    s1[i]++;
                    s2[j]++;
                } else bz[i][j] = 0;
                ch = G();
            }
        }

        if (flag == 0)
        {
            puts("MORTAL");
            continue;
        }

        if (flag == n * m)
        {
            puts("0");
            continue;
        }

        if (pd1())
        {
            puts("1");
            continue;
        }

        if (pd2())
        {
            puts("2");
            continue;
        }

        if(pd3())
        {
            puts("3");
            continue;
        }

        puts("4");

    }
    
    return 0;
}

标签：607,ch,return,s2,s1,Beingawesomeism,Div,include,bz
来源： https://blog.csdn.net/lijf2001/article/details/119054641

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。