HDU3926 Hand in Hand, 图形同构判断

最新推荐文章于 2020-08-01 11:34:23 发布

原创最新推荐文章于 2020-08-01 11:34:23 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#图形 #list #graph #struct #email

HDU 同时被 2 个专栏收录

60 篇文章

订阅专栏

图论

14 篇文章

订阅专栏

本文介绍了一种用于分析图结构的算法，该算法能够识别图中的链和环，并通过深度优先搜索来确定图的具体组成结构。通过对两个图进行比较，可以判断它们是否具有相同的链和环结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

图形比较特殊, 每个点的度最大是2, 故图形由链(list)和圆(circle), 其中度为0的点归为链.

由此, 我们可以对每个点进行DFS, 判断这个点所在图形是链还是圆.

然后就可以根据两个图的链的数目是否相等, 链的节点是否相等; 圆的数目是否相等, 圆的节点是否相等.

/*******************************************************************************
 # Author : Neo Fung
 # Email : neosfung@gmail.com
 # Last modified: 2012-02-05 21:14
 # Filename: HDU3926 Hand in Hand.cpp
 # Description : 
 ******************************************************************************/
#ifdef _MSC_VER
#define DEBUG
#endif

#include <fstream>
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <string>
#include <limits.h>
#include <algorithm>
#include <math.h>
#include <numeric>
#include <functional>
#include <ctype.h>
#include <vector>
#define MAX 10010
using namespace std;

bool inline cmp(const vector<int> &lhs,const vector<int> &rhs)
{
  return lhs.size()<rhs.size();
}

struct GRAPH
{
  vector<int>  adj[MAX],list[MAX],cirle[MAX];
  bool used[MAX];
  bool visit[MAX];
  int n,lcnt,ccnt;

  void init(const int &t)
  {
    n=t;
    lcnt=ccnt=0;
    memset(visit,false,sizeof(visit));
    memset(used,false,sizeof(used));
    for (int i=0;i<MAX;++i)
    {
      list[i].clear();
      cirle[i].clear();
      adj[i].clear();
    }
  }

  void add_adj(const int &x,const int &y)
  {
    used[x]=true;
    bool  flag=true;
    for(size_t i=0;i<adj[x].size();++i)
      if(adj[x][i]==y)
        flag=false;
    if(flag)
      adj[x].push_back(y);
  }

  bool dfs(const int &u)
  {
    visit[u]=true;
    list[lcnt].push_back(u);
    cirle[ccnt].push_back(u);

    bool flag=true;
    for(size_t j=0;j<adj[u].size();++j)
      if(!visit[adj[u][j]])
        flag=false;

    if(flag)
      if(adj[u].size()==1)
        return false;
      else
        return true;

    bool ans=false;
    for(size_t j=0;j<adj[u].size();++j)
      if(!visit[adj[u][j]])
        ans = ans||dfs(adj[u][j]);

    return ans;
  }

  void func()
  {
    for(int i=0;i<MAX;++i)
    {
      if(!visit[i] && used[i])
      {
        bool ans=dfs(i);
        if(!ans)
        {
          cirle[ccnt].clear();
          ++lcnt;
        }
        else
        {
          list[lcnt].clear();
          ++ccnt;
        }
      }
    }
    sort(list,list+lcnt,cmp);
    sort(cirle,cirle+ccnt,cmp);
  }
};

bool check(const vector<int> *lhs,const int &lcnt,const vector<int> *rhs,const int &rcnt)
{
  if(lcnt!=rcnt)
    return false;
  for(int i=0;i<lcnt;++i)
    if(lhs[i].size()!=rhs[i].size())
      return false;
  return true;
}

int main(void)
{
#ifdef DEBUG  
  freopen("../stdin.txt","r",stdin);
  freopen("../stdout.txt","w",stdout); 
#endif  
  int ncases,n,m;
  int a,b;
  GRAPH lhs,rhs;

  scanf("%d",&ncases);
  for(int nc=1;nc<=ncases;++nc)
  {
    
    scanf("%d%d",&n,&m);
    lhs.init(n);
    while(m--)
    {
      scanf("%d%d",&a,&b);
      lhs.add_adj(a,b);
      lhs.add_adj(b,a);
    }
    lhs.func();

    scanf("%d%d",&n,&m);
    rhs.init(n);
    while(m--)
    {
      scanf("%d%d",&a,&b);
      rhs.add_adj(a,b);
      rhs.add_adj(b,a);
    }
    rhs.func();

    bool ans=check(lhs.list,lhs.lcnt,rhs.list,rhs.lcnt) && 
      check(lhs.cirle,lhs.ccnt,rhs.cirle,rhs.ccnt);

    printf("Case #%d: ",nc);
    if(!ans)
      printf("NO\n");
    else
      printf("YES\n");

  }


  return 0;
}