洛谷P2630 题解

最新推荐文章于 2021-09-23 21:04:11 发布
最新推荐文章于 2021-09-23 21:04:11 发布
阅读量164 收藏
点赞数
原文链接：http://www.cnblogs.com/nth-element/p/10604318.html
版权

我先讲一下我的思路

  1. 将A，B，C，D四种操作用函数储存起来；

  2. 枚举所有可能出现的情况：A,B,C,D,AA,AB,AC,AD,BB,BC,BD,CC,CD,DD,ABC,ABD,ACD,BCD,ABCD共19种情况；(这里面一定有遗漏的点，但由于数据太水,所以没有一一列出来)

  3. 对初始矩阵进行上面枚举的操作，如果操作后与最终矩阵相同，便直接输出所对应的枚举的操作；

  4. 如果此时还没有结束程序（即所有操作都枚举完之后，皆不符合最终矩阵），就直接输出“Poland cannot into space!!!”

这是我的局部程序

1.A的操作函数：

int A_operation()
{
    memset(c,0,sizeof(c));//由于要多次用这个转换数组，所以必须清零 
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            c[i][j]=a[3-j+1][i];//按照题目要求进行操作 
        }
    }
    memcpy(a,c,sizeof(a));//将c这个中间 数组里的值拷贝到a数组中 
}

可以看到这里我用了memset和memcpy这两个函数：

memset 是内存赋值函数，比用for来赋值快很多，只是只能赋值常量；

用法：memset（数组名，常量，sizeof（数组名）） ；

memcpy 是内存赋值函数，将一个数组里的值复制到另一个数组中

用法：memcpy（目标数组名，被复制函数名，sizeof（被复制函数名））

2.枚举的操作情况：

memcpy(a,b,sizeof(a));//因为a的值会多次改变，所以b是输入的初始数组，要在每一次枚举的操作后，将a覆盖 
flag=1;//标志，判断是否成功 
A_operation();
A_operation();//进行操作 
for(int i=1;i<=3;i++)
{
    for(int j=1;j<=3;j++)
    {
        if(a[i][j]!=d[i][j])//假如有一个不相同，就跳出循环 
        {
            flag=0;//失败 
            goto p;//跳出循环 
        }
    }
}
p:
if(flag==1)//假如没有失败 
{
    printf("AA");//输出操作 
    return 0; //结束程序 
}

这里有一个新的跳出循环的方法，goto语句（我也是才学的）

这个语句与break,continue,return等语句的区别是：

break是跳出一层循环，continue是跳过本次循环，return是结束程序||函数，而goto则是想怎么跳就怎么跳（是不是有点心动了~~~）

用法：goto 语句名

语句名：（要跳到的地方）

直接上程序

#include<bits/stdc++.h>
using namespace std;
int a[4][4],b[4][4],c[4][4],d[4][4];
int flag=1;    
int A_operation()
{
    memset(c,0,sizeof(c));
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            c[i][j]=a[3-j+1][i];
        }
    }
    memcpy(a,c,sizeof(a)); 
}
int B_operation()
{
    memset(c,0,sizeof(c));
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            c[i][j]=a[j][3-i+1];
        }
    }
    memcpy(a,c,sizeof(a));
}

int C_operation()
{
    memset(c,0,sizeof(c));
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            c[i][j]=a[i][3-j+1];
        }
    }
    memcpy(a,c,sizeof(a));
}
int D_operation()
{
    memset(c,0,sizeof(c));
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            c[i][j]=a[3-i+1][j];
        }
    }
    memcpy(a,c,sizeof(a));
}
int main()
{
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            scanf("%d",&b[i][j]);
        }
    }
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            scanf("%d",&d[i][j]);
        }
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    A_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto a;
            }
        }
    }
    a:
    if(flag==1)
    {
        printf("A");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    B_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto b;
            }
        }
    }
    b:
    if(flag==1)
    {
        printf("B");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    C_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto c;
            }
        }
    }
    c:
    if(flag==1)
    {
        printf("C");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    D_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto d;
            }
        }
    }
    d:
    if(flag==1)
    {
        printf("D");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    A_operation();
    A_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto p;
            }
        }
    }
    p:
    if(flag==1)
    {
        printf("AA");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    A_operation();
    B_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto e;
            }
        }
    }
    e:
    if(flag==1)
    {
        printf("AB");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    A_operation();
    C_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto f;
            }
        }
    }
    f:
    if(flag==1)
    {
        printf("AC");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    A_operation();
    D_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto g;
            }
        }
    }
    g:
    if(flag==1)
    {
        printf("AD");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    B_operation();
    B_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto q;
            }
        }
    }
    q:
    if(flag==1)
    {
        printf("BB");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    B_operation();
    D_operation();          
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto h;
            }
        }
    }
    h:
    if(flag==1)
    {
        printf("BD");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    C_operation();
    B_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto i;
            }
        }
    }
    i:
    if(flag==1)
    {
        printf("BC");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    C_operation();
    C_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto r;
            }
        }
    }
    r:
    if(flag==1)
    {
        printf("CC");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    C_operation();
    D_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto j;
            }
        }
    }
    j:
    if(flag==1)
    {
        printf("CD");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    D_operation();
    D_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto s;
            }
        }
    }
    s:
    if(flag==1)
    {
        printf("DD");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    A_operation();
    B_operation();
    C_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto k;
            }
        }
    }
    k:
    if(flag==1)
    {
        printf("ABC");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    A_operation();
    D_operation();
    C_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto l;
            }
        }
    }
    l:
    if(flag==1)
    {
        printf("ACD");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    A_operation();
    B_operation();
    D_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto m;
            }
        }
    }
    m:
    if(flag==1)
    {
        printf("ABD");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    D_operation();
    B_operation();
    C_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto n;
            }
        }
    }
    n:
    if(flag==1)
    {
        printf("BCD");
        return 0;
    }
    memcpy(a,b,sizeof(a));
    flag=1;
    A_operation();
    D_operation();
    B_operation();
    C_operation();
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(a[i][j]!=d[i][j])
            {
                flag=0;
                goto o;
            }
        }
    }
    o:
    if(flag==1)
    {
        printf("ABCD");
        return 0;
    }
    printf("Poland cannot into space!!!");//假如上面枚举的情况都不行，就输出（对应4）
    return QWQ
}

转载于:https://www.cnblogs.com/nth-element/p/10604318.html

au1025
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
洛谷P1724题解（请不要抄袭！）
06-17
洛谷P1427题解，若要复制or下载，请与我联系，如要改编，也请联系，若发现未经我同意的复制、下载、改编，直接举报。
C memset() 函数
qq_26036173的博客
07-04 1813
函数原型： void  *memset(void  *s, int  ch, size_t  n);参数说明:  s : 指针、数组、结构体的地址                   ch:赋给s 的值，                   n: 是 s 的长度功能 :                   将s所指向的某一块内存中前n 个字节 设置为ch 。          struct{   ...
快速理解C++中的sizeof和memset
Yuta233的博客
01-14 1256
sizeof是C/C++中的一个操作符（operator），简单的说其作用就是返回一个对象或者类型所占的内存字节数。 它可以这么用： #include #include using namespace std; int main() { char c; char* c0; char c1[4]; int a0; int a1[10]; int* a2; int* a3=new int[1
P2630 图像变换 恶心的模拟题
qq_54575190的博客
09-23 205
题目描述 给定33行33列的图像各像素点灰度值，给定最终图像，求最短、字典序最小的操作序列。 其中，可能的操作及对应字符有如下四种： A：顺时针旋转9090度； B：逆时针旋转9090度； C：左右翻转； D：上下翻转。 输入格式 一个矩阵，表示初始的图像。 一个矩阵，表示最终的图像。 输出格式 最短、字典序最小的操作序列，保证长度不超过10^8108，不保证有解。 若长度不超过10^8108无解则输出Poland cannot into space!!!。...
C语言中memset函数详解(很清晰易懂）
PengPengBlog的博客
09-20 5万+
功 能: 将s所指向的某一块内存中的每个字节的内容全部设置为ch指定的ASCII值, 　　块的大小由第三个参数指定,这个函数通常为新申请的内存做初始化工作 　　用 法: void *memset(void *s, char ch, unsigned n); 　　程序例: 　　#include 　　#include 　　#include 　　int
memset()函数及其作用
ypb——奋斗之路
05-11 5万+
1. memset()函数原型是extern void *memset(void *buffer, int c, int count)        buffer：为指针或是数组,               c：是赋给buffer的值,        count：是buffer的长度.        这个函数在socket中多用于清空数组.如:原型是memset(buffer, 0,
洛谷题解：P1421-小玉买文具
最新发布
04-16
《洛谷题解：P1421-小玉买文具》是一道典型的编程入门题，主要考察编程者对于C++顺序结构编程的理解和应用。题目描述的是一个简单的数学问题，即小玉要用不超过某金额去购买文具，每件文具的价格是19分，问最多可以...
洛谷题解：P1001-A+B Problem
04-16
洛谷题解：P1001-A+B Problem主要涉及到知识点包括C++程序设计基础、程序输入输出操作、C++标准库的使用、位运算和C++编译预处理指令。 1. C++程序设计基础： - C++是编译型语言，需要编译成机器语言后才能运行。 ...
洛谷题解：P1425-小鱼的游泳时间
04-16
知识点: 1. C++程序结构：C++程序...整体上，本题解涉及到C++编程的基础知识点，如数据类型、函数、控制流、位运算、输入输出以及标准库的使用。通过对程序的阅读和理解，可以加深对C++编程顺序结构和基础语法的掌握。
洛谷P1002 过河卒题解
01-21
题意理解：在棋盘左上角标记为（0,0）的位置有卒，并使它走到指定位置，在棋盘另一指定位置有马，卒不能经过马以及马的控制点，求卒走到指定位置的走法总数？ 解题思路： 1.把整个棋盘看成一个二维数组，首先判断马...
解释memset(a,'0',sizeof(a)); 的意思
芳芳呀的博客
07-25 8万+
memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法。 这条语句是把a中所有字节换做字符“0”，常用来对指针或字符串的初始化。 函数原型如下： void *memset(void *s, int ch, size_t n); 函数解释：将s中前n个字节 （typedef unsigned int size_t）用 ch 替换并返回 s将ch设置...
C++--memset与sizeof
chaoshengmingyue的博客
06-29 2252
memset、sizeof
c/c++中memset的问题 以及memset和sizeof的关系
dirtyman_的博客
09-09 1189
今天在写hduoj-2062 号题目的时候参照了https://blog.csdn.net/wyg1997/article/details/51223475（纯0-1背包问题）的方法，我自己写完，测试完成（数据量比较小）之后，就提交了，结果WA。 自己对比原博主的逻辑之后，觉得的逻辑没有任何问题，代码也 没有问题，然后cp了下博主的代码提交了，结果AC了。 然后我仔细对比了我自己写的和原博主写...
C语言中的memset()
Don't rush and never settle. If it's meant to be, it will be.
09-11 1294
在C语言中定义了一个整型的数组或者是其他类型的数组，它们的默认数值是随机的，不像java有固定的默认值，但是在C语言中提供了一个memset()函数，它定义正在string.h中，可以帮助我们完成数组的初始化操作。 例如：#include<cstdio> #include<cstring> using namespace std;int main() { int a[10]; ch
memset函数详细说明
热门推荐
VC++/MFC的专栏
06-05 12万+
1。void *memset(void *s,int c,size_t n)总的作用：将已开辟内存空间 s 的首 n 个字节的值设为值 c。2。例子＃includevoid main(){char *s="Golden Global View";clrscr();memset(s,G,6);printf("%s",s);getchar();return 0;}　3。memset() 函数常用于
memset函数详解
qq_30445397的博客
06-05 5万+
memset函数详解 memset函数为初始化函数，可以将一段连续的内存初始化为某个值。 但它是以字节为单位进行初始化的。 memset函数的一般使用格式为 memset(首地址,值,sizeof(地址总大小)); 比如对数组a赋值 memset(a,0,sizeof(a)); 重点 memset以字节为单位进行初始化，这句话是什么意思呢？就是说它进行初始化时并不关心你要初始化的数组是什么类型的，它均以字节为单位进行初始化。 比如你的数组是int型的。int为4字节。但是memset以字节进行初始化 m
洛谷P2630 图像变换--BFS
weixin_43918046的博客
09-11 328
题目描述 给定3行3列的图像各像素点灰度值，给定最终图像，求最短、字典序最小的操作序列。 其中，可能的操作及对应字符有如下四种： A：顺时针旋转90度； B：逆时针旋转90度； C：左右翻转； D：上下翻转。 输入格式 一个矩阵，表示初始的图像。 一个矩阵，表示最终的图像。 输出格式 最短、字典序最小的操作序列，保证长度不超过100000000，不保证有解（若长度不超过 100000000无解则输...
洛谷p5715题解c语言
10-30
这道题是洛谷上的一道简单的排序题目，要求输入三个整数，然后按照从大到小的顺序输出这三个数。这里提供了三种不同的C++代码实现方法，其中第一种方法使用了C++标准库algorithm中的sort函数，第二种方法是第一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值