poj2706

最新推荐文章于 2021-06-06 20:13:05 发布
最新推荐文章于 2021-06-06 20:13:05 发布
阅读量319 收藏
点赞数
分类专栏： 模拟 文章标签： 模拟 poj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33362864/article/details/52713203
版权

Connect
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 1359 Accepted: 452

Description

Figure 1Figure 2Figure 3aFigure 3bFigure 4

Your task is to decide if a specified sequence of moves in the board game Twixt ends with a winning move. 

In this version of the game, different board sizes may be specified. Pegs are placed on a board at integer coordinates in the range [0, N]. Players Black and White use pegs of their own color. Black always starts and then alternates with White, placing a peg at one unoccupied position (x,y). Black's endzones are where x equals 0 or N, and White's endzones are where y equals 0 or N. Neither player may place a peg in the other player's endzones. After each play the latest position is connected by a segment to every position with a peg of the same color that is a chess knight's move away (2 away in one coordinate and 1 away in the other), provided that a new segment will touch no segment already added, except at an endpoint. Play stops after a winning move, which is when a player's segments complete a connected path between the player's endzones. 

For example Figure 1 shows a board with N=4 after the moves (0,2), (2,4), and (4,2). Figure 2 adds the next move (3,2). Figure 3a shows a poor next move of Black to (2,3). Figure 3b shows an alternate move for Black to (2,1) which would win the game. 

Figure 4 shows the board with N=7 after Black wins in 11 moves: 
(0, 3), (6, 5), (3, 2), (5, 7), (7, 2), (4, 4), (5, 3), (5, 2), (4, 5), (4, 0), (2, 4). 

Input

The input contains from 1 to 20 datasets followed by a line containing only two zeroes, "0 0". The first line of each dataset contains the maximum coordinate N and the number of total moves M where 3 < N < 21, 4 < M < 250, and M is odd. The rest of the dataset contains a total of M coordinate pairs, with one or more pairs per line. All numbers on a line will be separated by a space. M being odd means that Black will always be the last player. All data will be legal. There will never be a winning move before the last move.

Output

The output contains one line for each data set: "yes" if the last move is a winning move and "no" otherwise.

Sample Input

4 5
0 2 2 4 4 2 3 2 2 3
4 5
0 2 2 4 4 2 3 2 2 1
7 11
0 3 6 5 3 2 5 7 7 2 4 4
5 3 5 2 4 5 4 0 2 4
0 0

Sample Output

no
yes
yes
優YoU http://user.qzone.qq.com/289065406/blog/1308890557 ­

思路：

美（sang）妙（xin）至（bing）极（kuang）的模拟，但是难度不大，难点主要在于判断连线是否相交。­

这个题一定要画好了，细心才能做出来（太恶心了）

如上图放下一只棋子后，先检查其附近的8个方位是否存在同色棋子，若存在，则检查是否允许与该同色棋子连线。­

检查连线方法如下图，以30度的方位为例：­

­

如上图，当放下新棋子后，若检测到30度方位存在与其同色的棋子，则在连接蓝线之前，先检查是否已存在9条红色的线，当且仅当这9条红线都不存在时，才允许连接蓝线。­

其他7个方位也是同样做法。­


连接起来线就好说了，直接bfs看一看能不能走到最后边界就可以了。

小优的用了两次bfs，不过我也觉得数据给的应该是合法的，毕竟如果赢了那还下什么。

另外就是连线的时候，判断九条线的时候可以稍微暴力一下白色的点们的连线，如果能连线且相交自然是不能连接的，判断相交自然是用叉积。

不过这种思想是最简单的，只要画好图就行了。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int MAXN=250+5;
int n,m;
int lastx,lasty;

int tu[30][30];//用来给点编号
bool link[MAXN][MAXN];//表示两个点之间是否连线
//8个方位
int xx[8]= {-1,-2,-2,-1, 1, 2,2,1};
int xy[8]= { 2, 1,-1,-2,-2,-1,1,2};

struct node
{
    int color;
    int x,y;
    int connet[8];
    int cnt;
} peg[MAXN];

void linepeg(int i);//把此点和其余的点连线
bool checkwin();

int main()
{
    int i;
    while(~scanf("%d%d",&n,&m))
    {
        if(!n&&!m)break;
        memset(tu,0,sizeof(tu));
        memset(link,0,sizeof(link));
    for(i=1; i<=m; ++i)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        tu[x][y]=i;
        peg[i].color=i%2;
        peg[i].x=x;
        peg[i].y=y;
        peg[i].cnt=0;
        if(i==m)
        {
            lastx=x;
            lasty=y;
        }
        linepeg(i);//连线
    }
    if(checkwin())puts("yes");//搜索
    else puts("no");
    }
    return 0;
}

void linepeg(int i)
{
    int color=peg[i].color;
    for(int k = 0; k < 8; ++k) //查看八个方位的棋子
    {
        int x=peg[i].x+xx[k];
        int y=peg[i].y+xy[k];
        if(x>=0&&x<=n&&y>=0&&y<=n)//边界
        {
            if(tu[x][y]&&peg[tu[x][y]].color==color)//可以和相同的点连线
            {
                switch(k)
                {
                    //然后就是每个方位分别判断对应的九条线段就可以了，画好图很简单
                case 0:
                {
                    if(link[ tu[x][y-2] ][ tu[x+1][y] ])
                        break;
                    if(y-3>=0 && link[ tu[x][y-3] ][ tu[x+1][y-1] ])
                        break;
                    if(y+1<=n && link[ tu[x][y-1] ][ tu[x+1][y+1] ])
                        break;
                    if(x-1>=0)
                    {
                        if(link[ tu[x-1][y-2] ][ tu[x+1][y-1] ])
                            break;
                        if(link[ tu[x-1][y-1] ][ tu[x+1][y] ])
                            break;
                        if(link[ tu[x-1][y] ][ tu[x+1][y-1] ])
                            break;
                    }
                    if(x+2<=n)
                    {
                        if(link[ tu[x+2][y-2] ][ tu[x][y-1] ])
                            break;
                        if(link[ tu[x+2][y-1] ][ tu[x][y-2] ])
                            break;
                        if(link[ tu[x+2][y] ][ tu[x][y-1] ])
                            break;
                    }
                    int a=tu[peg[i].x][peg[i].y];
                    int b=tu[x][y];
                    peg[a].connet[peg[a].cnt++]=b;
                    peg[b].connet[peg[b].cnt++]=a;
                    link[a][b]=link[b][a]=1;
                    break;
                }
                case 1:
                {
                    if(link[ tu[x][y-1] ][ tu[x+2][y] ])
                        break;
                    if(x-1>=0 && link[ tu[x-1][y-1] ][ tu[x+1][y] ])
                        break;
                    if(x+3<=n && link[ tu[x+1][y-1] ][ tu[x+3][y] ])
                        break;
                    if(y-2>=0)
                    {
                        if(link[ tu[x][y-2] ][ tu[x+1][y] ])
                            break;
                        if(link[ tu[x+1][y-2] ][ tu[x+2][y] ])
                            break;
                        if(link[ tu[x+2][y-2] ][ tu[x+1][y] ])
                            break;
                    }
                    if(y+1<=n)
                    {
                        if(link[ tu[x][y-1] ][ tu[x+1][y+1] ])
                            break;
                        if(link[ tu[x+1][y-1] ][ tu[x][y+1] ])
                            break;
                        if(link[ tu[x+1][y-1] ][ tu[x+2][y+1] ])
                            break;
                    }
                    int a=tu[peg[i].x][peg[i].y];
                    int b=tu[x][y];
                    peg[a].connet[peg[a].cnt++]=b;
                    peg[b].connet[peg[b].cnt++]=a;
                    link[a][b]=link[b][a]=1;
                    break;
                }
                case 2:
                    {
                        if(link[ tu[x][y+1] ][ tu[x+2][y] ])
                            break;
                        if(x-1>=0 && link[ tu[x-1][y+1] ][ tu[x+1][y] ])
                            break;
                        if(x+3<=n && link[ tu[x+1][y+1] ][ tu[x+3][y] ])
                            break;
                        if(y-1>=0)
                        {
                            if(link[ tu[x][y-1] ][ tu[x+1][y+1] ])
                                break;
                            if(link[ tu[x+1][y-1] ][ tu[x][y+1] ])
                                break;
                            if(link[ tu[x+2][y-1] ][ tu[x+1][y+1] ])
                                break;
                        }
                        if(y+2<=n)
                        {
                            if(link[ tu[x+1][y] ][ tu[x][y+2] ])
                                break;
                            if(link[ tu[x+2][y] ][ tu[x+1][y+2] ])
                                break;
                            if(link[ tu[x+1][y] ][ tu[x+2][y+2] ])
                                break;
                        }
                        int a=tu[peg[i].x][peg[i].y];
                        int b=tu[x][y];
                        peg[a].connet[peg[a].cnt++]=b;
                        peg[b].connet[peg[b].cnt++]=a;
                        link[a][b]=link[b][a]=1;
                        break;
                    }
                case 3:
                    {
                        if(link[ tu[x][y+2] ][ tu[x+1][y] ])
                            break;
                        if(y-1>=0 && link[ tu[x+1][y-1] ][ tu[x][y+1] ])
                            break;
                        if(y+3<=n && link[ tu[x+1][y+1] ][ tu[x][y+3] ])
                            break;
                        if(x-1>=0)
                        {
                            if(link[ tu[x-1][y] ][ tu[x+1][y+1] ])
                                break;
                            if(link[ tu[x-1][y+1] ][ tu[x+1][y] ])
                                break;
                            if(link[ tu[x-1][y+2] ][ tu[x+1][y+1] ])
                                break;
                        }
                        if(x+2<=n)
                        {
                            if(link[ tu[x][y+1] ][ tu[x+2][y] ])
                                break;
                            if(link[ tu[x][y+1] ][ tu[x+2][y+2] ])
                                break;
                            if(link[ tu[x][y+2] ][ tu[x+2][y+1] ])
                                break;
                        }
                        int a=tu[peg[i].x][peg[i].y];
                        int b=tu[x][y];
                        peg[a].connet[peg[a].cnt++]=b;
                        peg[b].connet[peg[b].cnt++]=a;
                        link[a][b]=link[b][a]=1;
                        break;
                    }
                case 4:
                    {
                        if(link[ tu[x-1][y] ][ tu[x][y+2] ])
                            break;
                        if(y-1>=0 && link[ tu[x-1][y-1] ][ tu[x][y+1] ])
                            break;
                        if(y+3<=n && link[ tu[x-1][y+1] ][ tu[x][y+3] ])
                            break;
                        if(x-2>=0)
                        {
                            if(link[ tu[x-2][y] ][ tu[x][y+1] ])
                                break;
                            if(link[ tu[x-2][y+1] ][ tu[x][y+2] ])
                                break;
                            if(link[ tu[x-2][y+2] ][ tu[x][y+1] ])
                                break;
                        }
                        if(x+1<=n)
                        {
                            if(link[ tu[x][y] ][ tu[x-1][y+1] ])
                                break;
                            if(link[ tu[x+1][y+1] ][ tu[x-1][y] ])
                                break;
                            if(link[ tu[x+1][y+2] ][ tu[x-1][y+1] ])
                                break;
                        }
                        int a=tu[peg[i].x][peg[i].y];
                        int b=tu[x][y];
                        peg[a].connet[peg[a].cnt++]=b;
                        peg[b].connet[peg[b].cnt++]=a;
                        link[a][b]=link[b][a]=1;
                        break;
                    }
                case 5:
                    {
                        if(link[ tu[x-2][y] ][ tu[x][y+1] ])
                            break;
                        if(x-3>=0 && link[ tu[x-3][y] ][ tu[x-1][y+1] ])
                            break;
                        if(x+1<=n && link[ tu[x-1][y] ][ tu[x+1][y+1] ])
                            break;
                        if(y-1>=0)
                        {
                            if(link[ tu[x-2][y-1] ][ tu[x-1][y+1] ])
                                break;
                            if(link[ tu[x-1][y-1] ][ tu[x][y+1] ])
                                break;
                            if(link[ tu[x][y-1] ][ tu[x-1][y+1] ])
                                break;
                        }
                        if(y+2<=n)
                        {
                            if(link[ tu[x-1][y] ][ tu[x-2][y+2] ])
                                break;
                            if(link[ tu[x-2][y] ][ tu[x-1][y+2] ])
                                break;
                            if(link[ tu[x-1][y] ][ tu[x][y+2] ])
                                break;
                        }
                        int a=tu[peg[i].x][peg[i].y];
                        int b=tu[x][y];
                        peg[a].connet[peg[a].cnt++]=b;
                        peg[b].connet[peg[b].cnt++]=a;
                        link[a][b]=link[b][a]=1;
                        break;
                    }
                case 6:
                    {
                        if(link[ tu[x-2][y] ][ tu[x][y-1] ])
                            break;
                        if(x-3>=0 && link[ tu[x-3][y] ][ tu[x-1][y-1] ])
                            break;
                        if(x+1<=n && link[ tu[x-1][y] ][ tu[x+1][y-1] ])
                            break;

                        if(y-2>=0)
                        {
                            if(link[ tu[x-2][y-2] ][ tu[x-1][y] ])
                                break;
                            if(link[ tu[x-1][y-2] ][ tu[x-2][y] ])
                                break;
                            if(link[ tu[x][y-2] ][ tu[x-1][y] ])
                                break;
                        }
                        if(y+1<=n)
                        {
                            if(link[ tu[x-1][y-1] ][ tu[x-2][y+1] ])
                                break;
                            if(link[ tu[x][y-1] ][ tu[x-1][y+1] ])
                                break;
                            if(link[ tu[x-1][y-1] ][ tu[x][y+1] ])
                                break;
                        }
                        int a=tu[peg[i].x][peg[i].y];
                        int b=tu[x][y];
                        peg[a].connet[peg[a].cnt++]=b;
                        peg[b].connet[peg[b].cnt++]=a;
                        link[a][b]=link[b][a]=1;
                        break;
                    }
                case 7:
                    {
                        if(link[ tu[x][y-2] ][ tu[x-1][y] ])
                            break;
                        if(y-3>=0 && link[ tu[x][y-3] ][ tu[x-1][y-1] ])
                            break;
                        if(y+1<=n && link[ tu[x][y-1] ][ tu[x-1][y+1] ])
                            break;
                        if(x-2>=0)
                        {
                            if(link[ tu[x-2][y-2] ][ tu[x][y-1] ])
                                break;
                            if(link[ tu[x-2][y-1] ][ tu[x][y-2] ])
                                break;
                            if(link[ tu[x-2][y] ][ tu[x][y-1] ])
                                break;
                        }
                        if(x+1<=n)
                        {
                            if(link[ tu[x-1][y-1] ][ tu[x+1][y-2] ])
                                break;
                            if(link[ tu[x-1][y-1] ][ tu[x+1][y] ])
                                break;
                            if(link[ tu[x-1][y] ][ tu[x+1][y-1] ])
                                break;
                        }
                        int a=tu[peg[i].x][peg[i].y];
                        int b=tu[x][y];
                        peg[a].connet[peg[a].cnt++]=b;
                        peg[b].connet[peg[b].cnt++]=a;
                        link[a][b]=link[b][a]=1;
                        break;
                    }
                }
            }
        }
    }
}
bool checkwin()
{
    //搜索没什么好说的，最近队列习惯性静态，快但是内存消耗多
    for(int k=0;k<=n;k++)
    {
        int p=tu[0][k];
        if(p&&peg[p].color==1)//我们直接搜黑色就好了
        {
            int q[MAXN];
            bool vis[MAXN]={0};
            int head=0;
            int tail=0;
            q[tail++]=p;
            vis[p]=1;
            while(head<tail)
            {
                int k=q[head++];
                if(peg[k].x==n)
                    return 1;

                for(int i=0;i<peg[k].cnt;i++)
                {
                    int x=peg[k].connet[i];
                    if(!vis[x])
                    {
                        vis[x]=1;
                        q[tail++]=x;
                    }
                }
            }
        }
    }
    return 0;
}



UMR小豪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ2706-Connect
07-31
标题“POJ2706-Connect”是一个编程竞赛题目，源自北京大学的在线判题系统POJ（Problem Online Judge）。这个题目主要考察参赛者在算法和数据结构方面的知识，特别是图论中的连通性问题。下面我们将深入探讨这个问题...
poj题目分类
02-17
* 较为复杂的模拟题的训练：例如 poj3393、poj1472、poj3371、poj1027、poj2706。 2. 图算法： * 差分约束系统的建立和求解：例如 poj1201、poj2983。 * 最小费用最大流：例如 poj2516、poj2516、poj2195。 * ...
POJ 2706
qq_43609787的博客
06-06 94
Idi //Accepted312K16MS #include<iostream> #include<vector> #include<cstdio> #include<set> #include<algorithm> usingnamespacestd; intN,M; intdir[8][2]={{-1,2},{-1,-2},{-2,-1},{-2,1},{1,-2},{1,2},{2,-...
POJ2706
青松
04-28 343
#ifndef ONLINE_JUDGE #pragma warning(disable : 4996) #endif #include <iostream> #include <vector> #include <map> #include <cstdlib> using namespace std;typedef long long LL;// return (a * b) % m LL mod
poj2706麦森数
yanerhao的专栏
07-22 861
Description 形如2p-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数。2p-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数密切相关。 任务：从文件中输入P (1000 Input 文件中只包含一个整数P(1000 Output 第1行：十进制高精度数
poj2706 connect
生活总是要微笑着面对~
03-17 1148
几天都没有A题了，稍微分析了一下就是理解题意的能力太差了，比如之前的一道题，明明思路很简单，没有算法难度，但是我看不懂题意啊，想了两天，然后问了别人的题意，但是还是花了大半天时间才将题中给的数据给过了。。。。然后到现在还没有AC，一直wa了，看了和别人的思路是一样的，不过没有怎么看他们的代码，觉得这样的题等几天自己再写一下，把我的脑袋彻底弄混乱了，再说这题，我也是读错了好久，而且一开始的算法是想省
poj.rar_poj
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
POJ.rar_poj
09-19
【标题】"POJ.rar_poj" 指的是一份与编程竞赛相关的压缩文件，主要涉及POJ（Problem Overloading Judge）平台上的问题解答。POJ是一个在线的编程竞赛平台，它为参赛者提供了大量的算法题目进行练习和比赛，以提升...
POJ 2706 棋盘连线游戏(模拟)
AIDreamer
02-16 1005
POJ 2706题目大意黑棋从x轴0连到N算胜利，白棋从y轴0连到N算胜利 让你判断黑棋最后一步是否胜利 具体见原网页 分析对于线采用两种存放方式： 一种用四维数组实现，便于询问两点间是否有线 另一种用结构体实现，方便对线的集合进行操作 最后用BFS判断各个线的联通分量是否有跨越两边边界的连线的时候是不能与其他线之间有交集的，这道题的关键就是如何判断一条线连下去是否会产生交集。这道题我按
poj 2706 Connect
心の コード
01-24 485
题意：给你一个N+1*N+1的棋盘（从0到N），给定了这局棋的下棋过程，黑子先下，且总的下棋步数为奇数，也就保证最后一个下的是黑棋。其中，每下一步棋如果它的周围（中国象棋或是国际象棋中一个日字的走法）8个点存在同色的棋，并且两个棋之间没有其他棋子连线所拦，那么就将这连个棋子连线。如果黑棋从左边界到右边界有一条线贯穿或白棋从上边界到下边界有一条线贯穿，贯穿的那方就获得胜利。原题意为问黑子的最后一步是
poj--2706--Connect(极限大模拟)
随风的专栏
01-30 1498
Connect Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 1148   Accepted: 375 Description Figure 1 Figure 2 Figure 3a Figure 3b Figure
POJ 2706 Connect BFS + 判断线段相交
自在飞花
10-10 978
题意：在n*n的棋盘上有依次放上m个棋子。黑子先手。判断最后一个黑子所连成的线段能否贯穿其区域。 若两颗子中间已有直线存在（端点除外），则此两子不能连。且在最后一个黑子之前，不存在黑子连线贯穿整个区域的情况。 判断两线段相交： 因为此题不存在水平线段或者数值线段，所以可以丧心病狂的使用斜率。 设t1,t2为等待被连线的两个点，该线段所在直线斜率为k1,截距为b; 设t3,t4为有可能
POJ2706Connect(AC)
twinslizzy的博客
06-29 389
Connect Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 1390   Accepted: 472 Description Figure 1 Figure 2 Figure 3a Figure 3b Figure
POJ2706 Connect（并查集+模拟）
执重剑，横江过雁
10-16 540
题目链接：http://poj.org/problem?id=2706 zh
poj2706-麦森数-高精度快速幂
struct_liao的博客
08-13 1125
#include #include #include int a[610],b[610],c[610],d,n,i,j,ldy; int main(){     scanf("%d",&n);     int ldy=ceil( n* log10(2) );     printf("%d\n",ldy);     a[1]=2;     b[1]=1;     while(n!
【模拟】POJ_2706_Connect
yiluuuuu的博客
09-26 175
#include #include #include #include #include using namespace std; int Map[1010][1010],vis[1010],n,m; struct p { int x,y; } a[310]; int in(int i,int j)//判断是否在日字的范围内 { if((fabs(a[i].x-a[j]
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值