吴昊品游戏核心算法 Round 18 —— 吴昊教你玩Glow Puzzle（前篇）

  

  

  Glow Puzzle，又名辉光难题，欢迎来到这个非常吸引人的连接点益智游戏。是一个极其上瘾的游戏！我们的目标是连接中的所有难题点采用连续路径，但你不能重 复使用任何已完成的路径。有多达659大脑可让你在这场比赛中挑战戏弄的水平。3游戏模式可供选择：（1）经典模式，659级！（2） 挑战模式 （3）记忆模式。

   

  

如图所示，这是Glow Puzzle中的两个比较基本的问题，也就是Puzzle #1和Puzzle #3，在关卡的设计中，我们不能单单地根据顶点和边数的多少来判定这个游戏的复杂程度，有很多其余的参数需要考虑（这里我会在本期Round的之后部分说 明的）。游戏的规则类似于“七座桥问题”，也就是说，你采用一种策略，通过一笔将这幅图连续地勾勒出来，我们的要求是无重复，也就是，每条路径都恰好经过 一次。这款游戏除了画面比较绚丽以外，左右下角的两个辅助工具——左边那个当然是退回到起始的状态，而右边那个则是一盏灯，同理地，它可以提示你之后的一 些路径信息（有且仅能用一次，如果你一开始就是错的，它也会适时地指出来）

  关卡设计者的奥义

（欧拉回路的详细内容在后篇介绍）

  关于这款游戏，我们可以设计两个AI，一个为游戏的关卡设计者准备，一个为游戏的玩家准备。对于关卡设计者来说，为了让游戏变得更丰富，更有趣味性，当然 是不能过于唯一地用“胜与负”来衡量一个游戏，这样会很无聊的，我们可以增加一些小物件，使得游戏更可爱一些，如图所示：

     

  

  Glow Puzzle中可以返回三种结果，一种是GOOD WORK，代表你合格地完成了任务，FAILED代笔你没有合格地完成任务，AWESOME则代表你很“恐怖”地完成了任务。其中有两个判定点，一个是你 可以从起始点回到起始点，而不是除了起始点以外的另外一个点，这当然是其一，其二，代表你的速度足够地快，按照相关的算法可以计算出一个你所得到的返回分 数。
  对于关卡设计者来说，我们判断一个关卡是否是合理的，则要看它是否可以让玩家完成任务（同时还要一定程度地考虑一个关卡的难易程度）

  首先，我们还是来解决一个最基本的问题，就是判定，需要用到的数据结构有：并查集+欧拉回路。

  并查集奥义

  对不相交集合进行俩种操作：

  1．  检索某元素属于哪个集合

  2．  合并两个集合

  我们最常用的数据结构是并查集的森林实现，也就是说，在森林中，每棵树代表一个集合，用树根来标识一个集合，树的形态不重要，重要的是每棵树有哪些元素。

  查找操作

  查找一个元素v很简单，只需要顺着叶子到根节点的路径找到u所在的根节点，然后把v到u的路径上面的结点的父节点都设置为根节点，这样减少了查找的次数(路径压缩)。

  合并操作

  为了把两个集合s1和s2并起来，只需要把s1的根的父亲设置为s2的根节点，我们可以做一个优化，将深度小的合并成为深度大的子树，这样子查找的次数少些。

 

 

  

并查集的实现

 

 1  /* 初始化集合*/
 2  void Make_Set(int x)
 3   {
 4       father[x] = x; //根据实际情况指定的父节点可变化
 5       rank[x] = 0;   //根据实际情况初始化秩也有所变化
 6  } 
 7 
 8 
 9 /* 查找x元素所在的集合,回溯时压缩路径*/
10 
11  int Find_Set(int x)
12 {
13 
14      if (x != father[x])
15 
16      {
17 
18        father[x] = Find_Set(father[x]); //这个回溯时的压缩路径是精华
19      }
20      return father[x];
21  }
22 
23 
24 //将秩小的合并到秩大的集合中
25  void Union(int x, int y)
26  {
27      x = Find_Set(x);
28      y = Find_Set(y);
29      if (x == y) return;
30      if (rank[x] > rank[y]) 
31      {
32          father[y] = x;
33      }
34      else
35      {
36          if (rank[x] == rank[y])
37          {
38              rank[y]++;
39          }
40          father[x] = y;
41      }
42  }

 

 

  

 判断关卡是否合格的AI实现

   这个AI很简单，输入先是一张无向图的点数和边数（N，M），后面则是M条对应的边，每条边用两个对应的端点表示。在输出中，我们用1表示关卡合格，用0 表示关卡是不合格的(在AI中充分利用了并查集的上述两个函数，也就是查找函数和合并函数，建立欧拉回路的过程是在主函数给出的)。实际上，在一笔画判定 的函数中，该AI过于严格，更好的可以在之后进行改进。

 

 1  #include<iostream>
 2  using namespace std;
 3  
 4  //读入每个结点的度，由于是无向图，不计入度和出度
 5  int degree[1001];
 6  //制造一个游戏界面
 7  bool map[1001][1001];
 8  
 9  int node[1001];
10  int size[1001];
11  
12  int a,b,n,m;
13  
14  //找到那个结点的祖先(查找函数)
15  int find(int x)
16  {
17    //表示已经找到祖先结点了
18    if(node[x]==x) return x;
19    //每次递归,直到找到祖先结点
20    else return node[x]=find(node[x]);    
21  }
22  
23  //合并函数
24  void combine(int a,int b)
25  {
26    int ka=find(a);
27    int kb=find(b);
28    //如果不是一个祖先的话,将轶小的合并到轶大的集合中
29    if(ka!=kb)     
30    {
31      if(size[ka]>size[kb])
32      {
33        node[kb]=ka;
34        size[ka]+=size[kb];                     
35      }               
36      else
37      {
38        node[ka]=kb;
39        size[kb]+=size[ka];    
40      }
41    }
42  }
43  
44  int main()
45  {
46    //遇到0就退出
47    while(cin>>n&&n)
48    {
49      cin>>m;
50      //将点和地图清零
51      memset(degree,0,sizeof(degree));
52      memset(map,0,sizeof(map));
53      //建立每个点
54      for(int i=1;i<=n;i++)
55      {
56        //最开始的祖先结点是自己
57        node[i]=i;
58        size[i]=1;        
59      }           
60      while(m--)
61      {
62        cin>>a>>b;
63        //每次对两点加入边
64        if(map[a][b]==0)  
65        {
66          degree[a]++;
67          degree[b]++;
68          //标记一条边
69          map[a][b]=map[b][a]=1;
70          combine(a,b);                  
71        }        
72      }     
73      //找到祖先结点(任意一个点的)
74      int k=find(a);
75      bool flag=true;
76      for(int i=1;i<=n;i++)
77      {
78       //判定欧拉回路可以实现的充要条件为：（1）连通（2）每个结点度都是偶数（3）每个结点都有共同的祖先结点
79        if(degree[i]&1||degree[i]==0||find(i)!=k)
80        {
81          flag=false;
82          break;                                         
83        }        
84      }
85      if(flag) cout<<"1"<<endl;
86      else cout<<"0"<<endl;
87    }
88    return 0;    
89  }

 

 

  

那么，有了这个AI，我们就可以基本地判定出这个游戏是否是关卡合格的了。注意到这个if条件句，过于严格：  if(degree[i]&1||degree[i]==0||find(i)!=k)， 这里，可以将if条件句中的第一个条件弱化成“允许两个点的度为奇数”，这样的话，仍然是可以满足关卡的要求的，只是如果这样的话，就不能让起始点和终结 点都是相同的点了，这两个点必须不同。那么，我们可以先用上面一个AI判定出一些“具有AWESOME答案”的关卡，然后，再用改进的AI例程给出一些 “最终只能到达GOOD WORK”这个级别的答案。

  我们如何判定一个关卡的难易程度呢？一般情况下，当然，边数和点数越多，关卡应该更难一些，但是，这也不一定。我觉得，参数应该更多一些，比如，挂卡输入到AI中的运行时间，这就是一个不错的判定，毕竟，计算机只是比人要做的更快一些罢了。

  进一步地

  我们对关卡的设计给出更高的要求，比如，我们希望加大难度，但是，我们以一种“另外的方式”进行难度的加大，我们不再苛求要一笔解决问题，我们用两笔，或 者N笔解决问题。那么，游戏的难度确实加大了，加大的同时，我们甚至不认为它加大了，因为，我们有几次的重复，这样，使得游戏也变得更有意思了。

  这个AI，我们仍然按照原来的方式输入一个地图，只是返回的值不再是0和1，我们返回一个最小的笔画。

  公式：

  （a）如果是个欧拉回路一笔就可以完成。

  （b）笔划数=奇度数/2。

  （c）总之笔划数 = 奇度数%2 + 欧拉回路数。

  这里，对于每个连通集，用STL中的向量容器来装填。

 

 

  

这里的统计也很严格，所谓的欧拉回路，也是当起始点和终止点为同一个点的时候才算的。另外，由于关卡只要求将边完全地遍历，而没有必要考虑点，所以，孤立点可以不考虑，就让它孤立吧！

 

 1    #include <iostream>
 2  #include <stdio.h>
 3  #include <memory.h>
 4  #include <vector>
 5  
 6  #define maxn 100005
 7  #define maxm 200005
 8  
 9  using namespace std;
10 
11  int father[maxn],m,n,used[maxn],odd[maxn],deg[maxn];
12 
13  //初始化函数
14  void init()
15  {
16    int i;
17    //表明
18    memset(used, 0, sizeof(used));
19    //顶点度数的统计
20    memset(deg, 0, sizeof(deg));
21    //统计各个欧拉回路的祖先结点为奇数点的情况
22    memset(odd, 0, sizeof(odd));
23    for (i = 1; i <= n; i++)
24      father[i] = i;
25  }
26 
27  //查找函数
28  int find (int x)
29  {
30    if(father[x] != x)
31      father[x] = find(father[x]);
32    return father[x];
33  }
34 
35  //建立并查集，归并祖先结点
36  void make (int a,int b)
37  {
38    int x = find(a);
39    int y = find(b);
40    if (x != y) father[y] = x;
41  }
42  
43  int main()
44  {
45    int a,b,k;
46    //利用向量容器装填不同的欧拉回路
47    vector <int> t;
48    //每次读入一个样例
49    while (scanf("%d%d",&n,&m)!=EOF)
50    {
51      init();
52      //清空向量容器
53      t.clear();
54      int count = 0;
55      //读入所有的边
56      while (m--)
57      {
58        scanf("%d%d",&a,&b);
59        //两个点的度数自增
60        deg[a]++;
61        deg[b]++;
62        //归并这两个点
63        make (a,b);
64      }
65      for (int i=1; i<=n; i++)
66      {
67        //找到一个祖先结点
68        k = find(i);
69        //如果那个祖先结点还没有使用过
70        if (!used[k])
71        {
72          //进入容器
73          t.push_back(k);
74          //标记为已经使用了
75          used[k] = 1;
76        }
77        //如果存在结点是奇点，则odd[k]++
78        if (deg[i] & 1)
79          odd[k]++;
80      }
81      int sum = 0;
82      //对每个欧拉回路进行遍历
83      for (int i=0; i<t.size(); i++)
84      {
85        k = t[i];
86        //如果该集合在孤立点的话，则继续，因为，只需要遍历所有的边就可以了
87        if(deg[k] == 0) continue;  
88        //如果该集合是欧拉回路，则有一条路
89        else if(odd[k] == 0) sum++;
90        //否则，加上odd[k] /2     
91        else sum += odd[k]/2;
92           }
93           printf("%d\n",sum);
94              
95     }
96     return 0;
97 }