想看本篇文章英文版的點擊這里，收到谷歌 hr 郵件的我心血來潮，寫了篇英文版的，雖然中國朋友都不愛看（我知道）。。。
這是我的算法課的第三個 project，第二個在這里。為什么我連學校的 project 都拿來寫文章分析呢。因為這課算是我研究生階段最難的課之一，布置的 project 也都是 NPC 級別的，這個沒有 NPC，也有 NP-intermediate 了，所拿來分析分析，總結一下經驗，還是很有幫助的。我學什么都非常講究方法，我個人覺得方法比努力重要，就像選擇比努力重要一樣。當然不努力也白搭。。
Requirement
我已經把我們 project 的要求放在了 Github上。 如果你想自己嘗試一下，你可以點擊 這里，做一做我們學校的作業，你如果感興趣，我可以把我們學校的所有課程內容發給你哈。
當然 source code 也放在 Github上了。
圖同構問題
最上面顯示的那個就是最經典的圖同構問題的模型。目前最快的圖同構問題解決方案是 NAUTY，就用到了這個模型，很眼熟吧？
其實這個問題在現在的計算機界或者數學界，反正什么屆里都還算是一個未能完全解決的問題。在 wikipedia 上還有這么個問題呢：
Unsolved problem in computer science:
Can the graph isomorphism problem be solved in polynomial time?
我才疏學淺，不討論那些高深的話題，我只講一講最基礎的實現方式，用 backtracking，然后檢查是否符合要求。
基本思想是檢查兩個圖中的每個點是否相對應。也就是說，圖p中的 A 點和 B 點間有一條邊，那么圖g中也得有這么兩個點，M 和 N 間有一條邊；如果圖p中 A 和 B 間沒有邊，那么圖g中相對應的那兩個點，也不可以有邊。用 backtracking 遍歷每種情況，然后 checkEdges()。下面是偽代碼
bool DFS(int n, int level, int[][] graph1, int[][] graph2, int[] used, int[] perm) {
bool result = false;
if (level == -1) {
result = checkEdges(n, graph1, graph2);
} else {
index i = 0;
while (i < n && result == false) {
if (used[i] == false) {
used[i] = true;
perm[level] = i;
result = DFS(n, level - 1, graph1, graph2, used, perm);
}
i++;
}
}
return result;
}
檢查是否相同：
bool checkEdges(int n, int[][] graph1, int[][] graph2) {
bool same = true;
for x = 0 to n - 1 {
index y = 0;
while (y > 0 && same == true) {
if (graph1[x][y] != graph2[perm[x]][perm[y]]) {
same = false;
}
y++;
}
}
return same;
}
這個算法的時間復雜度是 O(N2*N!)，N 是頂點的數量。
Girth of Graph
不知道怎么翻譯，就用 Girth 吧。反正就是在一個圖中存在的最小圓環。我們老師 pdf 上的定義是：
The shortest cycle in a graph G is called the girth of G.
如果我們把圖用樹的結構樣式畫出來，那么其實就很容易看出來怎么求那個小圓環了。比如下面這個小圖：
我們可以畫一棵相應的小樹：
其實這里我們就能看出來，2 這個點是4和6的共同的孩子節點。那么我們只要 bfs 遍歷這棵樹，找到這個共同的節點就好了。用一個 label[] 去標識走過的點，2會走兩遍，第二次經過它的時候就知道它這里有個環了。
因為我用的 swift 做 project 的，所以我用的是 array 來做的。我刷 leetcode
用的是 java。 C++ 太麻煩了，還是不用了。。因為我們老師還要我們 plot 出不用節點數的圖的時間的 performance。。。Swift 還有個好處就是我可以用 iOS 作圖，比較方便。而且 swift 的 array 可以當 linkedlist 用。但是我們還是可以做一個 node 來存儲沒個點的深度信息 depth。
class Node {
public int vertex, depth;
public Node(int vertex, int depth) {
this.vertex = vertex;
this.depth = depth;
}
}
其實用什么語言都無所謂，如果你用 java，你可以用 ArrayDeque(), 或者LinkedList()，C++ 的話可以用 std::queue<int>，都差不多。下面是 bfs 遍歷的主要過程：
while(node != null && short > 3 && (node.depth + 1)* 2 - 1 < short)
{
int depth = node.depth + 1;
for (int neighbor in node.vertex’s all neighbor)
{
// if we haven’t went through this neighbor
if (label[neighbor] < 0) {
queue.add(new Node(neighbor, depth));
label[neighbor] = depth;
} else if (label[neighbor] == depth - 1) {
// odd neighbors
if (depth * 2 -1 < short)
short = depth * 2 - 1;
} else if (label[neighbor] == depth) {
// even neighbors
if (depth * 2 < short)
short = depth * 2;
}
}
// go another node
node = queue’s first element, and remove the first element;
}
// start a new bfs from another vertex
remove all elements from queue;
root++;
我們都知道 bfs 的時間復雜度是 O(m + n)，其中m和n分別是點和邊的數量。因為這個算法需要嘗試每個點作為root，從每個點都出發做一次 bfs 尋找最小圈，所以外層還有個循環，while(root < n - 2 && short > 3). 所以時間復雜度是 O(n * (m + n))。
