poj 1021

最新推荐文章于 2021-02-16 22:44:37 发布
最新推荐文章于 2021-02-16 22:44:37 发布
阅读量768 收藏
点赞数
分类专栏： acm C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Enigma_hao/article/details/8985858
版权
C++ 同时被 2 个专栏收录
29 篇文章 0 订阅
订阅专栏
acm
23 篇文章 0 订阅
订阅专栏 
/*2316K	0MS*/
#include <iostream>
//#include <fstream>
#include <queue>
using namespace std;

#define SIZE 100
typedef struct _point
{
    int _x;
    int _y;
}point;

queue<point>  q;
int w,h,n;
//fstream fin;
bool  map[SIZE][SIZE];

class subgraph
{
    public:
      bool data[SIZE][SIZE],use;
      int count;
      int height,width;
      subgraph *next;
      subgraph(){
         count=height=width=0;
         memset(data,0,sizeof(data));
         next=0;
      }
      subgraph(int w,int h)
      {
          count=0;
          width=w;
          height=h;
          use=false;
          next=0;
          memset(data,0,sizeof(data));  
      }
      void  add(int x,int y)
      {
          data[x][y]=true;
      }
      ~subgraph(){delete []data;}
};

class graph
{
    public:
        subgraph *start,*end;
        int len;
        int total;
        graph()
        {
            start=0;
            end=0;
            len=total=0;
        }
        void add(subgraph *t)
        {
            if(!start)
            {
               start=t;
               end=t;  
            }
            else
            {
                end->next=t;
                end=t;
            }
        }
        
        //¼ÆËãlenºÍtotal 
        void cul()
        {
           for(subgraph *a=start;a!=0;a=a->next)
           {
               len++;
               total+=a->count;
           } 
        } 
        
        //±È½ÏÁ½¸öͼÐÎÊDz»ÊÇ¿ÉÒÔͨ¹ýת»¯µÃµ½ 
        
        bool cmp(subgraph *s1,subgraph *s2)
        {
             if(s1->count!=s2->count)  return false;
             queue<int> q1,q2;
             
             for(int i=0;i<s2->width;i++)
               for(int j=0;j<s2->height;j++)
                  q1.push(s2->data[i][j]);
             
             int len=q1.size();
             int *p2=new int[len];
             for(int i=0;i<len;i++)
             {
                 p2[i]=q1.front();
                 q1.pop();
             }  
                
             //Ö±½Ó±È½Ï 
             bool flag=true;
             if(s1->width==s2->width&&s1->height==s2->height)
             {
                 for(int i=0;i<s1->width;i++)
                   for(int j=0;j<s1->height;j++)
                   {
                       if(s1->data[i][j]!=s2->data[i][j])
                       {
                           flag=false;
                           break;
                       }
                       if(!flag)  break;
                   }
                 if(flag)  return true;  
             }    
             
             //ˮƽ·­×ª
             flag=true;
             if(s1->width==s2->width&&s1->height==s2->height)
             {
                 for(int i=0;i<s1->width;i++)
                   for(int j=0;j<s1->height;j++)
                   {
                       if(s1->data[i][j]!=s2->data[s1->width-1-i][j])
                       {
                           flag=false;
                           break;
                       }
                       if(!flag) break;
                   }
                   if(flag)   return true;
             } 
             
             //´¹Ö±·­×ª 
             
             flag=true;
             if(s1->width==s2->width&&s1->height==s2->height)
             {
                 for(int i=0;i<s1->width;i++)
                   for(int j=0;j<s1->height;j++)
                   {
                       if(s1->data[i][j]!=s2->data[i][s1->height-1-j])
                       {
                           flag=false;
                           break;
                       }
                       if(!flag) break;
                   }
                   if(flag)  return true;
             } 
             
             //Ðýת90¶È
             flag=true;
             if(s1->width==s2->height&&s1->height==s2->width)
             {
                 for(int j=0;j<s1->height;j++)
                   for(int i=s1->width-1;i>=0;i--)
                   {
                       q2.push(s1->data[i][j]);
                   }
                   
                 for(int i=0;i<len;i++)
                 {
                      if(flag){
                      int t=q2.front();
                      if(t!=p2[i])
                          flag=false;
                      }    
                      q2.pop();
                 }
                 if(flag)  return true;  
             }
             
             //Ðýת180¶È
             flag=true;
             if(s1->width==s2->width&&s1->height==s2->height)
             {
                 for(int i=s1->width-1;i>=0;i--)
                   for(int j=s1->height-1;j>=0;j--)
                   {
                       q2.push(s1->data[i][j]);
                   }
                   
                 for(int i=0;i<len;i++)
                 {
                      if(flag){
                      int t=q2.front();
                      if(t!=p2[i])
                          flag=false;
                      }    
                      q2.pop();
                 }
                 if(flag)  return true;  
             }
             
             //Ðýת270¶È 
             flag=true;
             if(s1->width==s2->height&&s1->height==s2->width)
             {
                 for(int j=s1->height-1;j>=0;j--)
                   for(int i=s1->width-1;i>=0;i--)
                   {
                       q2.push(s1->data[i][j]);
                   }
                   
                 for(int i=0;i<len;i++)
                 {
                      if(flag){
                      int t=q2.front();
                      if(t!=p2[i])
                          flag=false;
                      }    
                      q2.pop();
                 }
                 if(flag)  return true;  
             }
             
             //Ðýת90¶È´¹Ö±·­×ª
             flag=true;
             if(s1->width==s2->height&&s1->height==s2->width)
             {
                 for(int j=0;j<s1->height;j++)
                   for(int i=0;i<s1->width;i++)
                   {
                       q2.push(s1->data[i][j]);
                   }
                   
                 for(int i=0;i<len;i++)
                 {
                      if(flag){
                      int t=q2.front();
                      if(t!=p2[i])
                          flag=false;
                      }    
                      q2.pop();
                 }
                 if(flag)  return true;  
             } 
             
             //Ðýת180¶È´¹Ö±·­×ª
             flag=true;
             if(s1->width==s2->width&&s1->height==s2->height)
             {
                 for(int i=s1->width-1;i>=0;i--)
                   for(int j=0;j<s1->height;j++)
                   {
                       q2.push(s1->data[i][j]);
                   }
                   
                 for(int i=0;i<len;i++)
                 {
                      if(flag){
                      int t=q2.front();
                      if(t!=p2[i])
                          flag=false;
                      }    
                      q2.pop();
                 }
                 if(flag)  return true;  
             } 
             
             //Ðýת270¶È´¹Ö±·­×ª
              
             flag=true;
             if(s1->width==s2->height&&s1->height==s2->width)
             {
                 for(int j=s1->height-1;j>=0;j--)
                   for(int i=0;i<s1->width;i++)
                   {
                       q2.push(s1->data[i][j]);
                   }
                   
                 for(int i=0;i<len;i++)
                 {
                      if(flag){
                      int t=q2.front();
                      if(t!=p2[i])
                          flag=false;
                      }    
                      q2.pop();
                 }
                 if(flag)  return true;  
             }  
             
             //Ðýת90¶Èˮƽ·­×ª
             flag=true;
             if(s1->width==s2->height&&s1->height==s2->width)
             {
                 for(int j=s1->height-1;j>=0;j--)
                   for(int i=s1->width-1;i>=0;i--)
                   {
                       q2.push(s1->data[i][j]);
                   }
                   
                 for(int i=0;i<len;i++)
                 {
                      if(flag){
                      int t=q2.front();
                      if(t!=p2[i])
                          flag=false;
                      }    
                      q2.pop();
                 }
                 if(flag)  return true;  
             }   
             
             //Ðýת180¶Èˮƽ·­×ª
             flag=true;
             if(s1->width==s2->height&&s1->height==s2->width)
             {
                 for(int i=0;i<s1->width;i++)
                   for(int j=s1->height-1;j>=0;j--)
                   {
                       q2.push(s1->data[i][j]);
                   }
                   
                 for(int i=0;i<len;i++)
                 {
                      if(flag){
                      int t=q2.front();
                      if(t!=p2[i])
                          flag=false;
                      }    
                      q2.pop();
                 }
                 if(flag)  return true;  
             }    
             
             
             //Ðýת270¶Èˮƽ·­×ª
             flag=true;
             if(s1->width==s2->height&&s1->height==s2->width)
             {
                 for(int j=0;j<s1->height;j++)
                   for(int i=s1->width-1;i>=0;i--)
                   {
                       q2.push(s1->data[i][j]);
                   }
                   
                 for(int i=0;i<len;i++)
                 {
                      if(flag){
                      int t=q2.front();
                      if(t!=p2[i])
                          flag=false;
                      }    
                      q2.pop();
                 }
                 if(flag)  return true;  
             } 
             
             delete [] p2;
             return false;   
        }
        
        //Á½¸öͼÐÎµÄ±È½Ï 
        bool compare(graph &g2)
        {
            if(len!=g2.len||total!=g2.total)  return false;
            else{
			for(subgraph *t1=g2.start;t1!=NULL;t1=t1->next)
			{
			  bool flag=false;
              for(subgraph *t2=start;t2!=NULL;t2=t2->next)
			  {
				  if(t1->use==false&&t2->use==false)
				     if(cmp(t2,t1))
					 {
					    t2->use=t1->use=true;
						flag=true;
						break;
					 }	 
      
                /*  for(int i1=0;i1<t1->width;i1++)
                  {
                         for(int i2=0;i2<t1->height;i2++)
                            cout<<t1->data[i1][i2]<<" "; 
                     cout<<endl;
                  }
                  cout<<"--------------"<<endl; */
			  }
			  if(!flag) return false;
			}
			return true;
		}
        }
};


void detect(int x,int y)
{
    if(x<0||y<0||x>=w||y>=h)  return;
    if(!map[x][y])  return;
    point p;
    p._x=x;
    p._y=y;
    q.push(p); 
    map[x][y]=false;
    detect(x-1,y);
    detect(x+1,y);
    detect(x,y-1);
    detect(x,y+1);
}

int main()
{
    //¶ÁÈ¡Êý¾Ý
    //fin.open("1021.txt",ios::in);
    
    int t; 
    cin>>t;
    
    while(t--)
    {
        memset(map,0,sizeof(map));
        cin>>w>>h>>n;
        int i,j;
        for(i=0;i<n;i++)
        {
            int x,y;
            cin>>x>>y;
            map[x][y]=true;
        }
        
      /*for(i=0;i<w;i++)
        {
             for(j=0;j<h;j++)
         {
             if(map[i][j])
               cout<<"1"<<" ";
             else
               cout<<"0"<<" ";
         }
          cout<<endl;
       }  */  
        //¶ÁÈ¡graph1 ºÍgraph2
        graph graph1,graph2;
        
        //graph1 
        for(i=0;i<w;i++)
          for(j=0;j<h;j++)
          {
              if(map[i][j])
              {
                  detect(i,j);
                  int len=q.size();
                  point *p=new point[len];
                  int index=0;
                  while(!q.empty())
                  {
                      p[index++]=q.front();
                      q.pop();   //³ö¶Ó 
                  }
                  
                  int leftx=100000;
                  int topy=100000;
                  int rightx,undery;
                  rightx=undery=-1;
                  
                  for(int k=0;k<len;k++)
                  {
                      if(leftx>p[k]._x)  leftx=p[k]._x;
                      if(topy>p[k]._y)  topy=p[k]._y;
                      if(rightx<p[k]._x)  rightx=p[k]._x;
                      if(undery<p[k]._y)  undery=p[k]._y;
                  }
          
                  subgraph *temp=new subgraph(rightx-leftx+1,undery-topy+1);
                  //cout<<temp->width<<" "<<temp->height<<endl; 
                  for(int l=0;l<len;l++)
                  {
                      int x,y;
                      x=p[l]._x-leftx;
                      y=p[l]._y-topy;
                      temp->add(x,y);
                  } 
                  
                 temp->count=len;
                 //cout<<"count:"<<temp->count<<endl; 
                 graph1.add(temp);
                 
                /* for(int i1=0;i1<temp->width;i1++)
                  {
                         for(int i2=0;i2<temp->height;i2++)
                            cout<<temp->data[i1][i2]<<" "; 
                     cout<<endl;
                  }
                  cout<<"--------------"<<endl;*/
                 delete []p;
              }
          }
          
          
          //graph2
          memset(map,0,sizeof(map));
          for(i=0;i<n;i++)
          {
            int x,y;
            cin>>x>>y;
            map[x][y]=true;
          }
          
        /*  for(i=0;i<w;i++)
         {
             for(j=0;j<h;j++)
            {
             if(map[i][j])
               cout<<"1"<<" ";
             else
               cout<<"0"<<" ";
            }
          cout<<endl;
        } */ 
          
          for(i=0;i<w;i++)
           for(j=0;j<h;j++)
           {
              if(map[i][j])
              {
                  detect(i,j);
                  int len=q.size();
                  point *p=new point[len];
                  int index=0;
                  while(!q.empty())
                  {
                      p[index++]=q.front();
                      q.pop();   //³ö¶Ó 
                  }
                  
                  int leftx=100000;
                  int topy=100000;
                  int rightx,undery;
                  rightx=undery=-1;
                  
                  for(int k=0;k<len;k++)
                  {
                      if(leftx>p[k]._x)  leftx=p[k]._x;
                      if(topy>p[k]._y)  topy=p[k]._y;
                      if(rightx<p[k]._x)  rightx=p[k]._x;
                      if(undery<p[k]._y)  undery=p[k]._y;
                  }
                  
                  subgraph *temp1=new subgraph(rightx-leftx+1,undery-topy+1);
                  //cout<<temp1->width<<" "<<temp1->height<<endl;
                  
                       
                  for(int l=0;l<len;l++)
                  {
                      int x,y;
                      x=p[l]._x-leftx;
                      y=p[l]._y-topy;
                      temp1->add(x,y);
                  } 
                 temp1->count=len; 
                 
                  /*for(int i1=0;i1<temp1->width;i1++)
                  {
                         for(int i2=0;i2<temp1->height;i2++)
                            cout<<temp1->data[i1][i2]<<" "; 
                     cout<<endl;
                  } 
                  cout<<"------------------"<<endl;  */
                 graph2.add(temp1);
                 
                 delete []p;
              }
           }
           
           graph1.cul();
           graph2.cul();
           //cout<<"len:"<<graph1.len<<"total:"<<graph1.total<<endl;
          // cout<<"len1:"<<graph2.len<<"total1:"<<graph2.total<<endl;
           if(graph1.compare(graph2))
            cout<<"YES"<<endl;
           else
             cout<<"NO"<<endl;
       }    
    system("pause");
    return 0;
}

Rotile
关注
专栏目录
poj.rar_poj
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
poj1021
SparkRat的家
05-16 1200
题目描述：判断两个图是否等价。 对等价的定义是：两个图有相同个数的连通块，第一个图里面的每个连通块总能在第二个图里面找到一个连通块（未与别的块匹配）与之匹配。 对连通块匹配的定义是：两个连通块如果能经过若干次平移、对称、旋转等操作之后重合，则说它们是匹配的。 现在要求设计程序，输入两个图，输出它们是否等价。 输入格式：第一行一个整数t，表示有t组数据，接下来t组数据，每组数据由3行构成，第一
OJ-POJ1021-暴力
zxwtry的博客
05-01 495
这题网上有代码量很少的解法，可惜我看不明白。 先不管题目，讨论如何判断两个图形相同（旋转，平移，翻转）？ 就是如下8个图形中，任选出两个，要得出它们是两个相同的图形： 我的方法特土特暴力：列出8种，然后分别比较。。。 回到题目，自己的理解是（对左右两个板）： a，找到群。要求左右，群数相同，群中点数相同 b，群中点数相同的，一定有一对一相同的形状 分析过程： 1，找群，
POJ 1021 Joseph
DS-K的博客
05-05 341
题目链接：http://poj.org/problem?id=1012 题意：有2*k个人围城一个圈，前k个是好人，后k个是坏人，现在从第一个开始报数，报到m的出去。求最小的m使得所有的坏人先出去。k 思路：约瑟夫环问题，我们可以暴力枚举m，对于每一个m来检查是不是满足情况。先固定了m之后，那么可以看看前k个人是不是在出去k个人之后还留下。只要找到出去一个人后，当前人的编号变化
poj 1021 2D_NIM
Fawkess的博客
10-21 170
这道题有两个难点。 第一个就是读懂题意，题目的意思是一群点上下左右链接就算一个点群，一个点群旋转后依然等于原点群。给你两个图，里面有很多个点群，两个图对应点群一样就算两个图一样，问你这两个图一不一样。 第二个难点就是图的同构问题（“图”指上文中的点群），主要是算图的hash值，hash值一样的就算同一个图，hash值有很多种算法，一种是算每个点到其他点的距离之和，算出来的hash是一个值，不过代码...
poj1021 概率，最小表示
浅空之下
01-16 2200
这个真的很强！网上找的： 唯一的难点是，怎么判断连成一片的棋子形状相同？ 一个基于概率的算法是：给每一颗棋子计算一个值，根据这个值是否相等来推测它所在的一片棋子的形状是否相等。计算出每颗棋子的值后对其进行排序，若两副棋盘生成的序列完全相等则推测其等价。     至于这个值如何定，我的设计为：每颗棋子在其水平方向和垂直方向与其相连的棋子总数+1（自己）。比如左图的C，这个值为水平相连2颗(AB
POJ.rar_poj
最新发布
09-19
【标题】"POJ.rar_poj" 指的是一份与编程竞赛相关的压缩文件，主要涉及POJ（Problem Overloading Judge）平台上的问题解答。POJ是一个在线的编程竞赛平台，它为参赛者提供了大量的算法题目进行练习和比赛，以提升...
poj1753枚举
05-16
该题记录了本人研究该题的记录，有些是心得，希望能给大家帮助。
poj1021-计算度
wonderwangwang的专栏
10-30 355
思路参考：http://blog.csdn.net/lencle/article/details/7206072                     http://blog.csdn.net/xinwang24/article/details/6605127 说是图经过镜像、旋转、平移变换后点的度数是不变的。因此计算第一个图中点的十字坐标上的点的个数作为其度，然后用同样的方法计算第二个
北大poj-1021
dianzhi2787的博客
04-23 223
2D-Nim Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 4066 Accepted: 1851 Description The 2D-Nim board game is played on a grid, with pieces on the gri...
POJ 1021 2D-Nim
skyword的专栏
05-12 745
链接：POJ 1021 题意：给你两个图，判定图中由字母组成的区域多边形是否一一对应相等，换句话说，图二与图一中的所有的区域多边形能建立起满射关系。 如果来自两个图的两个多边形全等（可以不位似），即可认为是一一对应了 看到这个题。。很晕。。 借鉴的网上的思路（话说怎么总遇到这种题。。自己想真是想不出好办法。。做题太少了） 对每一个有字母的点，搜索四个方位能相连成线的字母点，把能这样找到的
poj1021 约瑟夫问题 利用数学公式
wahaha1_的专栏
11-09 1403
题意：有k个好人和k个坏人 他们排成一列 并且规则是 前k个为好人 后k个为坏人 让你把后k个坏人除去 有一个条件是k个好人 都存在。 #include #include int ans[15]={0}; int main() { int k; int m=6; int pNum[30]; while(scanf("%d",&k),k)
poj 1021 java_北大poj-1021
weixin_36345268的博客
02-16 147
2D-NimTime Limit: 1000MSMemory Limit: 10000KTotal Submissions: 4066Accepted: 1851DescriptionThe 2D-Nim board game is played on a grid, with pieces on the grid points. On each move, a player may remove...
[点阵图同构 Hash] POJ 1021 2D-Nim
雯舞
02-28 571
做博弈做着做着做到了这样一道题 汗 对于每个连通块hash一下 大概有两种方法 连通块内两两距离的平方和 每个点向四个方向最多能走的距离的平方和的和 具体 我没写过
poj1021 哈希
Jacoding的博客
11-12 783
这道题在我刚学c++的时候写过一遍，然而因为代码太长了又写得很烂所以没敢交。 那时候或者是不久以前我觉得oj能ac都是一件不可思议的事情，这次也是参考了一些大神的想法，还有搜索了polyomino的问题大家在stackoverflow上的看法，然后写出来的。 其实我觉得因为我用了好多vector结构会导致变慢，但实际上ac居然0ms，不知道数据到底是怎么弄的。 主要还是哈希，每一个block
poj1021棋盘同构问题
To lose to pursue.
09-03 1344
算模拟题吧，先把两个图的所有连通分量计算出来，然后再一一配对，有一个配对不成功便返回false，配对的过程中可旋转90，180，270，360度以及上下翻折，左右翻折。 （开始没考虑翻折，导致wa了一次，调试时才发现，然后就一次AC了，数据太弱，骗分都可以过。。。） 包括调试代码总共200+行代码。第一次刷题写这么读代码阿。。汗～ AC代码(由于数据很弱故没优化，时间有点长。。。。。。囧)：
POJ 1021 2D-Nim 笔记
woniupengpeng的专栏
04-27 581
2D-Nim游戏。玩家一次可以删除某行或某列中连续的棋子，删除最后棋子的玩家获胜。给出两盘棋从2D-Nim的角度判断是否等价。
poj_1021_1
instant_noodles的博客
04-04 219
有参考：琴空 http://blog.csdn.net/lencle/article/details/7206072 #include #include #include using namespace std; int dataProcess(int a[101][101], int sum, int x[], int
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值