最近还是算比较忙的，没想过弄一个网站可以刷paypal的东西还有这么多讲究。。 好久没碰HTML了，啊哈哈，上个礼拜改公司网站，弄个啥都要google。。。 看来还是不能再用写字板这种东西做网页了=.=|| 我得弄个盗版DW去。。。

最近看了 Terra Nova，还有Becoming Bad， 好好看啊。。尤其是Terra Nova结尾的时候，第二季什么时候才能上啊。。等不及他们去badlands啦。。

dodo过来澳洲了，在我心里如同大神般的人物-_- 怪不得我妈天天用他教育我了。。。人家真用工啊。。跟他比起来我真不是人啊=.= 文凭吗，拿到手就行了， 既然做不到那种95%以上拿校长奖章的人。。 那平均分80跟50，我是真看不出来太大区别了。。 我又开始自己安慰自己了哈~

集装箱明天到港口了，我空闲的日子估计也不是特别多了。 能拖的都拖到最后不做不行了… 估计马上要忙起来咯。。。

还有要记下来的就是上个月买了个电视， 三星一个巨大的LED 电视啊，哇哈哈哈，46寸哒，看起来老爽了。

我唠叨完了。

今年过年的时候,我跟交往了5年多的男朋友分手了,谢谢小J, Bx, ADAA, DD, 传哥,小月和2K,在这段时间一直不停的给我上课.去英国的这5年,经历了很多人一辈子都无法想象的事情.我想上帝能让我最终活着回到家,就还是很贴心的照顾了我的.我一直在抱怨我付出的一切都没有任何结果.是你们让我知道,就算是我这样的结局,我也收获了成长.看看年龄跟我差不多的你们,我想我是时候,要开始学着长大了.

过去的这些年里,我做了太多荒唐的事情.我很健忘,甚至撒谎都会撒的前后不连贯,可有些事不是说忘就能忘的.真希望可以跟上帝做笔生意,我愿意折寿20年,换来这5年的消失.

小J你又要怪我像个孩子了,提出这种过分的要求.请你原谅我,就让我再任性最后一次.

曾经在分手后的几天写了很多语言偏激的日记.这些天下来,发现自己不放手,永远也不可能长大. 我今后再也不会对以前的空间做任何update.
勇气.真的需要一生的积攒,才能得到.

今年的6月份,我会自己一个人飞往墨尔本.前些日子小J你问我,会不会害怕,我选择了像5年前一样的答案”这有什么可害怕的”.只是5年前是发自内心的,而现在,是骗人的. 你没有选择向5年前一样试图讲可怕的事情吓唬我,我知道你也理解我是在骗你.经历了英国的日子,你们都看出来,我像极了一个受惊的孩子,对所有事情都感到惊恐,也拒绝相信任何人.我很清楚,对你们来说,这是一种伤害.只是长大是需要时间的.我才刚刚开始努力.

这段时间,你们都以为我反常.其实不是.我打心底里很喜欢这样的日子. 明白自己在走怎样的一条路.并可以按照自己的想法,选择自己的时间,自己的地点,看自己喜欢看的风景.再选择自己觉得恰当的时间,重新启程.

2K,所有人里数你认识我的时间最短.所以有时候你并无法像小J和传哥一样理解我的变化.但我还是要说一声,我很感激你,可以为了我的幸福而发脾气.

最后一句话,留给我自己.

放下,才能担当,才能对自己付责任,才能长大.

3年了，我放弃了以前的qq号码，在踏上澳洲的土地上之后，再也没有跟任何人联系，只有传哥，还时不时聊一聊，问问我近况，传哥也结婚了，生了个胖娃娃，大家都很幸福，我也很幸福。

只是三年前的计划，要放下，要对生活有勇气，要走自己的路，要过自己的生活，我依旧没有做到。放不下，虽然装做无所谓过，依旧骗不过自己，我恨，不是恨他，是恨当初瞎了眼懦弱的自己。

我也还是一个无法对自己负责任的小孩子，我的很多行动依然是跟着直觉，完全不顾及后果，天真，极其幼稚。我也依旧是说着愿意折寿20年，换来那5年消失的小孩子。而事实是，随着时间的流逝，我越发清楚那5年对我的人生意味着什么，我知道我接下来的50年，都换不回那5年了。不过我有我可爱的宝贝了，他会牵着我的手，陪我重新走回正轨。

这3年的变化，我想就是现在我可以从心底里笑出来了，我每天都过的很开心，我也不再是三年前那个受惊的孩子，我跟宝贝一样有钢板一样的厚脸皮了。哇哈哈哈。。。。

不知道3年之后的我，再回国头来看这个日记，会是什么个情景。

希望那时候的我，能更成熟一点。

我爸说，上次你们就说弄公司，慢慢吞吞的不知道在干嘛，lol。。。我这不是懒吗～～

这次公司注册了，商标申请了，订单也讨论的差不多了。厂长要被我们逼疯了。。

集装箱，清官，乱七八糟，上千样各种新东西，lol，学的也是头昏脑胀的。。下单的事也把我爸妈忙坏了。。。

集装箱的箱子也很麻烦，里面到底怎么堆，堆多少，什么地方正着放，什么地方转箱子等，才能放进去，弄得我头都大了。。

不过东西渐渐开始按起来像个样子了。超级有成就感的哇～～

还有产品的吊牌，还有包装盒的设计，全是我来的哇，特别特别难啊～～超级难啊，还好姐聪明 -.-|| 木哈哈哈哈。。。

人说现在做生意，真正从0开始已经好难了，我总感觉脑子聪明的人，怎么做都能做下来的，看来不是-.- 这次碰壁碰的也太多了，起步资金定成10w RMB看来的确是太费劲了。。扣掉集装箱啊，车啊，税啊，等等的啊，竟然没几毛钱能用来真正下订单了。。。 什么布料厂啊，乱七八糟的，起订量都好大， 你说东西印个几十米，谁理你啊=.= 还有其他配件， 动不动起订就5000米。。。10000个的， wtf。。

10w RMB也算是从0开始了吧，如今这个年代。。这钱真的还没干啥就没了。。。

好难好难好难啊，最近好累。 我发现我睡觉都是倒下立刻能睡着了，以前熬夜，3－4点根本不叫熬夜啊，现在竟然11点就能睡着了。。。靠。。

公司这个事情，以后就是我负责弄货，宝贝负责卖货，本以为弄货这个事，肯定比卖东西要便宜的多，谁知道也这么烦。头都大了！！ 哎。。。

希望以后一些顺利哦。

一年半以前，从墨尔本搬家到了悉尼，转学过来了，今天人事部经理找到我宝贝，说要给他调到墨尔本得总公司去。。。你折腾这么一大下子干什么呢。。。哎。。 公司说可以等我毕业再调过去，只要说调过去，他们就开始招人顶替我宝贝了。 我说肯定过去啊，我朋友都在墨尔本，而且我总感觉墨尔本得消费便宜一些。。 工资别说涨了，就是不涨，都跟涨了似的。。毕竟花销减少了吗哈哈。 哎。。又要大搬一次家啦半年后。

老爸老妈去了美国3个礼拜，又爱上美国了，就跟当初爱上澳洲一样。。现在天天跟我叨叨，说要让我陪他们再去一次。。。宝贝正好明年调到总部以前可以顺便请上一个月得假期，回来看一下爸妈，然后就可以飞美国了。 宝贝好了。。澳洲身份，网上online申请就结束了。。我国籍还是中国人。。无论是国内办还是国外办，都要面签。。tnnd。。。

既然明年年中要去美国，我看钻戒也是那时候买了。。哈哈，我以后可以天天盯着钻戒看了＝。＝ 不用盯着cartier得小盒子了。。

还有婴儿车。。澳洲stokke竟然卖到了1800AUD。。而且颜色还不能选，配件跟小伞也不是每家店都能买到。。美国才1049AUD，而且啥都有。。。靠。。。我去美国一定要抗一个宝宝婴儿车回来！

• when is a leaf node
• for internal node:
• case 1: is unmatched
• case 2: is matched to one of its children

First, look at a sub-tree from ,

Case 1: when is not matched , this means its children must all match to some of their children. Look at the thick edges.

Case 2: when is matched to so

Sum up: answer is at .

Running time:

where means how many children a certain node has.
Number of states:
each state take .
so:

Solve:

Branching-HS(A, (B1, …,Bm), k)
if k = o: 		//base case
	if Bi = original Bi for some i:
		return “no HS”
	else return empty set
else:
	choose some Bi
	for u ∈ Bi
		Brahching-HS(A-u, {Bi-u | i=1, …, m}, k-1)
	if all recursive
		return “no HS”, then return “no HS”
	else:
            choose some u where u ∈ Bi worked,
            add u to the result from that, call and return.

Running Time:

• {Bi-u | i=1 to m} takes
• 
• there are amout of in , so this runs in times
• Subset has elements, have elements, so

Rerolling above gives overall running time .

Want:

Maximum weight subset of compatible intervals

Means:

we have:

•   requests labelled 
• with each  request  specifying
  • a start time 
  • a finish time 
  • a weight 
  • Two intervals are compatible if they do not overlap
  • The goal is to find a subset  that maximize the sum of the weights of selected intervals.

Solve:

Assume all requests are sorted in order of finish time:

• We say a request comes before a request if
• define , for an interval , to be the largest index such that intervals and  are disjoint
• means is the leftmost interval that ends before begins, we define if no request is disjoint from .

Prove:
Let be an optimal solution, ignoring for now we have no idea what is.
Claim:
Either interval (the last one) belongs to , or it doesn’t.

• Claim 1: belongs to , then no interval indexed strictly between and can belong to , and must include an optimal solution to the problem consisting of requests .
• Thus is optimal for sub-instance of intervals that finish
• Claim 2: does NOT belong to , then is equal to the optimal solution to the problem consisting of requests
• Thus is optimal for sub-instance

Now computes:

MWIS(n)
if n=0
  return 0 //optimum over empty set
else
  return max{ MWIS(n-1), MWIS(p(n))+w(n) }

Just like Fibonacci numbers, it runs in
Reusing computation:

MWIS(n)
T  //array 1,...,n
T[0]=0
 for i = 1,…,n
T[i]= max{T[i],T[p(i)]+w(i)}
 return T[n]

Algorithm runs in time
Took to sort intervals and to compute .

How to find optimal solution:

call MWIS(n) to compute array T
S   //empty set
i   //n
while i > 0
  if T[i]=T[p(i)]+w(i)
    add i to S
    i←p(n)
  else
    i←i-1

Note: array T contains the value of the optimal solution on the full instance.
Note: each state of DP takes time, the algorithm runs iterations → 

For a given schedule , let be the finishing time of job in the schedule.

Want:
Design a greedy algorithm that computes a schedule with minimum weighted average finishing time that minimizing .

Solve:
Our greedy algorithm can be sorting the jobs in increasing order.

Assume for simplicity that no 2 jobs have the same ratio. To prove that the schedule is OPT, we resort to the usual exchange argument.
Suppose the OPT is and there are 2 adjacent indices and such that:

Now, consider:

where we swap the position of and , and leave other jobs in their places. We now need to prove the change decreases the cost of the schedule.
Notice that the finishing time of jobs other than and is the same in and . Thus:

Let . Then:

Plug those values into expression from above for the difference in cost between and . After simplifying we get:

Noting that

implies . so we get:

Given:
be a connected undirected graph. We say an edge is critical if removing it disconnects the graph.

Want:
Given an algorithm for identifying all critical edges.

Solve:
Fun DFS on G to get a single tree T.

1. non-tree edges cannot be critical

This is because the tree keeps the graph connected even if all non-tree edges are removed. This reduced the search space for critical edges from to just .

Let be the set of descendants of in T, consider to be a descendant of itself, so . Using the discovery times of DFS define for every vertex :

Recall DFS tree of an undirected graph, all non-tree edges connect 2 nodes such that one is the descendant of the other. So captures how high up the tree we can go from u by taking zero or more edges down the tree followed by a single non-tree edge to reach a node up in the tree.

In order to keep well defined (in case that no non-tree edge exists), we also consider the option of staying at . The discovery time of the vertices decreases as we go up the tree we take the minimum of the discovery times of the vertices before mentioned.

We now claim that a tree edge , where is ‘s parent, is a critical edge if and only if . The only way to remain connected is through a non-tree edge where and .

In that case, we know that . Otherwise, if no such edge exists, we have and removing disconnects the graph.

We could identify all critical vertices in time if we had these low values.

To pre-compute
,

for each vertex in time. Then we can compute low by using the following relation:
,
which would take for each .

Thus computing for all would take time.

NOW, to get a more efficient algorithm we need to re-use come computation. This can be done if we re-difine recursively:
.

The two definitions are clearly equivalent, but the second one leads immediately to a algorithm for computing for all , provided is given for all .

So this approach takes time.