按道理來說，這種 board game 是比較合我胃口的：做工精美，人物豐富，老少咸宜。但不知怎的就是提不起興趣去玩好。

忽然一驚，以前的自己對這種東西可是很著迷的，睡覺想，上課想，但現在，竟然不 fancy 了。

突然覺得以前大人所說的三分鐘熱度，不是什麼壞東西。世上的東西那麼多，值得研究的千千萬，可以學習的萬萬千。三分鐘熱度，說明你能對一樣東西提起興趣；三分鐘熱度，不至於讓你以生之有涯，去花在學之無涯。最重要的，還是保持對萬事萬物的好奇之心，自己覺得喜歡的，大可不必在意旁人的眼光，而自己決定是否要花時間在上面。沉迷於一樣東西的感覺也是很好很妙的，它可以讓你廢寢忘食，它可以讓你如痴如醉。即使時間很短，但事半功倍，往往效率很高地能在很短時間內達到業餘的水平。最後，把自己的才智與時間花在有興趣的東西上，豈不妙哉？

三分鐘熱度，可以保持人的敏感性。這樣才能多嘗試不同事物，最終找到不是“三分鐘熱度”而是三年，三十年熱度的東西的幾率也就大大增加了，興趣也就自然廣泛。

希望我繼續多一點三分鐘熱度。

iPhoto has one thing that drives me nuts: one cannot export photos in folder/album while keeping the hierarchy!
This is very useful when your want to export them to some external device, say, a digital photo frame.

I did some search and found that people are using some cumbersome trick, i.e., to batch rename the photos with prefix of the event, export, and then move the photos with the same prefix into folders with the prefixes. This is not so elegant because people may want to give meaningful name the photos and this will certainly destroy it.

So I wrote this little script to make life easier. Extract it and drag to ~/Library/Services. This will add it as an service of iPhoto. Now you can just select an album and choose

‘iPhoto -> Service -> Export Album’

then select a folder to export to. Enjoy!

完整的 log 在這裡：https://gist.github.com/1344235

大事：
Apple CEO Jobs 辭世
C 語言創始人之一，UNIX 创造者之一 Dennis Ritchie 辭世
以上兩個都不多說了，無法盡言。

瑣碎：
今年忘記關注圖靈獎了。後來發覺 Leslie Valiant 是得獎者。
剛好在上 Machine Learning，有學到他提出的 PAC, 以及一篇影響深遠的paper “A theory of learnable”.
之前在做 approximation algorithm 的時候，也拜讀過他關於 network reliability 與 counting 的複雜度文章。

一間 local guitar store 促銷，入了一把 American Standard Stratocaster，我最喜歡的 3-color sunburst!

訂了回國機票。

(完)

他們沒留言給我，倒是我表弟留言給我，說已經在大學城上學了。突然覺得時間過得很快，當年我在北中上學的時候，他還在小學。現在他已然從北中畢業並且上大學了。

隨便說了幾句話，由於他有事要走了，於是便準備道別。最後他說，“哥哥，我想你了”。

雖然是很普通的一句話，不過由於從一個男性口中發出，不由得讓我感到很肉麻…… 但是同時也感到很溫馨。

父母從來都不是善於表達感情的人，潛移默化，我甚至也沒對他們說過一句“想你”的話，更無論其他人。

也許表弟比我更善於表露感情罷了。但換過來想，如果這句話由我口中冒出，也許那已經是我情感近乎崩潰的時候，說出這句話的時候，必然正是淚流滿面。

來美國不知不覺已經一年有餘，果然是人越大越心煩，因為要處理的事情越來越多。特別是在異國他鄉，事無鉅細，都要自己一人包辦。

房租、電話、銀行、網絡、水電、油費、騎車、課程、研究，單單是 name 已經可以 name a few，繼續 enumerate 下去可以嘮叨一天。

於是忙得甚至沒有時間去寫篇 blog，於是忙得週末從來也不出門，於是忙得一星期也沒有彈一次琴打一次球，於是忙得一星期也沒有關心家人一次。

一直很怕跟人 keep in touch 會浪費時間，這也的確如此。我相信五分鐘已經可以讓對方感覺到你在關心他，但理想狀況往往達不到，往往需要半個小時才能把近況說清楚。

而家人與朋友那麼一大把，實在很難勻出時間來分給他們。不是我自私，而是實際情況就是這樣的。感覺給家裡電話、視頻已經是我的極限。

所以我的朋友們，不是我我不關心大家，而是家人已經優先了。

於是朋友大概會越來越少罷。

Last semester I wrote an survey for the problem as a project in Approximation Algorithm course. The article introduces three methods for the problem, all of them utilize Monte-Carlo as the basic framework.

1. R. Karp and M. Luby’s Monte Carlo [Karp and Luby]
R. Karp and M. Luby showed that Monte Carlo algorithm is an FPRAS (Fully polynomial time randomized approximation scheme) when the number of samples are sufficiently small. Furthermore, the number of samples are linear to the ratio of the size of positive samples and size of the sample space. Hence, how to formulate the sample space becomes the most important problem. They proposed several methods, which includes K-separating cuts, paths and cycles, and finally walks. The first two modeling is straightforward and easy to understand, however it utilized some false assumptions. The last one makes the Monte Carlo truly FPRAS. But personally I found it very hard to follow, and impractical.

2. Karger’s alpha-Minimum Cut method [Karger FPRAS]
I have to say this is an interesting and clever method. First note that the network breaks only when the failure edges are in one of the cuts. He showed that only small cuts are vital when computing the failure probability. Here `small cuts’ can be interpreted as the set of min cuts and `near’ min cuts. In another Karger’s paper, he showed that these cuts can be found can be found in polynomial time and the number is polynomial [Karger min cut] (very interesting algorithm, highly recommended). Hence, the problem can be reduced to DNF counting:

We assign a boolean variable xe to each edge e, where xe = true if e fails and false otherwise. For the ith small cut c_i, it disconnects the network if and only if all of its edges fail. Let F_i be the conjunction of all x_e, for all e in c_i. Clearly F_i is true if and only if c_i fails. Hence, the event that some small cuts fail can be written as F = disjunction of all F_i. We want to know the probability that F is true, which is clearly the failure probability of the network. Note that F is in disjunctive normal form, and the number of clauses in F is exactly the number of small cuts, which is a polynomial. There is a FPRAS for the DNF counting problem, which also uses Monte-Carlo. It is straight-forward now.

3. Zenklusen’s FPRAS for s-t reliability problem on acyclic network [Zenklusen]
This is a relatively new result. The basic idea is, in a DAG, one can compute the mean number of intact path between s and t after the failure process. In a highly unreliable network, this number is a good estimate for the s-t reliability. Monte Carlo is used to estimate the ratio between reliability(s,t) and the mean number of intact s-t paths. He showed that the s-t paths can be sampled in linear time.

[Karp and Luby]: Monte-carlo algorithms for the planar multiterminal network reliability problem.
[Karger FPRAS]: A randomized fully polynomial time approximation scheme for the all-terminal network reliability problem.
[Karger min cut]: An O~(n^2) algorithm for minimum cuts.
[Zenklusen]: Combinatorial methods for analyzing network security and reliability

—-

I decided to release my manuscript from CS598: Approximation Algorithms, which is a survey on network reliability problem. I am not an expert on approximation algorithm, and my writing may not be so great. For any mysterious or unclear part, please refer to the original papers.

The file can be downloaded from here. The password is ‘cs598′. If this document is of any help, please give appropriate citation in your work.

For example, the active point and end point concepts are very important. It is defined as ‘the first non-leaf node’. However it is not actually a node when you are looking at the tree, because there may be some ‘implicit nodes’, which you cannot find anywhere when you draw a tree. Indeed, it should be viewed from the suffix’s point.

I have to read his source code to completely understand how it works. To better demonstrate, I designed the following example to illustrate the algorithm.
This is how the algorithm works step by step when the input string is ‘cacao’. Hope this helps.

Other useful resource include this tutorial and online suffix tree computation form. Here’s an excellent java applet that can generate the suffix tree on the fly. Finally, another detailed tutorial is given by Prof Sartaj Sahni, but I found the presentation introduced lots of symbols and quite hard to follow. A lecture note from Prof. Shaojie Zhang is written clearly, though not many details given.

Here is some points that I want to clarify about the algorithm and suffix tree, assuming you know how a suffix tree looks like:
- Intuitively, suffix tree is a compressed trie. You can construct it trivially by inserting each suffix one by one into a trie tree, then compress it. However, this takes quadratic time.
- To speed up, people proposed different approach. A little history from wikipedia:

The concept was first introduced as a position tree by Weiner in 1973, which Donald Knuth subsequently characterized as "Algorithm of the Year 1973". The construction was greatly simplified by McCreight in 1976, and also by Ukkonen in 1995. Ukkonen provided the first online-construction of suffix trees, now known as Ukkonen’s algorithm, with running time that matched the then fastest algorithms.

Ukkonen is the easiest to understand and it is on-line. Most people should be using this one.

- The basic idea of the algorithm is, given an string S[1..n], we process the characters one by one. We extend the previously inserted suffix by adding the current processing character to them. For example, suppose we are given ‘cacao’. When we are processing ‘o’, the existing suffix is ‘caca’, ‘aca’, ‘ca’ and ‘a’. We want to append ‘o’ to each of them.
- For character S[i+1], the current suffices are S[j..i], where j=1..i. In the current tree we trace a path that contains substring S[j..i]. Note that this path may stop at an edge (implicit node), an explicit node or leaf node. There are basically three case when you want to insert a character for suffix S[j..i],
1. There is already a path from the end of S[j..i] that starts with S[i+1], or S[j..i+1] corresponds to a path. We do nothing. This in fact introduce an implicit node.
2. S[j..i] ends at a leaf, simply append S[i+1].
3. No path from the end of S[j..i] starts with S[i+1]. Split the edge at the branching position, and add a new leaf with S[i+1]. Note that this is the ONLY case that will introduce new leaf.
- However, the above method has to go through all suffices at each iteration, still quadratic time.
- The speed up and memory reduction come from the following important observations and techniques:
1. We only have to consider the suffices between the Active Point and End point at each iteration. It can be shown that suffices outside this range are already at leaf nodes, and hence require do nothing (See Case 1). Furthermore, the end point will be the active point at the next iteration.
2. We introduce a suffix pointer for each internal node (non-leaf non-root) node, which points to a node that contains the Longest Proper Suffix of the current suffix. For example, the longest proper suffix of "cacao" is "acao". With this technique, we don’t need to search for the node that contains the next suffix from root every time, instead, we jump from the just processed one to the next one, e.g., from "cacao" to "acao".
3. We don’t need to actually store the substrings in the nodes, we just need to know the index of the starting and ending characters. Hence, we actually do nothing when encounters Rule #2.
4. We can use hash table to store the edges, which can help inserting, removing and finding edges in constant time. The details can be found in Mark’s algorithm implementation, and the comparison in the wiki.
- Intuitively, the active point is the first suffix that requires you to do something, that is, when encounters Rule #3. The end point is the first suffix that you should do nothing again, i.e., when we encounters Rule #1 or Rule #2 again when processing the active point during the iteration.
- To avoid a suffix being a prefix of another suffix, the last character in the string must be unique. In general, we can just append a special character that is not in the vocabulary, e.g., the ‘$’ used in the example. For example, ‘book’ does not need to append since ‘k’ is unique, but ‘banana’ needs since ‘a’ is not unique. In this case, after the algorithm terminates, there will be exactly |S| + 1 leaves in the tree, one for each suffix, or, all the suffices end at leaf!

Important application of suffix tree includes:
- Find a substring P in S in O(|P|) time. Note that other linear algorithm such as KMP requires O(|P|+|S|). When there are multiple Ps, suffix tree is more efficient.
- Find the longest common substring (LCS) between P and S. We can construct a suffix tree for string P#S$, where ‘#’ and ‘$’ are two characters that are not in the vocabulary. To find the LCS, we traverse the suffix tree and sum up the number of characters visited for each internal node. Then, an internal node that has the largest sum and has at least one leaf node that represents the suffix of P and S, respectively, is the desired node. This can be done in O(|P|+|S|) time. Note that the typical solution, i.e., dynamic programming, requires O(|P||S|) time. This can be extended to a more general case where there are multiple strings S1, S2, …, Sn. And the runtime is the sum of the lengths of the strings.
- Find the longest palindrome in S. Here is one excellent article in Chinese. The basic idea is, let P be the reverse of S, construct suffix tree for S#P$. Then for each S[i], find the largest Least Common Ancestor of S[i], S[n-i+1] (even length) and S[i+1], S[n-i+1] (odd length). LCA can be done in linear time using Tarjan’s algorithm.
- Given a set of strings S1, S2, …, Sn, find all the Si such that Si contains pattern P. This is a typical application in computational biology. The set of strings are gene banks, the pattern is a gene segment. Let T=S1#S2#…#Sn$. This is called a multiple string suffix tree. To find all the Si that contains P, we walk down from root according to P. If we cannot complete a path that represents P, no string contains P. Otherwise, we will stop at a node N, then from its leaves we can know what strings Si contains P. A special case is that N is a leaf node, which means only one string contains P. To speed up, we can maintain a list of indices of Si for each node, which lists all the Si that are a start point of the suffices in the leaves.
- Refer to this and this for more detail.

The problem is that MacOS X’s default filesystem changes all filenames you give it to an unusual normalization form which does not use precomposed characters.

根据 Python unicodedata 的文档 [2]：

The Unicode standard defines various normalization forms of a Unicode string, based on the definition of canonical equivalence and compatibility equivalence. In Unicode, several characters can be expressed in various way. For example, the character U+00C7 (LATIN CAPITAL LETTER C WITH CEDILLA) can also be expressed as the sequence U+0327 (COMBINING CEDILLA) U+0043 (LATIN CAPITAL LETTER C).

其中的 U+00C7 是 ‘Ç’

对应的 python 源代码我也更新了。

请参考：
[1] http://stackoverflow.com/questions/6803621/how-to-prevent-the-command-line-argument-from-being-encoded/6809703#6809703
[2] http://docs.python.org/library/unicodedata.html#unicodedata.normalize

#!/usr/bin/env python
import sys
for i in sys.argv[1:]:
print i.decode(‘utf8′).encode(‘latin-1′).decode(‘gbk’)

PS. 不知道为什么我用网上介绍的 convmv 做不出来。