UVA - 1572 Self-Assembly

/*
  这题查了很多题解和资料，磕磕碰碰，画图和举各种例子，才终于想明白了...
  
  虽然代码确实很短，但是也确实很难想啊...根本没有想到，能把它和拓扑排序联系起来...
  
  以及，分别用 2n 和 2n+1，表示 A+ 和 A- 等这样的一对一对，也是很棒的处理方式啊！~
  
  而且，用异或来实现，将一条边，转换为与它拼接的边，十分精妙啊！
  
  我记得之前学古文时，有听过一句话是“斯言甚善,余不得赞一词”，这道题的代码，也是给我这么经验的感觉...甚是精妙，简直想不到，居然有人能想出这么妙的方法！ T^T 让这么抽象的问题，居然能够用这么简短的代码就解决了，实在让人叹服
  
概括一下思路：(小白书P173)
把标号看成点，正方形看作边，得到一个有向图。当且仅当图中存在有向环时有解。只需要做一次拓扑排序即可
  
分析：
//分析截取了我认为，我最容易理解的一份题解( 来自： http://www.cnblogs.com/AOQNRMGYXLMV/p/4257692.html )

首先因为可以旋转和反转，所以可以保证在拼接的过程中正方形不会自交。

把边的标号看成点，将正方形的边界A+变成B+可以看做是一条边。比如说，一个正方形中有A-和B+两条边，则A-与其他正方形中A+结合后，结合前边界为A+，结合后变为B+。

这样就得到图中的一条有向边A+ → B+

如果能在图中找到一个环，则可以无限循环拼接正方形。
-------------------------------------------------------------------------------------------------------------------------
<BTW 我自己再做一个不太恰当，但是能辅助理解的小注解>
A+ -> B+ 的含义为，正方形有两条边A-和B+，前一边是和 A+ 相接，后一边就是 B+ (我表述得不太清楚，因为该题实在比较抽象)
再结合一下找到有向环的条件，就会发现，其实也还是可以理解的，但是需要多想一段时间)

啊，突然想起，可以再举一个例子帮助理解：
在这个例子里，A+ 表示的是前哨兵的 v
< 之前好像在哪里看到过“哨兵”这个说法，当时记得好像说，哨兵一般不是真正存在的，只是为了我们处理方便，人为加上的。如果我记忆有误，我就换个定义 >
这里的 A+ 表示的是，如果还有别的正方形 [用正方形 X 代替]，和这个同时具有 A- 和 B+ 边的正方形 [用正方形 Y 代替]相接，那么 正方形X，肯定是用 边 A+去和 正方形Y相接，连接完以后，就建立了边 A+ -- B+ (联系它的具体意义，就比较容易理解，判断是否成环的条件，为何应该那样去写)

同理，正方形的其他边也是这么处理的，每个正方形都要这么处理一次，
然后才能找，是否成环，若能成环，考虑到给我们的正方形都是无限个的，就能知道，成环的那个环里，我们可以按照它的连接规律，无限次扩倍，也就是说，能够组成一个无限大的结构了
*/

/*
  附上看过的其他题解，这些题解也一定程度上帮助了我理解：
  http://www.cnblogs.com/AOQNRMGYXLMV/p/4257692.html
  上面的链接是对我的理解，帮助最大的
  
  下面的链接，也都有或多或少的启发：
  http://www.cnblogs.com/dwtfukgv/p/5580438.html
  http://m.blog.csdn.net/peach_yang/article/details/52708493
  http://blog.csdn.net/cFarmerReally/article/details/52128447
  http://m.blog.csdn.net/qq_38069256/article/details/70246553
  http://blog.csdn.net/tt2767/article/details/47027495
  http://blog.csdn.net/u014800748/article/details/44830923

*/

#include <iostream>
#include <vector>
#include <cstring>
#include <cstdio>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const int N = 26 * 2;

int G[N][N];
int c[N];

int ID (char a1, char a2)
{
	return (a1 - 'A') * 2 + (a2 == '+' ? 0 : 1);
}

void connect (char a1, char a2, char b1, char b2)
{
	if (a1 == '0' || b1 == '0') return;
	int u = ID ( a1, a2 ) ^ 1, v = ID ( b1, b2 );
	G[u][v] = 1; 
}

// 当且仅当u能形成一个环路时，返回 true 
bool dfs ( int u )
{
	c[u] = -1; // visiting
	rep(v, 52)
	if ( G[u][v] )
	{
		if (c[v] < 0) return true;
		if (!c[v] && dfs(v)) return true; // 原来没被遍历的结点，经过遍历后，能形成环路 
	}
	c[u] = 1; // vistied
	return false;
}

bool find_cycle()
{
	memset(c, 0, sizeof(c));
	rep(i, 52)
	{
		if (!c[i])
		if ( dfs(i) ) return true;
	}
	return false;
}

int main()
{
	int n;
	while (cin >> n && n)
	{
		memset(G, 0, sizeof(G)); //务必记住：多组数据时，记得每次都要清空数组！！！因为这个点又忽视了，又WA了...
		while (n--)
		{
			string s;
			cin >> s;
			
			rep(i, 4) 
			rep(j, 4)
			if (i != j) 
			connect( s[i * 2], s[i * 2 + 1], s[j * 2], s[j * 2 + 1] );
		}
		if ( find_cycle() ) cout << "unbounded";
		else cout << "bounded";
		cout << endl;
	}
	return 0;
}