ZOJ 2610 Puzzle 模拟

最新推荐文章于 2020-12-17 05:06:13 发布
最新推荐文章于 2020-12-17 05:06:13 发布
阅读量1k 收藏
点赞数
分类专栏： 暴力/模拟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ck_boss/article/details/40213147
版权


大模拟：枚举6个方向，检查每个0能否移动


Puzzle
Time Limit: 2 Seconds       Memory Limit: 65536 KB

Little Georgie likes puzzles very much. Recently he has found a wooden triangle in the box with old toys. The side of the triangle is n inches long. The triangle is divided into n2unit triangles with lines drawn on his surface.

The interesting fact about that triangle is that it is not solid - it consists of two parts. Each of the parts is a connected set of unit triangles. Georgie has put his triangle onto the table and now wonders whether he can separate the parts. He wants to separate them without taking any part of the triangle off the table, just moving the parts by the table surface. The triangle has a small but non-zero thickness, so while being moved the parts must not intersect.

For example, if the triangle is divided into parts as it is shown on the top picture below, Georgie can separate the parts the way he wants. However in the case displayed on the bottom picture, he cannot separate the parts without lifting one of them.

Help Georgie to determine whether he can separate the parts moving them by the surface of the table.

<img src="http://acm.zju.edu.cn/onlinejudge/showImage.do?name=0000%2F2610%2Fg.gif" <="" img=""><img src="http://acm.zju.edu.cn/onlinejudge/showImage.do?name=0000%2F2610%2Fg2.gif" <="" img="">
Two puzzles corresponding the samples

Input

Input file contains one or more testcases. The first line of each testcase contains n (2 <= n <= 50). Next n lines contain the description of the triangle, i-th of these lines contains 2i - 1 characters, describing unit triangles in the i-th row, from left to right. Character '0' means that the triangle belongs to the first part of the main triangle, '1' means that it belongs to the second one.

Testcase with n = 0 designates the end of the test data, this testcase must not be processed. There is no blank line in the input file.


Output

For each puzzle output the line with its number followed by the line that states whether the parts can be separated. Do not output any blank lines.


Sample Input

6
0
001
00011
0000011
000111111
00111111111
6
0
001
00111
0011011
000000111
00111111111
0

Sample Output

Puzzle 1
Parts can be separated
Puzzle 2
Parts cannot be separated

Author:  Andrew Stankevich
Source:  Andrew Stankevich's Contest #7 


#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

int n;
int tu[55][200];

bool inmap(int x,int y)
{
    if((x>=1&&x<=n)&&(y>=1&&y<=2*x-1)) return true;
    return false;
}

bool check_down(int x,int y,int c,int kind)
{
    if(kind==1)
    {
        /// x+1 --- y,y+1,y+2
        /// x+2 --- y+1,y+2,y+3
        for(int i=0;i<3;i++)
        {
            int nx=x+1,ny=y+i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }
        for(int i=1;i<4;i++)
        {
            int nx=x+2,ny=y+i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }
    }
    else if(kind==0)
    {
        /// x --- y-1 y+1
        /// x+1 --- y+1 y+2 y+3
        /// x+2 -- y+2

        for(int i=-1;i<=1;i++)
        {
            int nx=x,ny=y+i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }

        for(int i=1;i<=3;i++)
        {
            int nx=x+1,ny=y+i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }

        if(inmap(x+2,y+2))
        {
            if(tu[x+2][y+2]!=c) return false;
        }
    }

    return true;
}

bool check_left(int x,int y,int c,int kind)
{
    if(kind==1)
    {
        /// x -- y-1 y-2 y-3
        /// x-1 y-2,y-3,y-4

        for(int i=1;i<=3;i++)
        {
            int nx=x,ny=y-i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }

        for(int i=2;i<=4;i++)
        {
            int nx=x-1,ny=y-i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }
    }
    else if(kind==0)
    {
        /// x -- y-1 y-2
        /// x-1 -- y-1 y-2 y-3 y-4

        for(int i=1;i<=2;i++)
        {
            int nx=x,ny=y-i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }

         for(int i=1;i<=4;i++)
        {
            int nx=x-1,ny=y-i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }
    }

    return true;
}

bool check_right(int x,int y,int c,int kind)
{
    if(kind==1)
    {
        /// x -- y+1 y+2 y+3
        /// x-1 y y+1 y+2 y+3

         for(int i=1;i<=3;i++)
        {
            int nx=x,ny=y+i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }

         for(int i=0;i<=3;i++)
        {
            int nx=x-1,ny=y+i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }

    }
    else if(kind==0)
    {
        /// x y+1 y+2
        /// x-1 y-1 ... y+3
        for(int i=1;i<=2;i++)
        {
            int nx=x,ny=y+i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }
        for(int i=-1;i<=3;i++)
        {
            int nx=x-1,ny=y+i;
            if(inmap(nx,ny))
            {
                if(tu[nx][ny]!=c) return false;
            }
        }
    }
    return true;
}

bool check_heng()
{
	bool flag=true;
	for(int i=1;i<=n&&flag;i++)
	{
		for(int j=1;j<=2*i-1&&flag;j++)
		{
			if(tu[i][j]==0)
			{
				if(inmap(i,j-1)==false) continue;
				if(tu[i][j-1]==0) continue;
				else flag=false;
			}
		}
	}
	if(flag) return true;
	flag=true;
	for(int i=1;i<=n&&flag;i++)
	{
		for(int j=1;j<=2*i-1&&flag;j++)
		{
			if(tu[i][j]==0)
			{
				if(inmap(i,j+1)==false) continue;
				if(tu[i][j+1]==0) continue;
				else flag=false;
			}
		}
	}
	if(flag) return true;
	return false;
}

bool check_shu()
{
    bool flag=true;
    for(int i=1;i<=n&&flag;i++)
	{
		for(int j=1;j<=2*i-1&&flag;j++)
		{
			if(tu[i][j]==0)
			{
			    if(j%2==1)
                {
                    int nx=i, ny=j+1;
					if(inmap(nx,ny)==false) continue;
                    if(tu[nx][ny]==0) ;
                    else flag=false;
                }
                else if(j%2==0)
                {
                    int nx=i-1, ny=j-1;
					if(inmap(nx,ny)==false) continue;
                    if(tu[nx][ny]==0) ;
                    else flag=false;
                }
			}
		}
	}
	if(flag) return true;
	flag=true;
    for(int i=1;i<=n&&flag;i++)
	{
		for(int j=1;j<=2*i-1&&flag;j++)
		{
			if(tu[i][j]==0)
			{
			    if(j%2==1)
                {
                    int nx=i+1, ny=j+1;
					if(inmap(nx,ny)==false) continue;
                    if(tu[nx][ny]==0) ;
                    else flag=false;
                }
                else if(j%2==0)
                {
                    int nx=i, ny=j-1;
					if(inmap(nx,ny)==false) continue;
                    if(tu[nx][ny]==0) ;
                    else flag=false;
                }
			}
		}
	}
	if(flag) return true;
	return false;
}

bool check_xie()
{
    bool flag=true;
    for(int i=1;i<=n&&flag;i++)
	{
		for(int j=1;j<=2*i-1&&flag;j++)
		{
			if(tu[i][j]==0)
			{
			    if(j%2==1)
                {
                    int nx=i, ny=j-1;
					if(inmap(nx,ny)==false) continue;
                    if(tu[nx][ny]==0) ;
                    else 
                    {
                    	flag=false;
                	}
                }
                else if(j%2==0)
                {
                    int nx=i-1, ny=j-1;
					if(inmap(nx,ny)==false) continue;
                    if(tu[nx][ny]==0) ;
                    else 
                    {
                    	flag=false;
                	}
                }
			}
		}
	}
	if(flag) return true;
	flag=true;
    for(int i=1;i<=n&&flag;i++)
	{
		for(int j=1;j<=2*i-1&&flag;j++)
		{
			if(tu[i][j]==0)
			{
			    if(j%2==1)
                {
                    int nx=i+1, ny=j+1;
					if(inmap(nx,ny)==false) continue;
                    if(tu[nx][ny]==0) ;
                    else 
                    {
                    	flag=false;
                	}
                }
                else if(j%2==0)
                {
                    int nx=i, ny=j+1;
					if(inmap(nx,ny)==false) continue;
                    if(tu[nx][ny]==0) ;
                    else 
                    {
                    	flag=false;
                	}
                }
			}
		}
	}
	if(flag) return true;
	return false;
}

char hang[5000];

int main()
{
	int cas=1;
    while(scanf("%d",&n)!=EOF&&n)
    {
    	printf("Puzzle %d\n",cas++);
    	int zero=0,one=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%s",hang+1);
            for(int j=1;j<=2*i-1;j++)
            {
                tu[i][j]=hang[j]-'0';
            	if(tu[i][j]==0) zero++;
            	else one++;
            }
        }

        if(one==0||zero==0)
        {
        	puts("Parts cannot be separated"); continue;
        }

        bool flag=true;

        if(check_heng()||check_shu()||check_xie()){puts("Parts can be separated"); continue;}

        for(int i=1;i<=n&&flag;i++)
        {
        	for(int j=1;j<=2*i-1&&flag;j++)
        	{
        		if(tu[i][j]!=0) continue;
        		if(check_down(i,j,0,j%2)) continue;
        		else flag=false;
        	}
        }

        if(flag==true)
        {
        	puts("Parts can be separated"); continue;
        }

        flag=true;
        for(int i=1;i<=n&&flag;i++)
        {
        	for(int j=1;j<=2*i-1&&flag;j++)
        	{
        		if(tu[i][j]!=0) continue;
        		if(check_left(i,j,0,j%2)) continue;
        		else flag=false;
        	}
        }

        if(flag==true)
        {
        	puts("Parts can be separated"); continue;
        }

        flag=true;
        for(int i=1;i<=n&&flag;i++)
        {
        	for(int j=1;j<=2*i-1&&flag;j++)
        	{
        		if(tu[i][j]!=0) continue;
        		if(check_right(i,j,0,j%2)) continue;
        		else flag=false;
        	}
        }

        if(flag==true)
        {
        	puts("Parts can be separated"); continue;
        }
        else
        {
        	puts("Parts cannot be separated");
        }

    }
    return 0;
}




码代码的猿猿的AC之路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
8-puzzle(8字拼图)代码
05-09
运用了二叉堆实现的优先级队列和a*寻路算法解决了8-puzzle问题。写的随意,没有注释。代码只要稍微改动变可以支持n puzzle问题求解。
zoj 3019 Puzzle（这个算是贪心吧？？）
小媛在努力~
11-26 958
<br />给你两串数A,B，让你随意排列这些数使它们的最长公共子序列最长。<br /> <br />开始还以为是DP，后来觉得，这个真没必要呀。<br /> <br />因为可以按任何安排，那么只要知道这两个序列中有多少个数是相同的就OK了，那一定是最长的。<br /> <br />直接排序，两个都排序，然后按顺序查找就OK了。<br /> <br />#include <stdio.h> #include <stdlib.h> #include <iostream> #include <strin
ZOJ 3019 Puzzle
左眼皮跳跳
08-11 885
贪心 ZOJ 3019 Puzzle
Zoj 3541 The Last Puzzle（区间dp）
madaidao的专栏
09-26 547
题目链接 The Last Puzzle Time Limit: 2 Seconds      Memory Limit: 65536 KB      Special Judge  There is one last gate between the hero and the dragon. But opening the gate isn't an easy ta
ZOJ3541:The Last Puzzle(区间DP)
ACM！荣耀之路！
08-11 1900
There is one last gate between the hero and the dragon. But opening the gate isn't an easy task. There were n buttons list in a straight line in front of the gate and each with an integer on it. Like
zoj 3019 Puzzle.md
11-17
zoj 3019 Puzzle.md
zoj 1002_zoj1002_
09-29
【标题】"ZOJ 1002" 是一个在线编程竞赛题目，源自ZOJ（Zhejiang Online Judge），这是一个面向ACM/ICPC（国际大学生程序设计竞赛）的在线评测系统。题目编号1002，通常表示该题是ZOJ平台上的一个问题，可能涉及算法...
zoj.zip_zoj
最新发布
09-24
【标题】"zoj.zip_zoj"所对应的资源是一个与ZOJ（Zhejiang Online Judge）相关的代码集合。ZOJ是浙江大学主办的一个在线编程竞赛平台，它提供了多种算法题目供用户练习和提交代码进行评测。这个压缩包很可能包含了在...
zoj1383_zoj1383_
09-30
标题“zoj1383_zoj1383_”和描述中的“一个非常非常非常非常实用的zoj结题代码”暗示我们这可能是一个关于ZOJ（在线判题系统Zhejiang Online Judge）的编程挑战解决方案。ZOJ是一个为编程爱好者提供在线编程练习和...
puzzle_demo
10-24
puzzle_demo
ZOJ4.16.rar_zoj
09-21
ZOJ4.16.rar_zoj 是一个与ZOJ（Zhejiang Online Judge）相关的压缩文件，这通常意味着它包含了某次程序设计竞赛，特别是2004年4月16日浙江省程序设计竞赛的题目。ZOJ是浙江大学主办的一个在线编程平台，它允许参赛者...
Java实现puzzle
weixin_45796275的博客
06-01 478
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键题目的要求实现的代码生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的
c代码实现 ifft运算_C程序编程第七天，谜题（Puzzle）的代码实现，含代码讲解...
weixin_40009393的博客
12-17 239
题目：题目-1题目-2题目-3题目翻译： 这个原题实在是太长了，就直接上图片了，我们一起翻译一下：Puzzle :谜题 ，有一个5*5的方格其中恰好有一个格子是空的，其他各自各有一个字母。一共有4种指令：A,B,L,R ，分别表示把空格上，下，左，右的相邻字母移动到空格中。输入初始网格和指令序列(以零结束)，输出执行完之后的网格，如果有非法指令，应输出：This puzzle has no fin...
npuzzle代码
weixin_43227176的博客
06-17 282
npuzzle代码欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 List i...
8数码，8PUZZLE 问题 C++ 代码
豌豆公主
11-17 2247
用到A* 算法。还有h方程。定义如代码里面。 我的代码如下： 8puzzle.h: #include #include #include #include #include #include #include #include #include using namespace std; void begin(); int** input(); in
ZOJ 3736 Pocket Cube
码代码的猿猿
12-03 3155
模拟。。。就足够了 Pocket Cube Time Limit: 2 Seconds      Memory Limit: 65536 KB Pocket Cube is a 3-D combination puzzle. It is a 2 × 2 × 2 cube, which means it is constructed by 8 mini-cubes. F
CodeForces 367B. Sereja ans Anagrams
码代码的猿猿
11-29 2385
B. Sereja ans Anagrams time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Sereja has two sequences a and b and
Codeforces 382 C. Arithmetic Progression
码代码的猿猿
01-18 2176
先由小到大排序 1：只有一个数  无限多 2：存在3种以上的间距 无 3：出现2种间距 大的间距只有1个，且长度是小的两倍  1种 大的间距有几个  无 4：只有1种间距 只出现一次  一头一尾  或者 加上中间 **仅有的间距是0  1种 C. Arithmetic Progression time limit per test 1
zoj解题分类详细版
03-01
ZOJ题目分类详细版包括初学者题目和模拟问题，分别涵盖了一系列题目，是非常详细的解题分类，对初学者学习十分有用。其中初学者题目包括1001、1037、1048、1049、1051、1067、1115、1151、1201、1205、1216、1240、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值