Greenmoon55's Blog

湾区体验

2019-09-08T00:00:00+00:00

已经搬来湾区快一个月了，趁新鲜劲还没过写一下感受。

衣食住行

湾区的天气真的好，夏天每天都是晴天，二十来度不冷不热。中餐还是很全的，鲤鱼门早茶甚至比纽约的好吃，不过哪里都要排队，比纽约还可怕。。整个湾区感觉就像是一座座小镇连在一起，在 Buiding 20 或者在去 Fremont 的84号桥上看周围荒芜人烟的样子，和公司的高大上的楼形成了鲜明的对比，总觉得很奇幻。

暂时住在 Foster city，公司提供的房子真的很不错，或许是人生第一次一个人住这么久，挺舒服的。Foster city 是个安静的小城，周围步行就有快乐柠檬、火锅、大华、safeway，还有一个超级美的湖。虽然告别了半夜十二点下楼遛弯儿的纽约生活，这里天没黑的时候出门走走还是很安全的。在 Google 和知乎搜 Foster city，最靠前的结果都是我司员工写的。。那我就把这两个链接放在这里吧。

https://leonson.me/2018/12/foster-city-intro

https://zhuanlan.zhihu.com/p/34935531

湾区出行还是很方便的，跟很多其他美国城市一样，高速非常发达，出门很快就能上高速，几乎去哪儿都在半小时以内。唯一的问题是堵车比较严重，刚好去公司这一段路完全没有HOV lane，班车只好堵着，还要停很多站。。每天两小时在路上比较影响生活质量。。纽约地铁确实方便但是很脏，站里也没有空调，各有各的好。

上班感受

交通

嘿嘿首先还要从交通说起，来了之后才意识到公司有多大，园区内部班车有好几个线路，甚至还有express。接员工上下班的shuttle高峰期几乎不会断，可能有二三十个线路，每个线路有很多班次。园区还有免费的自行车可以骑，前天试着骑了最远的一次，将近20分钟，风很大再也不这么折腾了。。太远的楼还是坐车好。

吃

用地里的话说，free food, is ok，我不太在乎吃已经知足了。工作日几乎不用花钱，这周工作日除了打uber一分钱都没有花。。这样对我来说，可能比在纽约更省钱，这个月花钱最多的商户肯定是海底捞和uber。

Orientation & 内部工具

非常强调价值观，还会做奇怪的游戏。。让我想到了阿里。。内部用的work chat竟然是可以看到已读状态和在线状态的，很像钉钉有没有。入职之前我最担心的是outlook难用，现在感觉网页版也可以接受。workspace 不按时间排序可能有点乱，但是更容易找之前的对话。上面有很多有趣的组，比如introverts（终于找到同类了），刷内网有点刷reddit的感觉hhhh。

Culture

对于新人来说，这里像一个startup。非常强调move fast和impact，之前工程上可能要求不高，比如代码很少有文档和注释，code review可能抠的不太细。。虽然听起来不怎么样，但是可能对公司快速迭代是好事，可能要看组里怎么平衡质量和速度了。。这会让员工去想，我做某件事情对公司有什么意义？我真的要refactor这个东西嘛？

想来去年实习跟组里的senior聊，他说大公司可能更规范，我说不一定吧。然后他举个例子说，你看我们的文档可能在github上，也可能在confluence上，也可能在google docs上多乱啊。然而现在我司更乱。。wiki, google docs, dropbox, quip, ms哪都有。。

去年实习的时候就觉得大家都（至少表面上）很nice，这里也是一样，如果有问题一般都是热心解答。可能是美国不太看层级。

open确实是open呀，跟以前实习一样，可以看到别的组的架构、roadmap啥的。

work life balance听说不是很好，似乎确实是这样，我现在已经不敢看同事交代码的heatmap了。好玩/wlb/manager靠谱构成了一个不可能三角形，准确的说可能好玩又轻松的组就很少了。

开发环境

入职第二天大家做第一个教程，所有人都遇到了bug…我来说一些好的地方。

Monorepo

以前只听说Google只有一个repo，FB也差不多，这么搞其实有很多好处，比如内部依赖不需要版本控制，搜代码非常容易，缺点就是需要team管版本控制，dev机器都需要很强的配置，才能pull那么多代码。

Task

可能大家都很讨厌jira，内部task管理就是一个很简单的工具，用起来很爽

Nuclide

这个基于atom的IDE还是很方便的，比如可以一键申请开发机，搜内部代码，甚至可以直接在IDE里inline看别人的comments。

Infra

如果写backend，除了Hack和数据库跟其他公司区别比较大，其他似乎差不多？可能还是aws这种地方更接近业界常用的框架吧。

ML

Train model可能不需要写代码，只要点点点就可以了。。真是方便。

Bootcamp

美国很多公司都是标准化面试不分组，特别是我司，newgrad几乎都是不分组的。Bootcamp前两三周大家一起写一些小task，后面几周就去跟几个组一起做点task，然后只要你说去某个组，并且那个组还有hc就可以去，先到先得，组里都是欢迎你去体验的，manager也愿意花时间跟每个bootcamper聊（这边manager跟tech lead往往是两个人），并不会给你面试的感觉。比如你以前没写过前端，没有做过ml，可能仍然有机会去这些组。如果实在不match你自然也不会去，去了搞不定就没有好的rating了。。这其实有点像pair programming面试。这么搞其实很有趣，可以让你深刻体验某个组是不是适合你，缺点就是万一没有跟你兴趣匹配的组就完蛋了。这还需要这么大的公司尽量保证所有面试的问题和标准是一样的。

以前以为只有newgrad才这样，进来之后发现甚至有工作7年这种资深的人也是没分组进来自己选，当然也有preallocated hire，他们在bootcamp待的时间就短一点。有的组大家都觉的不好玩，就跟本招不到人。。当manager也不容易呵呵。

bootcamp其实并没有想象的那么轻松，真的非常刺激，要上课要了解组要做task，毕竟你的未来掌握在自己手里。回到刚刚说的culture，比如第二周就自己选task做，有问题自己去找task的联系人，这个人可能放假，可能在另一个州，并不是你旁边有一个人手把手教你，task描述也可能有问题，全靠自己去问。也不敢去真的学完全不熟悉的领域，我是不敢接Haskell的task…

听起来还不错？然而如果你想做cloud/backend啥的，合适的组真的不多，可能内部infra确实不像aws那么复杂需要很多人吧。现在聊的组都比较奇怪，每天都在想：我要做ml嘛？我要做风控嘛？虽然肯定不想做fullstack，我要写php还是c++呢？要体验新东西嘛还是求稳？我要忙一点还是轻松一点？这个老板到底好不好？显然跳槽的时候公司的名字不会有多少加成，所以压力山大，相信自己，走着看吧。

Bootcamp很多课其实都没必要现场听，回家看视频感受一下就可以了。有些课讲得确实挺好的，也有些比较浪费时间。

国人

完全没想到我司也这么多中国人，可能每周说英语不超过两小时。。有时候在办公区走着走着就觉得像回国了。

很幸运同时入职有几个小伙伴可以多交流。

2018Spring

2018-05-26T00:00:00+00:00

忍了一学期没有吐槽，今天刚好小长假无聊，并且成绩刚刚出来，终于可以写一篇流水帐了。

这学期没有找工压力，本来以为会很闲，结果过得还是挺忙的，大部分时间还是在写作业，选的三门课是AI+HPC for ML + 1003 ML。这学期的选课思路非常简单，为了保留上ml后续课程的可能性，所以一定要选ml，结果现在发现后面应该不会上ml相关的了…这门课确实不错，但是剩下两门比较一般，好吧，现在开启吐槽模式。

课程

AI: 30-40人 workload: 1天/周

老师是大佬，教材AIMA他也写了一些内容，但是讲课水平确实一般。抄袭一句经典的话，如果你懂了，那么不用上他的课，如果你不懂，也很难听懂。有次我问旁边的美国人，结果他也没懂… 这门课内容其实还可以，对ai整体介绍了一下，虽然学的东西没有什么用。AIMA也不错，你会发现以前自以为是写搜索的小聪明（例如Bidirectional Search）人家早就研究过。但是讲得太浅了…其实这门课我觉得最有趣的地方是写sat solver，虽然只是个dfs。本科就听说cs的同学在写prolog神马的，现在终于知道他们在干嘛了…这门课不好的地方就是很多作业是做cs同学最讨厌做的事情（我可以这么说吗？），也就是明明可以写代码做的东西非要手算，programming assignment也跟好学校的ai课有很大差距，要是能写个游戏多好（例如stanford cs221）。我就不用说作业成绩一个月之后才出来了，反正大家基本都是满分只看final，final一道选择占总成绩2.5%…

总之跟top学校的ai课相比差距巨大，刚好适合我来水一水。。不然的话完全没必要选这门课，看看berkley的cs 188x或者台大的coursera的ai就行了。rmp教授低分是有原因的…最影响心情的一门课。

HPC for ML: 20-30人 workload: 1天/周

选这课的原因是没敢选compiler，这个看起来有点水所以就选了，不过体验也很一般，很多人都有点后悔选了这门…基本上就是把每个领域的入门教程抄过来放在slide里，三个lab写写pytorch, cuda和mpi，还是学到了一些东西，只是完全可以自学。我还记得春假那会儿一个人在图书馆搞了五天lab1，完全就是浪费生命…然后第一次去piazza求情extend ddl。lab设计一般，说明很不清楚，他自己都没有写过，有次给的checksum还是错的… final考试非常奇怪，有种文科课的感觉…很多东西我觉得他上课没有认真讲就考了，公式也是只告诉你怎么算，并没有说原理，虽然原理其实两分钟就能讲完。

这门课内容还是很好的，虽然讲得浅但提供了一个roadmap…现在ml这么火，很多公司是想要懂算法也懂systems的人的，例如阿里，还有这个：机器学习相关岗位面试中，有哪些加（zhuang）分（bi）项？ , uw也开始搞saml group了。其实适合ds的同学选。

这门课也是目前遇到大神最多的一门，太可怕了只能给人家当分母…相关课程的话，当然要提cmu的15-418，视频是公开的，还有uw的systems for ml，陈天奇开的课哦（微博）。

ML: 160人 workload: 3天/周

这门课选得相当不容易，因为只给cs30个名额，所以等到开学第一周才选到。rmp满分的课，ds最好的课之一。这门课只是第一周会觉得难一些，后面没有想象的那么难，但是作业不少，作业、考试以及notes都是精心准备的，没有太多数学，是理论和实践的完美结合，是非常值得选的一门课。学了这门课我就敢说入门ml了，也有信心去自学相关内容了。Project给大家一个跟大佬交流的机会，但是非常可惜我们并没有怎么交流。首先是被队友坑，所以只能四个人组队，搞成了我这学期压力最大的事情，还好我们有大佬。我们dataset选的比较奇怪，我们四个都不想做所以拖到了最后几天别人都搞定的时候才搞。刚好那天hpc gateway升了openssh搞的我没法登进去…整个人都抑郁了…现在会想起来如果选一个经常交流的advisor会更好，并且完全可以两人组队，甚至还有一个人做的…这样会舒服很多。ml project做完让我再也不想搞data science了，感觉ds只是把code当做工具，得到某些结果，而我希望code是个可以持续改进的“产品”。

我总觉得这门课从2015到现在慢慢变简单了，虽然对我来说还是不容易，不知道是不是错觉。

其实final之前又发现一堆问题，比如上学期觉得平时没有好好复习，这学期下课之后都会回头看一眼，但是final前几天才发现很多东西其实没学会，所以及时整理非常重要，希望以后每周都能花一两个小时来整理一下，尽量少开新坑多复习…就像david的建议。

I think you’ll be surprised how much easier it is to remember something once you’ve fully mastered it. In any case, once you master something, I always recommend that you write a note to your future self, explaining the concept. This should be something you can read in 6-12 months (or years, eventually) when you need that mastery, but you’ve forgotten the details. You’ll have trouble writing the note if you don’t fully understand the material, so it’s also a good self test. I have 100s pages of these types of notes, and I’ve found them immensely useful over the years.

还有一个尴尬的事情是做完以前的final，同样的问题我竟然又错了…还是印象不深刻，以后错题要再做一遍…如果有空的话orz。

NYU

去年总觉得这边cs哪里不对但又说不出来，一是去年以为没有多少colloquium，这学期倒是发现了很多…我去了10个左右，nlp, pl, os啥都有，就是听不懂只能蹭吃噌喝…回头又没时间（不想）看paper… 听完感觉各位phd/postdoc/prof都很会讲，每个人讲得都很有条理。第二点是没有cs氛围…就像看到reddit这一条。

Personally I’ve found a lot of the students to be intelligent, hard working people, but what I call “tech enthusiasts”. They like the idea of programming, they may even go to clubs like tech@nyu or BUGS (open source club), but they don’t spend the time to actually program.

不像某学校”空气中弥漫着代码的味道”。我觉得有很多原因吧，比如

1.大家都不住在一起，不会像本科时候一起去学院俱乐部写代码什么的

2.课程作业就很多了，谁有空自己写代码玩

3.很多人学cs是为了会一些技术，把cs当作工具来完成自己的目的。(no offense)

实习

刚好两年没有工作了，感觉上学相当于花钱度假…确实对工作没有太大帮助但是很有趣，之前看到知乎帖子有美本申到了mcds问是去读书还是去azure工作，大家都说如果不转行就应该直接工作，读书的时间成本还是挺高的。

到现在刚刚实习一周，没有太特别的感觉，第一天有点紧张很快就好了，同事都很professional，不像以前在创业公司大家天天闲聊。我五年前竟然还写过实习感受1和实习感受2…这边实习感觉真心不错，办公环境好，开放，不加班，用我喜欢的技术还有很多挑战，代码质量虽然不够完美但是很不错了。除了没有免费的饭其他都很完美的样子，至少比之前去过的team都好…但是不知道为什么我不是很excited，可能是跟以前的技术栈比较像，所以我有一种第500天上班的感觉，并没有刚上班的新鲜感。如果去做点其他的东西会不会更有趣呢？比如cuda, ml, nlp, blockchain？可能学会之后也觉得无聊了…这要怎么办…我甚至都不知道自己为什么不是特别感兴趣…难道是刚放假没休息好？反正我不会觉得不喜欢…所以似乎还好？

2017总结

2018-01-22T00:00:00+00:00

2017年初在看Casey Neistat的Vlog和C君纽约旅行视频的我完全想不到自己真的会来纽约（当初觉得会去加州吧，没觉得NYU会要我），到现在半年过去，每天还会想自己是有多幸运能来到纽约。来到这边啥culture shock都没有，除了语言跟国内没啥区别，逛街啥的甚至比国内还方便，城里人也少一些比较舒服，气候跟国内也差不多，同学很多中餐馆也很多。我心里最喜欢的城市就是纽约和上海了，现在都不想去湾区了。。

终于彻底变成学生了，工作过才能体会上学有多幸福。只要能赚回来学费，这波不亏。这学期上了算法、OS、PL和概率统计，Siegel的算法课的作业题很有趣，用同学的话说，”He really makes you think”，可以说是我上过最好的一门算法课，还是学到了一些新东西。OS主要对内存管理认识更深刻了，还简单介绍了很多Linux的具体实现的，学完之后很想再找本Kernel的书看看，或者说给了我再去自学的信心（估计不会看的。。），不过这门课还是undergraduate level的，作为cs的graduate student应该学得更深一点，学深了写写代码反而比学概念容易理解，这也可能是为什么大家都想去CMU吧。概率统计补补数学，上学期花了这么多时间还是很值的，不过时间分配很失败，总是没时间预习，上课跟不上，课后花很多时间自学，写作业总是很痛苦。总的来说，没想到这半年学生生活让我更喜欢CS了，算是这学期的最大收获吧。

写作业找实习一学期过去感觉甚至比上班还要忙，过着图书馆和家两点一线的生活。。实习也不好找，当初想着面面FLAG，最后去个中型公司，实际上这边面试非常难拿。我是投了四五十家，最后面试不到5个。最开始收到简历拒就很伤心，最后接到拒信都心怀感激。如果早知道实习这么难找我可能就不选概率统计了，会把重心放在找工作上。还好有惊无险，很幸运接了个小公司offer。发offer之后还组织参观公司问各种问题，体验还不错。感觉中美找工作也越来越趋同了，美国除了面算法也越来越看中项目，国内也越来越重视算法吧。

其实好多次感觉心态都要崩了，比如被fb, amazon简历拒，比如感恩节一个人在家花了好久debug OS lab，比如十一月中旬以为面挂了没有offer，比如考试一边写一边想会不会挂科不能去实习。。

2017年也是我第一次出国，四月底去了日本，风景倒没有特别的，倒是亲眼见识了一分钟间隔的铁路、拿出钢笔画地图热心指路的小哥、胡同里汽车停下来耐心等救护车、博物馆对战争的美化。去了一次印象深刻，希望以后还能去玩~

Newport

Washington Square Park

最喜欢的图书馆四楼

2018没有什么特别的想法，学喜欢的课，出去多玩玩，好好管理时间，希望一切顺利。

LeetCode 44 Wildcard Matching

2017-06-09T00:00:00+00:00

class Solution(object):
    def isMatch(self, s, p):
        """
        :type s: str
        :type p: str
        :rtype: bool
        """
        if len(s) == 0:
            for ch in p:
                if ch != '*':
                    return False
            return True
        f = [[False] * (len(p)+1) for x in xrange(len(s)+1)]
        f[0][0] = True
        for i in xrange(0, len(s) + 1):
            for j in xrange(1, len(p) + 1):
                if p[j-1] == s[i-1] or p[j-1] == '?':
                    f[i][j] = f[i-1][j-1]
                elif p[j-1] == '*':
                    for k in xrange(0, i+1):
                        if f[k][j-1]:
                            f[i][j] = True
                            break
        #print f
        return f[len(s)][len(p)]

第一个思路是f[i][j]表示s[i]匹配到p[j]能否实现，两重循环计算，遇到*还要再加一层循环来确定p前一位匹配到了哪里。提交之后TLE。

可以发现有两个可以优化的地方，第一个是f[i][j]第二维只需要j-1，因此可以降成一维数组。第二个是当p[j]是*时，任意f[k][j](k<=i)为True都可以，不需要每个i都向前搜索一遍，而应该遇到f[k][j]反过来填后面的f[i][j](i>=k)。

class Solution(object):
    def isMatch(self, s, p):
        """
        :type s: str
        :type p: str
        :rtype: bool
        """
        if len(s) == 0:
            for ch in p:
                if ch != '*':
                    return False
            return True
        f = [False] * (len(s)+1)
        f[0] = True
        for ch in p:
            if ch != '*':
                for i in xrange(len(s), 0, -1):
                    if s[i-1] == ch or ch == '?':
                        f[i] = f[i-1]
                    else:
                        f[i] = False
                f[0] = False
            else:
                for i in xrange(len(s)):
                    if f[i]:
                        for j in xrange(i+1, len(s) + 1):
                            f[j] = True
                        break
        return f[len(s)]

此时f[i]表示截止到当前ch，能否匹配到第i位。

Codeforces Round #418 (Div. 2)

2017-06-08T00:00:00+00:00

又是发挥很差的一场，只过了A..

A. An abandoned sentiment from past

逆序填入数字再判断是否还是递增的序列

B. An express train to reveries

这道题看了样例想了想就写了个算法，居然还过了pretest，最后WA了。说明要认真想算法的正确性。。

分两种情况讨论：

a, b只有一个数字不同，那么说明a[i]和b[i]都不可能是要找的数字，找一找剩下n-1个数中未出现的数字即可。
a, b在第i位和第j位不同

如果是

1 2 3 4 3
1 2 5 4 5

那么i位和j位选哪个都无所谓。

如果是

5 4 5 3 1
4 4 2 3 1

就要先去掉出现两次的数，例如上面第3位先选b，因为2只出现了一次，接下来第一位选5，因为a中第三位的5已经被替换成2了，5在a中只出现1次。

再举个例子

5 4 3 5 2
5 4 1 1 2

答案是：

5 4 3 1 2

from collections import defaultdict
n = int(input())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]

x = []
a_used = defaultdict(int)
b_used = defaultdict(int)
for i in range(len(a)):
    a_used[a[i]] += 1
    b_used[b[i]] += 1
    if a[i] != b[i]:
        x.append(i)
if len(x) == 2:
    x_done = 0
    while x_done < len(x):
        for i in range(len(x)):
            if a_used[a[x[i]]] > 1 and b_used[b[x[i]]] == 1:
                x_done += 1
                a_used[a[x[i]]] -= 1
                a[x[i]] = b[x[i]]
            elif a_used[a[x[i]]] == 1 and b_used[b[x[i]]] > 1:
                x_done += 1
                b_used[b[x[i]]] -= 1
        if x_done == 0:
            a[x[0]] = b[x[0]]
            break
else:
    for i in range(1, n+1):
        if a_used[i] == 0:
            a[x[0]] = i
            break
print(a[0], end="")
for i in range(1, len(a)):
    print(" " + str(a[i]), end="")

C. An impassioned circulation of affection

当时把自己带到沟里了，想着先split，然后就卡在“aaaaaa”这种情况。今天发现只要暴力扫一遍就好，不需要split啥的。。注意需要先算好所有答案，因为q太大了。卡python也是无语，只好再用c++写一下。我这里循环用滑动窗口来做，j先确定当前串的长度，另一种做法是直接两重循环串的起点和终点，两种做法都是O(n^2)，没有区别。官方题解还提到了有复杂度更低的算法，目前没有动力去看。。

#include <iostream>
#include <string>
using namespace std;
int f[26][1510];

int main() {
    int n, q, m;
    char c;
    string s;
    cin >> n;
    cin >> s;
    for (int i = 0; i < 26; i++) {
        char ch = 'a' + i;
        for (int j = 1; j <= n; j++) {
            int l = 0, r = 0;
            int count = 0;
            while (r < n) {
                if (s[r] != ch) {
                    count++;
                }
                while (count > j) {
                    if (s[l] != ch) {
                        count--;
                    }
                    l++;
                }
                f[i][j] = max(f[i][j], r-l+1);
                r++;
            }
        }
    }
    cin >> q;
    while (q) {
        cin >> m >> c;
        cout << f[int(c-'a')][m] << endl;
        q--;
    }
    return 0;
}

LeetCode 600 Non-negative Integers without Consecutive Ones

2017-06-07T00:00:00+00:00

第一次ak哈哈，可能是因为这周的比赛比较简单。

先说第一个方法，也是我当时想出来的。分情况讨论，一种是二进制表示的长度小于n的长度，另一种是跟n长度相同。第一种情况任意不含11的数都符合条件，第二种要搜索判断。

class Solution:
    def count(self, i, num, size):
        if i == size - 1:
            return 1
        if num == 1:
            return self.count(i+1, 0, size)
        else:
            return self.count(i+1, 0, size) + self.count(i+1, 1, size)

    # top: whether current value is the same as a
    def countLimit(self, i, num, size, a, top):
        if top and num > a[i]:
            return 0
        if i == size - 1:
            return 1
        if num < a[i]:
            top = False
        if num == 1:
            if top == False:
                # we can choose whatever we want
                return self.all[size-i]
            return self.countLimit(i+1, 0, size, a, top)
        else:
            return self.countLimit(i+1, 0, size, a, top) + self.countLimit(i+1, 1, size, a, top)
            
            
    def findIntegers(self, num):
        """
        :type num: int
        :rtype: int
        """
        # possible solutions starting with 1
        self.all = [0] * 31
        self.all[1] = 1
        self.all[2] = 1
        for i in range(3, 31):
            self.all[i] = self.all[i-1] + self.all[i-2]
        a = []
        while num > 0:
            a.append(num % 2)
            num = num // 2
        a.reverse()
        length = len(a)
        #print(a)
        res = self.countLimit(0, 1, length, a, True)
        #print(res)
        for i in range(1, length):
            res += self.all[i]
        # add 0 to solutions
        return res + 1

all数组表示1开头符合条件的数的数量，本来是通过count函数来搜索的，后来发现是斐波那契数列就直接算了。countLimit用来搜索长度与n相同的数，top用来标记当前位是否与n一样大，如果当前第i位是1并且已经不是最大的，那就说明从第i位开始就可以随意选1和0了，加了这个剪枝就过了。

下面是官方题解的思路，另外参考这个解释。这个f[i]包含以0开头的情况，所以如果发现n的第i位是1，那么当前位是0，后面就可以任意选数字了。如果遇到连续的1，选完第i位是0，就可以退出了，因为此时第i位只能为0。最后返回时加上n本身（如果遇到11要限减掉，因为不可能出现n这个数）。

class Solution:
    def findIntegers(self, num):
        """
        :type num: int
        :rtype: int
        """
        a = []
        while num > 0:
            a.append(num % 2)
            num = num // 2
        a.reverse()
        length = len(a)
        
        # number of available solutions, i is the length of binary representations
        # f[1]: 0, 1; f[2]: 00, 10, 01
        f = [0] * (length+1)
        f[0] = 1
        f[1] = 2
        for i in range(2, len(f)):
            # f[i] = (f[i-1] + '0') + (f[i-2] + '01')
            f[i] = f[i-1] + f[i-2]
            
        res = 0
        #print(length,res)
        for i in range(0, length):
            if a[i] == 1:
                l = length - i - 1
                res += f[l]
                if i > 0 and a[i-1] == 1:
                    # num itself is invalid and will be deleted later
                    res -= 1
                    # res was updated in previous i
                    break
        # plus num itself
        return res+1

我的2016

2016-12-31T00:00:00+00:00

2016年发生了很多事情，年前一二月在公司忙重构，四月决定出国，六月离职，七八月复习GRE，后面在学校申请+看看论文。

今年做的最重要决定肯定是离职准备申请master，可能在别人看来是比较冲动的决定，这次也就上网搜了一圈资料就决定了，其实本科的时候有过一点点想法，只是后来完全放弃了。

不记得在哪里看到一篇文章，不管从事什么高薪工作，多年后很多人还是会选择做自己最想做的事情，过自己想要的生活方式。初中的时候有次跟同学聊天，讲以后想做什么，我就想做一个平凡的人，白天做有意义的工作，空闲时间可以读读书，这就是最理想的人生了，希望以后能实现这个目标。（有意义 = 影响的人数 * 贡献度，比如让电脑开机耗时-1s，如果影响的人多，也是一件有意义的工作。）接下来读研希望也有时间见识更大的世界，思考人生目标。

第一次回到软院很想哭，很喜欢最近在嘉定的生活。申请季到现在还比较顺利，最紧张的时候是八月初担心GRE考不出来和十一月底担心文书写不好，等明年结果都出来再好好总结一下吧。完全没想到最近这半年会这么忙，近三个月的节奏是这样的：每周实验室开会之后先自己看看公开课放松一两天，然后再花两三天做本周的主要任务，比如复习托福或者网申几所学校，最后开会前一两天再去看论文或者折腾代码，这一两天才是每周最紧张的时候，所以其实每次去考托福或者GRE我都非常放松。。

今年公开课看了宾大的《城市规划》，感觉好多设计很有特色，很强调构建一个walkable neighbourhood，然而真的跟中国国情差距太大，人太多了= = 第一次体验peer review的公开课，大家做presentation都挺认真的。专业相关的就是Andrew Ng的Machine Learning，Geoffrey Hinton的神经网络，再加上Udacity的自动驾驶，都各有侧重，明年学完再来总结。

虽然不是学霸，对于我来说，学习带来的快感要比上班写代码爽得多，可能因为码农不能决定产品方向？（其实还算幸运一直在做还算感兴趣的东西，没有遇到过新浪微博那种脑残PM。）挺喜欢读paper的，申请季也在考虑以后是做科研还是工作，工作的话要是去不了好玩的组，就算在FLAG又如何，科研我不明确做什么方向，也不知道自己是否天赋、智商足够，要知道科研选错方向可比在公司进错组惨多了。（推荐这篇研究生后出国去Google的思考《是时候了》，我也比较看重技术氛围和国内环境）

最近在一亩三分地上看到两篇讨论这类问题的帖子，一篇是top5硕士毕业工作三年后想做科研，另外一篇是想做CV但是master读了一年之后有些迷茫，第二篇很可能就是明年的我。我发现性格因素其实也挺重要，上大学测过自己是INTJ，这两个帖子的作者也是INTJ/INTP，我昨天测了下还是INTJ，I最明显，NTJ其实倾向不大，或许这种测试还是有点道理的？INTJ也就是内倾、直觉、理性、判断。内向是肯定的，我是属于充电（跟人聊天）五分钟可以放电（一个人呆着）很久的，一直充电就会爆炸，大一对门的时候就不理结果为啥希望寝室没有人。还有一点是强烈兴趣驱动，完全无法忍受做自己不想做的事情，比如当年不保研的原因之一是不想再上政治课，现在申请也不想选MSIM甚至MSIN这种课程表不完美的项目。追求完美？可能是有点吧。。我也越来越不在意别人的想法了。“INTJ是十六种人格类型中最稀有的类型，约占女性人口比例0.5%，男性人口比例1%”，来自维基百科，真是可怜。

今年的主要娱乐是看youtube的游戏视频…F1（播主是工科生）、模拟卡车（播主居然是cs毕业的大叔，有次还聊他喜欢操作系统讨厌数学课。。），还有bilibili的视频吧。。书几乎没看，kindle已经积灰很久了。每天晚上从十一点多躺一两个小时睡不着也是醉醉的。豆瓣告诉我今年电影居然看得比去年少，额是更宅了还是更忙了？

申请季仅仅是个开始，不管找工还是科研，后面的压力会更大。新年计划就不写了，听说不告诉别人计划会更好？越长大越想家，也希望能多回家看看。

新年快乐！

最后放一张调过色的嘉定。

Coursera Machine Learning

2016-11-18T00:00:00+00:00

这门课也是本科的时候尝试然后放弃的课，今年五月重新捡了起来还买了证书，夏天复习GRE没看，赶在可以获得证书的最后几天（要半年内学完）终于学完了。

这门课是 CS229 的 “watered down”版本。剔除了几乎所有需要数学知识的部分，只需要知道如何求导以及矩阵乘法。编程作业里的所有数学公式都给出来了，只需要在MATLAB里实现就可以了。这门课很奇葩的一点是入门比较难…后面越来越简单。

总结一下这门课都讲了啥？

线性回归，cost function, gradient descent, vectorized implementation
Feature scaling, mean normalization, normal equation（但是数据量大的时候很慢）, regularization
Logistic Regression（用到sigmoid function和取对数的cost function）, Advanced optimization, one-vs-all
Neural Networks: Forward Propagation, bias unit, Backpropagation（可以用gradient checking确定backpropagation算出的导数是否正确）, Random initialization: Symmetry breaking
Training/validation/test sets
Spam classification, Precision/Recall, F Score
SVM：修改Logistic Regression的model，优化theta即可获得比较好的结果。

参考：支持向量机: Maximum Margin Classifier

Kernel: 生成feature的好方法，可以选择数据作为landmarks，选择基于到landmark的距离的similarity methods来生成新的数据。
KMeans
Demension Reduction: PCA(SVD分解）(Bad use: prevent overfitting)
Anomaly Detection，这里用的是高斯分布，判断数据点是否离均值太远
Collabrative Filtering
Stochastic gradient descent(random shuffle first, can slowly decrease alpha), mini-batch gradient descent, MapReduce
Pipline, Ceiling analysis

嗯只是给我自己看的….有人写了很详细的笔记，强烈推荐：http://www.holehouse.org/mlclass/index.html

接下来我现在在看Hilton的Neural Network，很详细地讲神经网络，上周学了CNN，这周讲RNN。等明年有空去搞搞Kaggle，学完不动手就全忘了。或许看下CS229或者231n吧…

回到嘉定

2016-07-06T00:00:00+00:00

像我这么不敏感的人，并没有什么感觉，一进图书馆开始看书就把自己当做准备期末考的大二学生了，没有任何违和感。然而这都是考试周的第二周了，图书管理依旧都是大二电气的复习考试呢。。

倒是睡前刷邮箱刷到LinkedIn，看到好几个大一学CS的同学，现在都挺不错的，去了好公司or去了好学校，突然发现真的过了好多年了。

笑来寄语：人生是一场长跑，但你想明白了么？

猴年快乐

2016-02-09T00:00:00+00:00

又是很匆忙的一年，除夕下午出去买东西，头一次看到没人的河南街。。回到家晚会都开始了，都没来得及贴春联。

想想 2015 也发生了很多，首先是换了个工作，当时想着扇贝的一句话 I know it’s going to be very busy, but I’m ready to welcome that with open arms. 结果到了 2016 才是真忙，一月份忙到都没有生活了= =

技术上么，终于有了MBP，系统是挺好用的，不过在我手上经常五国- - 开始用了 PyCharm，终于开始 coding 了，有机会开发新功能&重构感觉很爽的。不过一直没机会折腾 docker 相关的东西，今年要搞起来咯，还要看看旧代码，多向同事学东西~ 其实现在并发量还没上来，以后有更多挑战。

入了 steam 大坑，买了好多游戏，玩得多的是不用动脑的卡车模拟和Mini Metro，周末就想在家宅着好好休息打游戏= =

终于从闵行回到了大杨浦^_^。尽管上半年去了西安，后面去了两次杭州，参加了一次 8km 跑步比赛，不过后面感觉更宅了，健身一点都没搞了，Keep 也没做，口琴半年木有拿出来了。。Todoist 和扇贝倒是坚持下来啦。

新年希望自己更开心咯，要多花时间想想计划了。

Raspberry Pi 上手

2015-11-19T00:00:00+00:00

从公司拿来一台树莓派折腾玩，下面记录一下折腾的的过程吧。

买 SD 卡装系统

京东买了个 Sandisk 16G卡，插在读卡器上就可以用了。官网下载 RASPBIAN JESSIE，装好之后懒得接显示器，nmap 查一下 ip， ssh pi@，密码是 raspberry。配了 192.168.1.233 这个静态 ip，这样以后就可以直接连了233。

连接显示器

HDMI连上我的 Dell U2312HM 显示器，居然没反应。。还好搜到解决方法

在网上找了一下，说是将/boot/config.txt的HDMI_SAFE的注释删掉就好了，于是照做。发现显示器能亮了，但是只有640*480的分辨率。再经过若干折腾，发现将HDMI_SAFE还是注掉，将hdmi_force_hotplug=1打开就可以完美1080p了。不过用hdmi接电视的时候需要再关上。

USB网卡

开始折腾的时间到了。。买了个TP-LINK TL-WN821N 300M无线USB网卡，插上去之后 lsusb 没识别。

pi@raspberrypi ~ $ lsusb
Bus 001 Device 004: ID 0bda:818b Realtek Semiconductor Corp.
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. SMSC9512/9514 Fast Ethernet Adapter
Bus 001 Device 002: ID 0424:9514 Standard Microsystems Corp.
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

能搜到需要 rtl8192eu 驱动，谢天谢地有人编译好了，从百度贴吧找到的链接： https://www.raspberrypi.org/forums/viewtopic.php?f=28&t=124509&p=835823&hilit=8192eu#p835823

根据规则从 Dropbox 下载就好了，好幸福。。就怕他以后不更新了，不敢升级系统了。。

路由器

参考这篇文章把树莓派搞成AP吧：

http://jacobsalmela.com/raspberry-pi-and-routing-turning-a-pi-into-a-router/

注意 hostapd 不能用 debian 自带的，需要自己编译，我直接用的 master 分支，参考：http://www.jenssegers.be/43/realtek-rtl8188-based-access-point-on-raspberry-pi

hostapd.conf

# Basic configuration

interface=wlan0
ssid=RPiAP
channel=7
#bridge=br0

# WPA and WPA2 configuration

macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
wpa_passphrase=12345678
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP

# Hardware configuration

driver=rtl871xdrv
ieee80211n=1
hw_mode=g
device_name=RTL8192CU
manufacturer=Realtek

pi@raspberrypi ~ $ cat /etc/dnsmasq.conf | grep -v "#" | sed '/^$/d'
domain-needed
interface=wlan0
listen-address=127.0.0.1,192.168.2.1
dhcp-range=192.168.2.20,192.168.2.200,12h

pi@raspberrypi ~ $ cat /etc/network/interfaces
# Please note that this file is written to be used with dhcpcd.
# For static IP, consult /etc/dhcpcd.conf and 'man dhcpcd.conf'.

auto lo
iface lo inet loopback

auto eth0
allow-hotplug eth0
#iface eth0 inet manual
iface eth0 inet static
address 192.168.1.233
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255
gateway 192.168.1.1

allow-hotplug wlan0
iface wlan0 inet static
	address 192.168.2.1
	netmask 255.255.255.0
	network 192.168.2.0
	gateway 192.168.2.1

iptables 配置参考这篇文章：http://liberize.me/tech/turn-raspberry-pi-into-a-router.html

sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sudo iptables -A FORWARD -i eth0 -o wlan0 -m state --state RELATED,ESTABLISHED -j ACCEPT
sudo iptables -A FORWARD -i wlan0 -o eth0 -j ACCEPT

Done! Have fun!

Nova scheduler

2015-07-25T00:00:00+00:00

Nova部署、迁移VM都会用到scheduler来调度。本文内容基于Icehouse。

#Filters and Weights

Filters会过滤不符合条件的宿主机，然后经过Weights获得权重，最终选择权重最大的host。

常用filter有RetryFilter,AvailabilityZoneFilter,RamFilter,ComputeFilter,ComputeCapabilitiesFilter,ImagePropertiesFilter。

默认启用的weighter只有RAMWeigher。。会返回host的可用内存，最终选取可用内存最大的host。

另外还有个MetricsWeigher，可以自定义各项metric的重要性，不过默认没有启用。

#Resource tracker

那么这些权重怎么获取呢？

nova/compute/manager.py 有个periodic task update_available_resource，每分钟会更新一次host的资源使用情况。最终会调用到resource tracker里的_sync compute node，更新compute_nodes表。scheduler里的HostManager再从数据库里获取metrics。

scheduler本身不会更新host metric，只会在filter_scheduler _provision_resource时更新instance的host, node及schedule_at。

#是否有cache 没有，有个caching scheduler，可缓存all_host_states，默认没有启用。

#retry如何实现？

filter scheduler -> def scheduler_run_instance -> def _schedule -> def _populate_retry

retry = {
    'num_attempts': 1,
    'hosts': []  # list of compute hosts tried
}
filter_properties['retry'] = retry

compute/manager.py有_reschedule_or_error，如果失败会RPC调用scheduler。另外有个RetryFilter，会过滤之前尝试（失败）过的host。

Coursera Cryptography

2015-06-22T00:00:00+00:00

大学的时候之前尝试过两次，都没跟下来，这次终于学完了。。

密码学是什么？在学这门课之前，我只有这些印象：

课程项目写用户注册的时候要 hash+salt
Rails 会把 session 信息存在 cookie 里，为了防止被篡改，cookie 里还有个 HMAC，用到了secret key。link
SSH keypair

目标主要有两个：confidentiality and integrity。要保证confidentiality，就要选择各种加密方法，要保证integrity，就要用到MAC。两种都保证了，就可以说实现了authenticated encryption。

好吧，那接下来看看都讲了啥。。自己整理一下：

第一周：Stream Cipher, One-time Pad, PRG

第二周：Block Cipher, AES, DES, PRG, PRF, CBC, CTR

第三周：Secure MAC, Birthday Attack, Merkle–Damgard iterated construction

第四周：Authenticated Encryption, Encrypt-then-MAC, Padding Oracle, HKDF, PBKDF

第五周：Diffie-Hellman protocol, Fermat, Euler, DLOG

第六周：Trapdoor Functions, RSA, PKCS1 v1.5, PKCS1 v2.0: OAEP, EIGamal

百度脑图

现在感觉只是大概了解了这些概念和数学证明，习题做得太少，已经忘了一些了。。知道这些已经知足啦，期待Part 2:)

OpenStack Horizon Filter 功能的实现

2015-03-07T00:00:00+00:00

怕自己以后忘了，随手记一下。

下图是 admin dashboard 里的 filter，可根据 Project 和 Name 过滤 instance。

下图是 project dashboard 里的 filter，可以过滤表格里的任意一列

代码以当前 stable/icehouse 分支为准

首先从后端看起，horizon/tables/actions.py 有 FilterAction class

class FilterAction(BaseAction):

openstack_dashboard/dashboards/project/instances/tables.py 有

class InstancesFilterAction(tables.FilterAction):

    def filter(self, table, instances, filter_string):
        """Naive case-insensitive search."""
        q = filter_string.lower()
        return [instance for instance in instances
                if q in instance.name.lower()]admin

openstack_dashboard/dashboards/admin/instances/tables.py

class AdminInstanceFilterAction(tables.FilterAction):
    filter_type = "server"
    filter_choices = (('project', _("Project")),
                      ('name', _("Name"))
                      )
    needs_preloading = True

    def filter(self, table, instances, filter_string):
        """Server side search.
        When filtering is supported in the api, then we will handle in view
        """
        filter_field = table.request.POST.get('instances__filter__q_field')
        self.filter_field = filter_field
        self.filter_string = filter_string
        if filter_field == 'project' and filter_string:
            return [inst for inst in instances
                    if inst.tenant_name == filter_string]
        if filter_field == 'name' and filter_string:
            q = filter_string.lower()
            return [instance for instance in instances
                    if q in instance.name.lower()]
        return instances

然后我们看下前端的实现，horizon/templates/horizon/common/_data_table_table_actions.html

可以看到这里有三种 filter_type，InstancesFilterAction 默认是 query，AdminInstanceFilterAction 是 server。query 和 server 有什么不同呢？我们去看看 js。

horizon.datatables.set_table_query_filter = function (parent) {
  $(parent).find('table').each(function (index, elm) {
    var input = $($(elm).find('div.table_search.client input')),
        table_selector;
    if (input.length > 0) {
      // Disable server-side searcing if we have client-side searching since
      // (for now) the client-side is actually superior. Server-side filtering
      // remains as a noscript fallback.
      // TODO(gabriel): figure out an overall strategy for making server-side
      // filtering the preferred functional method.
      input.on('keypress', function (evt) {
        if (evt.keyCode === 13) {
          return false;
        }
      });
      input.next('button.btn-search').on('click keypress', function (evt) {
        return false;
      });

      // Enable the client-side searching.
      table_selector = 'table#' + $(elm).attr('id');
      input.quicksearch(table_selector + ' tbody tr', {
        'delay': 300,
        'loader': 'span.loading',
        'bind': 'keyup click',
        'show': this.show,
        'hide': this.hide,
        onBefore: function () {
          var table = $(table_selector);
          horizon.datatables.remove_no_results_row(table);
        },
        onAfter: function () {
          var template, table, colspan, params;
          table = $(table_selector);
          horizon.datatables.update_footer_count(table);
          horizon.datatables.add_no_results_row(table);
          horizon.datatables.fix_row_striping(table);
        },
        prepareQuery: function (val) {
          return new RegExp(val, "i");
        },
        testQuery: function (query, txt, _row) {
          return query.test($(_row).find('td:not(.hidden):not(.actions_column)').text());
        }
      });
    }
  });
};

如果 filter_type 是 query，就直接调用 js 来 filter，用的是 jQuery quicksearch。（Icehouse 好像用的不是这个版本）

那么服务端的 filter 是怎么实现的呢？

horizon/tables/base.py

class DataTable 里的 filtered_data 会调用 action 的 filter 函数，而 get_rows 函数会从 filtered_data 里读数据。

    @property
    def filtered_data(self):
        # This function should be using django.utils.functional.cached_property
        # decorator, but unfortunately due to bug in Django
        # https://code.djangoproject.com/ticket/19872 it would make it fail
        # when being mocked by mox in tests.
        if not hasattr(self, '_filtered_data'):
            self._filtered_data = self.data
            if self._meta.filter and self._meta._filter_action:
                action = self._meta._filter_action
                filter_string = self.get_filter_string()
                request_method = self.request.method
                needs_preloading = (not filter_string
                                    and request_method == 'GET'
                                    and action.needs_preloading)
                valid_method = (request_method == action.method)
                if valid_method or needs_preloading:
                    if self._meta.mixed_data_type:
                        self._filtered_data = action.data_type_filter(self,
                                                                self.data,
                                                                filter_string)
                    else:
                        self._filtered_data = action.filter(self,
                                                            self.data,
                                                            filter_string)
        return self._filtered_data

    def get_rows(self):
        """Return the row data for this table broken out by columns."""
        rows = []
        try:
            for datum in self.filtered_data:
                row = self._meta.row_class(self, datum)
                if self.get_object_id(datum) == self.current_item_id:
                    self.selected = True
                    row.classes.append('current_selected')
                rows.append(row)
        except Exception:
            # Exceptions can be swallowed at the template level here,
            # re-raising as a TemplateSyntaxError makes them visible.
            LOG.exception("Error while rendering table rows.")
            exc_info = sys.exc_info()
            raise template.TemplateSyntaxError, exc_info[1], exc_info[2]
        return rows

20150228

2015-02-28T00:00:00+00:00

想着要写篇 blog，现在不知道该写什么了。

春节就算过完了，在家最短的一年，十天。春节过得跟十一没什么区别。。没放鞭炮、没怎么见亲戚，连春联都是三十晚上才贴上的。从大一春节回学校开始，每次回家都这么匆忙，我也没有很想家。在家改了改 Leancloud 的 Android todo list demo。

这次给家里买了米4、小米手环、小米路由 mini、米键，都物超所值啊。米4没什么亮点，手环计步、来电震动、解锁手机挺好用的，路由比 TP-Link 信号强多了，再也不用我的迷你路由做中继了，米键截图很好用。明年看看能不能给家里买个空气净化器…

过年见高中同学最神奇了，本来只有四个宅男见面，吃着饭遇到几个妹子，聊着聊着又遇到个，于是我们就在美食广场从午饭坐到晚饭，这些妹子毕业之后都没见过…

大家都挺拼的，在扬州工作的同学网上投了个简历，就来上海工作了。在哈尔滨的同学看到上海的招聘会，直接飞过来面试。。就这样来上海了。不知道我有没有这勇气诶。某童鞋问了我之后开始在扇贝上被单词，现在已经是66天 * 150词/天了，我都几年没背过了= =

初七，第一次看到这么冷清的上海，好多店铺都没开。虽然有喜欢做的任务，这周还是过得好慢，终于到周末了～新的一年开始了！

20150218新春快乐

2015-02-18T00:00:00+00:00

羊年就要来了，新年快乐！

我现在完全会想不出14年下半年我都干嘛了，好像生命中少了几个月一样。工作效率不高，心情也不太好。只能想到骑车去了趟嘉定，水了一场hackathon。

去年年底好好去玩了一趟，回来之后就不知道为啥就觉得世界很美好了。。2015年感觉很好，工作虽然很忙，但是很开心，发现真的有好多可以学的。

执行力太重要了，比如说要不是某童鞋，去年年底肯定不会出去玩。想做什么就花时间去做嘛，不然以后会后悔的。就像cntrains做出来没花多久:)现在在写Android版yaml的demo（不知道能写到啥程度。。），口琴也到手了，还没开始玩。还想看看gitblog呢。

现在感觉找到了大一时候的感觉:) 万一实现了呢～

Upgrade Openstack From Grizzly To Icehouse

2015-02-14T00:00:00+00:00

首先，我们在Meetup的时候介绍过升级，请看这里的Session 3。说到升级，想起Paris summit的一个视频：Upgrading in Place from Grizzly to Icehouse: A Cautionary Tale，具体说什么没啥印象了，只记得里面那句吐槽：one developer, two weeks，事实证明不可能那么快= =

网上有很多种升级方案，例如RDO的分类就很不错。我们这边的环境对cloud的可用性要求不高，只要已经部署好的VM不受影响，可以接受较长时间不部署/管理虚拟机，所以我们最终选择了pdf里的方案一，就是controller原地升级，其实最后我们觉得换controller也不错…能降低点风险，还好升级时用方案一没遇到太多问题。

升级第一关就是db migration了，理论上来说上游代码里会考虑到升级的问题，每步db migration应该都在代码里面。其实这里还是有些问题的，我们有自己的改动，要先downgrade放弃自己的修改再upgrade，我们旧版上所有代码改动都先放弃了。。

首先就是grizzly的keystone client不支持降级（db sync指定版本），这个很好解决，改改代码咯。还有icehouse的nova db migration只支持从H版升上来，解决办法就是从H版把从G升到H的代码搞过来。。

难点在于neutron的db migration。I版的neutron经过重构，有了ml2 plugin，我们db sync之后还需要用官方提供的migrate to ml2的脚本来改数据库，以支持ml2 plugin。H版的neutron在建VM的时候会把host和port插入portbindingports表，migrate to ml2脚本就会从这个表读数据并插入到ml2_port_bindings表里，network segment的信息是由ovs_network_bindings表搞出来的。（待补充）。。

下面问题来了，portbindingports是H版才有的表，G版根本没有啊，从grizzly升上来也不会建这个表，这样migrate to ml2就会有问题。不过用ovs plugin跑起来没啥问题…最终我们的办法是在db sync之后，migrate to ml2之前把host和port插入进去，这样看起来数据ok！网上没搜到这种问题，很奇怪。还有I版用ovs plugin的时候，如果是手工建的port，neutron不会插入到portbindingports里，migrate to ml2就不会插入ml2_port_bindings表里，但是ml2 plugin会把这种port插入ml2_port_bindings。Anyway，我们最后也把这种unbound的port都插入进去了。

以上就是db migration的问题，我们在测试升级和实际操作的时候还遇到一些问题。

mysql备份出来的sql，注释的地方也是有用的，不能随便删掉。
更新包的时候有些包没有依赖，不会自动更新，要手动搞。
neutron agents由fqdn改成hostname，要删掉inactive的那些（这个文档也写了）
太多坑了= =！

我们整个升级用时是估算时间*2…

下次升级一定要准备更充分一点，估计是升到Kilo或者Liberty了…最好neutron的代码也有人认真看看。其实I版上游的代码还有挺多bug的，要是有能力的话有很多机会贡献代码= =…

研究升级方案时发现有好多好多可以学的东西啊～之前一直有其他需求，没空搞升级，终于在年前搞定这件大事了。（似乎还有坑没发现T_T)

Novaclient 载入 extensions 的过程

2014-10-28T00:00:00+00:00

novaclient/v1_1/contrib里可以加入新的指令，例如：

@utils.arg('server',
        metavar='<server>',
        help=_('Name or UUID of the server to list actions for.'))
def do_instance_action_list(cs, args):
    """List actions on a server."""
    server = utils.find_resource(cs.servers, args.server)
    actions = cs.instance_action.list(server)
    utils.print_list(actions,
        ['Action', 'Request_ID', 'Message', 'Start_Time'], sortby_index=3)

那这个函数是怎么被调用的呢

在 novaclient/shell.py 的 main 里有

# build available subcommands based on version
self.extensions = self._discover_extensions(
        options.os_compute_api_version)

然后找到这个函数

def _discover_extensions(self, version):
    extensions = []
    for name, module in itertools.chain(
            self._discover_via_python_path(),
            self._discover_via_contrib_path(version),
            self._discover_via_entry_points()):

        extension = novaclient.extension.Extension(name, module)
        extensions.append(extension)

    return extensions

self._discover_via_python_path() 会找以 python_novaclient_ext 结尾的 module

def _discover_via_contrib_path(self, version):
    module_path = os.path.dirname(os.path.abspath(__file__))
    version_str = "v%s" % version.replace('.', '_')
    ext_path = os.path.join(module_path, version_str, 'contrib')
    ext_glob = os.path.join(ext_path, "*.py")

    for ext_path in glob.iglob(ext_glob):
        name = os.path.basename(ext_path)[:-3]

        if name == "__init__":
            continue

        module = imp.load_source(name, ext_path)

        yield name, module

其中 glob.iglob(ext_glob) 会生成一个 iterator 循环所有 contrib/*.py，imp.load_source(name, ext_path) 再加载 module。

最后载入 Entry Points novaclient.extensions，参考 http://stackoverflow.com/a/9615473

Cntrains.com Docker 自动部署

2014-09-20T00:00:00+00:00

很久之前就发现余票信息网yupiao.info 上能查到余票、正晚点、车次信息，作者还介绍了网站的实现，我也想自己写一个相似的网站。想了很久都没有动手，几个月前突发奇想去找域名，刚好在 Godaddy 上搜到 cntrains.com 这个域名在拍卖，截止日期刚好是当天，于是我用底价就拍到了，好幸运:-)

买到之后闲置了很久，后来写了个抓盛名时刻表 rar 压缩包的东西。

网站：cntrains.com/smsk

代码：github.com/greenmoon55/cntrains

##获取数据

这个，我不好意思叫爬虫。。盛名时刻表官方的下载地址很好搞到，从下载页面正则匹配一下就可以获取到最新的下载地址，直接 GET 就能下载到，下载地址里时包含发布时间的，我暴力了一下，找到的最旧的版本是去年的，可惜没有更早的。现在用 crontab 每小时查询一次。

##存储

最开始是把压缩包存在本地，然后用数据库记录下来，现在放在七牛云上了，每月免费配额很多，完全用不完，代码也好写。

##代码

代码是用 Django 写的，你可能想问了，为嘛用 Django 呢，就这么一个破网页，呃，因为公司有用到（horizon），顺便看看。

##服务器

最开始用的是Azure免费试用，最近刚刚换成DigitalOcean，DO在墙外要方便一点，感觉Azure还有点小问题，比如内网的DNS。DO看起来挺好用的，一个月5刀可以接受。

##Docker

嗯，这个是跑在 Docker 上的，有必要么？我只是跑着玩玩嘛。Dockerfile里主要就是 pip install了，另外还要自己起 cron。

玩了一下 Docker Hub 的 webhook，就是每次 push 的时候会 POST 一个 json 到自己指定的 URL，我在服务器上又起了个 python http server，接到这个请求就重新 pull image 再 run image。只要 push 就能自动部署啦，分分中搞定，有木有 Heroku 的感觉！

参考：Automagical Deploys from Docker Hub

##未来

首先要把页面稍微改改，至少声明跟软件作者无关。其他功能嘛，暂时懒得弄，我最终目标时要做个自动更新带历史记录的火车时刻表，最好提供个API，其实和 yupiao.info 之前做的差不多，但是没空研究爬虫、验证码方面的东西，很可能会无限期推迟（但愿不会）。

监控和测试目前没有，可以考虑加上。

Docker Hub 支持 Automated Build，就是 push 到 GitHub 之后可以自动根据 Dockerfile build image，但是我有些文件不想传到 GitHub 上（密码、access key），不知道该怎么办，其实现在也不错了。

有个基于 Ubuntu 修改过的 Docker image phusion/baseimage，解决了一些问题，有 cron 和 ssh server，挺热门的。

部署方面，要看看 CoreOS，现在 DO 和 UStack 都支持了。现在还有一些 Docker container hosting 的公司，也就是说以后想部署服务，连 VM 都不用搞，直接 push docker image就可以。比如这两家：Quay.io 和 tutum

前几天看到陈沙克的这条微博，感觉确实很多东西可以用 Docker 来搞了，没必要搞那些 VM 了。

zhxq 最近做了票.今天，能生成每小时余票趋势图，看起来好厉害～

使 Cloud-init 只读取一次 Metadata

2014-07-04T00:00:00+00:00

Linux 的 cloud-init 会在每次启动时运行，默认每次都会读取 metadata，如果 metadata service 挂掉了或者响应缓慢就会使虚拟机重启时花费很多时间，一般 metadata 也不会改变，Windows 上的 cloudbase-init 貌似就只会读一次。

只需配置manual_cache_clean:True，否则在 init-local 时会自动清除缓存，见代码。

        # The cache is not instance specific, so it has to be purged
        # but we want 'start' to benefit from a cache if
        # a previous start-local populated one...
        manual_clean = util.get_cfg_option_bool(init.cfg,
                                                'manual_cache_clean', False)
        if manual_clean:
            LOG.debug("Not purging instance link, manual cleaning enabled")
            init.purge_cache(False)
        else:
            init.purge_cache()
        # Delete the non-net file as well
        util.del_file(os.path.join(path_helper.get_cpath("data"), "no-net"))

毕业设计

2014-06-24T00:00:00+00:00

还是写写毕设的过程吧。从选导师开始，这就是一个很烦的事情。因为热门导师有很多人选，三个志愿其实后两个完全没意义，我就三个都没要我。。还好最后我的导师还不错，很负责的，每一两周都检查我们的进度，提一些建议。

不想随便写个无聊的项目，最开始我的选择是Kaggle上的Personalize Expedia Hotel Searches - ICDM 2013，导师觉得她也不熟，就换了个短文本聚类的题目，最开始的选题是《并行聚类算法在短小文本上的应用》，寒假的时候在家还在看谱聚类的算法，《A Tutorial on Spectral Clustering》（请Google）写得很详细，数学太烂了，看了点线性代数，还是看不懂，后来导师告诉我不用看证明了= =只实现出来就好。接下来几个月就慢慢在意写代码的基础上实现了K-means、层次聚类和谱聚类，再通过WordNet获取相似度，最后就搞定了。。放弃了Hadoop相关的东西，所有内容都是导师提供的，创新性为0。这是答辩PPT。

最后一周的时候，导师叫我把传统文本聚类的向量空间模型也做出来，数据集是路透社经过处理后的一些向量，我还请了假写好代码之后发现求出的最佳聚类数目跟正确答案不匹配，又没有和原始数据的对应关系，根本没法debug。那个时候一个人在新租的房子里非常不爽，我的感受就像在做一个需求不清的项目，到了最后一刻又要改需求。反思之后，感觉我的整体毕设就是一直被导师push，像在完成一个作业一样，应该要反过来才对，最开始就应该好好研究一下我原始的选题，早一点要实验数据，早知道是这样的数据的话就应该很早放弃并行，这么点数据搞毛线啊。还有一点很不爽，就是没有去做数据的预处理，起初还想做twitter真实数据呢。。完全不可能。最后的东西只是在很烂的数据上跑了一下而已。

通过毕设了解一点学术圈了，就是不停地提出想法、做实验、发论文的样子。数据挖掘这边coding其实不太重要，数学不行寸步难行。最后写论文的时候花了很久，写到将近一万字到一万五千字是最艰难的，都不知道些什么好了，最后凑到两万多字，四十多页。假期在家看谱聚类的时候也很不爽的。。还想去嘉定看看大组答辩都有啥呢，那天没去，在印论文。

再列几个有价值的参考资料：

漫谈 Clustering 系列对各种聚类算法都有介绍
Clustering Indices Bernard Desgraupes University Paris Ouest Lab Modal’X April 2013 介绍各种聚类评价方法
Web数据挖掘聚类算法介绍详细，译者还有sjtu的俞勇，不过翻译一般，有些词前后译文都不一样。。
TF-IDF与余弦相似性的应用（一）：自动提取关键词阮一峰的文章，我论文里的传统文本聚类就是在凑字数- -
互联网时代的社会语言学：基于SNS的文本数据挖掘 M67很早以前写的，just for fun

写论文的过程中Word仍然经常崩溃或者按了保存其实没存上，非常感谢Dropbox一直在备份，还保留历史记录。这次学到了Word自动加参考文献、给图片和表格加编号，还有用制表符给公式编号，以后估计也用不到了。

死亡诗社

2014-03-31T00:00:00+00:00

</embed>

寒假在家看超级碗广告的时候发现的这个 iPad 广告，太赞了，吸引我把电影也看了，电影有点“痛斥美国教育”的感觉…里面的诗写得真好。

We don’t read and write poetry because it’s cute. We read and write poetry because we are members of the human race. And the human race is filled with passion. And medicine, law, business, engineering, these are noble pursuits and necessary to sustain life. But poetry, beauty, romance, love, these are what we stay alive for.

还有这一段

To quote from Whitman, “O me! O life!… of the questions of these recurring; of the endless trains of the faithless… of cities filled with the foolish; what good amid these, O me, O life?” Answer. That you are here - that life exists, and identity; that the powerful play goes on and you may contribute a verse. That the powerful play goes on and you may contribute a verse. What will your verse be?

电影里印象很深的还有这段，Mr.Keating 带学生看很多年前也在这所学校上学的学生的照片，这些照片就摆在楼下，现在的学生们每天匆匆走过，从不驻足。照片里的学生和现在的学生差不多，充满希望，不过现在他们已经离世了，最后到底有没有有所成就呢？

They’re not that different from you, are they? Same haircuts. Full of hormones, just like you. Invincible, just like you feel. The world is their oyster. They believe they’re destined for great things, just like many of you, their eyes are full of hope, just like you. Did they wait until it was too late to make from their lives even one iota of what they were capable? Because, you see gentlemen, these boys are now fertilizing daffodils. But if you listen real close, you can hear them whisper their legacy to you. Go on, lean in. Listen, you hear it? - - Carpe - - hear it? - - Carpe, carpe diem, seize the day boys, make your lives extraordinary.

还有电影中评价诗的方法：完美程度为x轴、重要性为y轴，面积越大说明诗越好，真的是笑死了哈哈。于是老师直接让大家把这页书撕掉了。

John Keating (Character) - Quotes - IMDB

残酷青春 (死亡诗社影评) - 豆瓣

烟花三月下扬州

2014-03-26T23:46:00+00:00

还记得小学时全班一起唱《黄鹤楼送孟浩然之广陵》

故人西辞黄鹤楼，烟花三月下扬州，孤帆远影碧空尽，唯见长江天际流。

古人用的是农历，我们三月去扬州的时候，瘦西湖好多花儿还没开，游客倒是已经有很多了。瘦西湖很大，和西湖相比，瘦西湖确实很瘦，感觉更像一条河，有“二十四桥”（寄扬州韩绰判官，扬州慢·淮左名都），有亭台楼阁，有假山瀑布，还有古时的城墙。

湖心岛上的小径，挺有感觉的

从大明寺景区拍瘦西湖，到处都在施工，整个扬州也是，搞得很多尘土。另外看到在修下穿瘦西湖的隧道。

个园，有各种竹子，中国四大名园之一。有很多竹子、假山，四季风景。江南的园林还挺有意思。

何园，刚好赶上人家拍婚纱照，这个角度好漂亮。

别有洞天

复道回廊，走廊连通着各个房子

文昌阁

东关街上一家很精致的贺卡店，这些贺卡都能折起来的哦

瓜州（泊船瓜州）镇杨汽渡，24小时不断

古代的扬州多么繁华，才有了现在这些园林，当年的扬州可能是现在的南京、上海，可惜随着航运的衰落，扬州不再那么重要，感觉城市建设完全比不上苏州。

扬州是个很特别的城市，景点和美食都值得一去，淮扬菜比较清淡，我喜欢，还没吃够，希望有机会再来。不过扬州炒饭没觉得很特别。这次和童鞋们玩得很开心:)

乘坐 CRH2-075C 和 CRH2-076C 往返，还是比普速快多了，这次发现花钱换时间还是很爽的…比如说打车、乘高铁。

20140215

2014-02-15T01:25:00+00:00

时间过得太快啦！转眼间已经过了十五。在家里过了学生时代最后一个寒假，总结一下都干了啥。每次假期最后一天都会很后悔时间利用不够好，当然这次也不例外。

1月19号下午到家，2月8号走，约三周。

20略，23见同学看了kmeans，24-26搞定100行的代码，这一周时间利用还可以。

第二周最不爽了，看线代教材看不下去，上网找视频看，看了一段时间又觉得看不完，又回来看书，浪费了很多时间。。导致过年的时候心情不太好。而且其中很长时间都在玩游戏…以后注意..

最后一周没什么，对于我来说过年区别不大，家里聚聚，跟同学吃吃饭，很快就过去了。值得一提的是三个人一起去了趟烟筒山，这种运转的机会不知道以后还有吗= = 另外我找了几个好久没见的高中同学，财富广场真不错，连高中时在北京吃的比格比萨自助都有..为啥我高中、初中、小学都没人组织聚会呢…真神奇= =！吉林这次有了山寨无印良品风格的店，全场十元…

越长大越想家哈，以后估计只有十一和春节会回家…大概就是飞机回吉林，Z62+G1 或 T60+G13 回上海吧，火车的话就末班高铁到北京然后换临D（如果有的话），这样会累死吧。

最小树形图

2013-12-22T13:31:00+00:00

参考资料：

先翻译一部分上面的 Lecture notes：

最小树形图也就是有向最小生成树。如果有向加权图 G 有子图 T，T 中从某个结点 r 可以到达全部其他结点，并且若这些边是无向边，T 就是最小生成树的话，那么 T 就是 G 上以 r 为根的有向生成树。最小有向生成树就是有向生成树中边权值的和最小的那个。（有点晕。。）

引理 1.1 以下条件等价：

T 是 G 的以 r 为根的有向生成树
r 在 T 中的入度为 0，其它边在 T 中的入度是 1，且 T 是无环的。
r 在 T 中的入度为 0，其它边在 T 中的入度是 1，T 中从 r 到其他任意结点都有有向路径

推论 1.2

设 T 是以 r 为根的有向生成树，设 (u,v) 是不在 T 中的一条边，且 v != r，u 不是 T 中 v 的后续结点（后续结点的意思是 T 中从 v 到 u 有路径），设 (u’, v) 是 T 中终点为 v 的（唯一的）边。那么把 T 加上 (u,v) 去掉 (u,v’) 仍然是一个 r 为根的有向生成树。

定理 4.1

设 G=（V, E, w）是加权有向图，设 r 在 V 中。设 C 是一个不包含 r 的由最小的入边构成的边集。那么，存在一个最小有向生成树，包含 C 中去掉一条边后剩余的边。

证明：设 T 是 G 中以 r 为根的最小有向生成树。设 v1 是 C 中的点，且 T 中从 r 到 v1 不经过 C 中其他的边。（一定至少存在一个点，比如 C 中在 T 上最接近 r 的点中的一个。）按照环上的顺序，设 v1, v2, .., vk 是 C 中的点。如果 (v1, v2), (v2, v3), …, (vk - 1, vk) 属于T，我们就搞定了。不过，假设存在某个 i < k，(v1, v2), (v2, v3), …, (vi - 1, vi) 属于 T，而 (vi, vi + 1) 不属于T。设 T 中 vi + 1 的入边为 (u, vi + 1)。vi 在 T 中的上游结点是 T 中从 r 到 v1 这些结点和 C 上的 v1, v2, …, vi - 1，所以 vi 不是 vi + 1 的下游结点（descendents…）。根据推论1.2，T 去掉 (u, vi + 1) 加上 (vi, vi + 1) 仍然是一个以 r 为根的生成树，记为T‘。既然 (vi, vi + 1) 是进入 vi + 1 的最短边，T’ 也是以 r 为根的最小有向生成树。一直这样做，我们就能构造一个以 r 为根，包含 C 中除了 (vk, v1) 之外所有边的最小有向生成树。

接下来说说做法，根据上面的定理：

找除了根节点外其他点的最小入边，如果哪个点没有，就说明无解
看看现在是否有环，如果无环则找到解了，记录当前选择的所有边的权值和，作为答案。
把环缩点，设 u 是不在环上的点，v 是在环上的点，minEdgeDis[v] 表示 v 的最短入边的权值，那么把边 (u, v) 的权值减去 minEdgeDis[v]。把环上所有的点合并为同一个点。回到第一步。

曾经2011年大连网络赛就出了这个算法的模板题 HDU 4009 Transfer Water，当时好像是 yds 远程过的…我到现在还没去做这道题。

Debian Wheezy 使用 oh-my-zsh 的小问题

2013-12-22T13:26:00+00:00

最近发现默认的 Shell（应该是 bash）有点小问题，果断换成 zsh，装了 oh-my-zsh 之后发现每次开启终端都会显示类似环境变量的东西

查了半天问题在哪，发现是在 ~/.oh-my-zsh/oh-my-zsh.sh 里：

# Check for updates on initial load...
if [ "$DISABLE_AUTO_UPDATE" != "true" ]; then
  /usr/bin/env ZSH=$ZSH DISABLE_UPDATE_PROMPT=$DISABLE_UPDATE_PROMPT zsh $ZSH/tools/check_for_upgrade.sh
fi

执行 /usr/bin/env 的时候会输出这些东西。解决办法就是在第三行重定向输出：

/usr/bin/env ZSH=$ZSH DISABLE_UPDATE_PROMPT=$DISABLE_UPDATE_PROMPT zsh $ZSH/tools/check_for_upgrade.sh &>/dev/null

Horizon 中 Python 元编程的例子

2013-11-27T00:00:00+00:00

Horizon 中创建虚拟机的 workflows 里面有这样一个类，用来选择虚拟机的一些信息，比如配置。GitHub代码

class SetInstanceDetailsAction(workflows.Action):

里面有这几个方法

def populate_image_id_choices(self, request, context):
    images = self._get_available_images(request, context)
    choices = [(image.id, image.name)
               for image in images
               if image.properties.get("image_type", '') != "snapshot"]
    if choices:
        choices.insert(0, ("", _("Select Image")))
    else:
        choices.insert(0, ("", _("No images available.")))
    return choices

def populate_instance_snapshot_id_choices(self, request, context):
    .
    .
    .

def populate_flavor_choices(self, request, context):
    .
    .
    .

这几个方法是用来填充一些页面上的选择框的，看来看去不知道是在哪里被调用的。

于是找父类 workflows.Action

def _populate_choices(self, request, context):
    for field_name, bound_field in self.fields.items():
        meth = getattr(self, "populate_%s_choices" % field_name, None)
        if meth is not None and callable(meth):
            bound_field.choices = meth(request, context)

哈，原来在这里，看出来做什么了吧。太具体的我也还没研究= =

最后，在 __init__ 中有一行。

self._populate_choices(request, context)

看大牛写的高质量代码也有点意思，我想吐槽貌似 Django 的文档不够全面啊，至少跟 Rails 比。

实习感受131127

2013-11-27T00:00:00+00:00

前段时间换了地方实习，现在在携程待了半个多月，我们组主要是做内部的 IAAS，更具体的说貌似只是给其他组分配虚拟机。。最近主要看了 Python, Django 和 Openstack Horizon，Horizon 是基于 Django 的，然后调用 Nova 的 API，Nova 再去用具体的虚拟化技术分配虚拟机，比如 VMware vSphere 和 KVM。刚开始觉得 Python 不太习惯，缩进有点丑，很多地方没有 Ruby 舒服，现在习惯多了。

现在还没什么事情做，没写代码也动力不大，感觉我用了不到百分之七八十的精力。其实对组里具体事情还不了解，晨会都没有，希望下个月能逐渐熟悉起来。现在看起来还不错，就是写代码有点少。= =不知道这个方向是不是有点窄？前两天把三方交给学院，发现我是第一个交的。。

携程让人很不爽的地方就是办公区域太小了，甚至比寝室的桌子还小，过道也很窄。Outlook 没 Gmail 好用，我自己加了存档和星标凑合用，Outlook 跟 Lync 集成看在线状态不错，不过 Lync 没 QQ 好用。

这边同事看起来更 geek 一点，天天玩魔方、用 Vim、看 The Old Reader 等等。这边的电脑也爽多了，下载速度跟寝室差不多，22 寸显示器。还是想吐槽点评几十K的下载速度，下个 Eclipse 都花了好几个小时，网速差都没有加班的动力啊。

当时也可以留在点评的，面试真是个神奇的事情，当年面实习生，跟我水平差不多的同学挂了，我比较轻松地进来，都没问什么问题，转正面试也感觉还好啊，结果几乎挂掉= = 转正面的面试官让我意识到产品有多么重要，其实我花时间做得那个小工具并不是真正需要的东西，不过让我做的 PM 也没说什么嘛= = 我自己确实没想太多。

很怀念点评那边的氛围，就像大学里的朋友一样～点评的工作环境也很赞，在创意园区里，，我觉得比百度都好，虽然百度每个人的空间大一点。组里希望把每个人培养成 full-stack 工程师。

我觉得不好的地方

对这个东西是在没有太大兴趣= = 不想去深入了解 Spring，Struts，当时学校上课就没兴趣
做业务很多人用可能很有成就感，很好玩。听过产品的分享，感觉产品的整体思路很棒，但是，我不是 PM，很多细节不够好，我觉得不能接受，不应该上线，就算是 MVP 也要把体验做到比较好才行啊。这里只说消费的一般用户用到的，比如：
1. 刚开始的时候首页的餐厅预定时间选择是无效的，到了商户页还要再选一遍。有种被耍了的感觉
2. 6.0 还没出来的时候首页上就有下载的广告，点开会发现还是旧版
3. 这个只是我自己想的，可能产品有自己的想法。团购评价和商户评价没合并，很麻烦
4. 对了，预定抽奖的抵用券在团购里没显示，得自己输入号码。。还有细节问题，鼠标不能点的信誉值星级还是手形指针。
改 bug 不够快，大概十月份同学提了个bug，后来发现八月论坛上就有报告。我离职两周前提了公司地图位置标错，走的时候也没改= = 而且不够处女座啊，注意点细节好么。
比较辛苦啊，我觉得每天工作到八九点，回家哪还有心情去学其他技术了，我还想学点工作上用不到的呢，天天这么写业务，我怕一年后我就开始不想写代码了。。
虽然没认真看代码，但是感觉代码质量不会很高的

需求经常变，这是不可避免的= =，我还是想，能不能变得少一点？能不能在 sprint 开始前明确需求？能不能慢一点，体验做得好一点？刚好看到 Fenng 小道消息的《试错》

最后再写下我找工作的标准吧:

Do cool things that matter (via Google)，这个很难定义啊，以后每天大部分时间都在工作，千万不要做得很不爽。
不要太辛苦= = 点评的工作时间已经是我的极限了，不要 996 啊= =
薪水

虽然没认真想过，之前的目标大概是毕业的时候有一线的互联网企业的水平吧，完全没达到啊。上半年找实习的时候发现有点难，然后就想去点评或者百姓网了。现在在携程感觉也还不错，今年应该不会再有面试了。

十一之前注册了携程，定了个旅店，付款后第二天上午告诉我没定成，垃圾邮件总是退订失败。去哪儿有百度支持，也招很多牛人，觉得携程可能没有互联网基因吧，看起来最近转型还不错，以后就算去哪儿发展特别好，携程也能是市场第二吧。

我 06 年就注册了点评，阿里的口碑没打过，网易、百度做得类似的东西也不行。点评只是移动端的入口比较弱，挺看好点评的。

终于写了这篇，以后看肯定会觉得现在很幼稚。。留此存照= =

Skip List 的应用

2013-10-26T00:00:00+00:00

首先这里是 skip list 的介绍。

Redis Sorted Set

之前用 Redis 的 Sorted Set 存在线用户。

# key, score, member
$redis.zadd('online-users', Time.now.to_i, current_user.id)

查询某用户最后访问的时间

last_seen = $redis.zscore("online-users", self.id)

ZADD 的复杂度是 O(log(N))，ZSCORE 的复杂度是 O(1)。

ZSET 是由一个 dict 和 skip list 实现的。dict 是一个根据 member 生成的哈希表，所以 ZSCORE 的复杂度是 O(1)，ZADD 还需插入到 skip list 里所以需要 O(log(N))。

这个 skip list 是根据 score 排序的，所以根据 score 找 member 的复杂度是 O(log(N))，用于 ZRANK 等命令。

有序集 — Redis 设计与实现

倒排索引

前几天在公司听了搜索的分享，才知道这个东西。维基百科

比如有两个到排索引，一个是“五角场”，另外一个是“火锅”。那在搜索“五角场火锅”的时候就要合并这两条链，找出两条链上相同的节点。

如果是普通的链表的话，效率是 O(M + N)。skip list 在合并时，如果另外那个表跳跃过去的节点仍然小于当前表的节点，中间的节点就不用考虑了。

Bash 找出最大的数

2013-10-25T00:00:00+00:00

随机生成一些数据

#!/bin/bash
for i in {1..10}
do
  printf "%d\t%d\n" $i $RANDOM
done

现在要找出右边第三大的数

sort -k2 -n -r temp.txt | sed -n '3p'

-k2 说明按第二列排序
-n 说明当作数字排序
-r 说明由大到小

详见 explainshell.com

sed 简明教程酷壳 - CoolShell.cn

这是百度的面试题和某公司的笔试题

面试问题1

2013-10-07T00:00:00+00:00

#初面

new和malloc的区别

http://stackoverflow.com/questions/240212/what-is-the-difference-between-new-delete-and-malloc-free

New	Malloc
失败时抛出异常	返回 NULL
Free Store	Heap
可重载

进程静态区存了什么

全局变量和静态变量？

Data Segment (Data(variables, string literals) + BSS + Heap)
Stack
Code segment

http://en.wikipedia.org/wiki/Data_segment

text(program code) data bss heap stack

进程和线程的区别

没想到被问到这种问题…

一个进程可能有多个线程共享代码段、数据段

真不知道说什么…

##Web相关，比如（网站）安全、性能优化

CDN、缓存、前端优化，这个当时应该多说一些

查找和排序的关系

不知所云

链表和数组区别

略

树、二叉树的有哪些应用？

树：B树数据库

二叉树：平衡二叉树：C++ std::map

重载和多态区别

override, overload, polymorphism 这几个词要搞清楚…

http://stackoverflow.com/questions/12893907/is-polymorphism-overloading-and-overriding-are-same-concepts

Polymorphism can be achieved through overriding.
Method Overriding
Method Overloading
Operator Overloading

TCP UDP 区别

TCP 三次握手保证传输
UDP best-effort 不保证一定发过去，开销小
视频用UDP，HTTP用UDP。

TCP: connection oriented
UDP: datagram oriented 不保证传输顺序

共30万个url，每个占空间256bytes(unicode)，任意给出一个url，判断是否在里面

十分钟写思路

我的想法：hash然后二分查找…当时应该问问正解怎么做…

二面

C++和C有什么区别

去死吧…

C++ 面向对象，有类的概念。
C++ 有 STL，有 template，有异常处理

然后我就说不出啥了…

额，new/delete，运算符重载…

既然有GC，Java会不会出现内存泄露，什么时候会出现？GC的原理

不知道…

如果一个对象 = null 了就可以被回收了吧。如果在某个循环里生成很多的对象，存到循环外的某个容器里，这样就会内存泄露吧。

http://www.ibm.com/developerworks/cn/java/l-JavaMemoryLeak/

本专业四年学了什么大学里最大的收获最重要的两门专业课是什么

有没有自己课外做的东西（非实习、非课程项目、非外包）

Const Reference To Pointer

2013-09-21T00:00:00+00:00

struct mycomp {
    bool operator()(ListNode * const &a, ListNode * const &b) {
        return a->val > b->val;
    }
};

上学期 euyuil 曾经讲过这方面的东西，现在终于用到了。之前一直写成 const ListNode *，还不明白为什么不对。

这里重载括号也挺有意思，这种东西叫做 functor，我还没想明白为什么不能直接传名为 mycomp 的函数过去。

9.9 — Overloading the parenthesis operator « Learn C++

LeetCode 很不错，网页上的代码编辑器做得相当好，和本地的 CodeBlocks 差不多了。写 C++ 也想把左括号放到行尾了，可惜 CodeBlocks 自动缩进有问题。

MyBatis 与 MySQL Timestamp 类型的问题

2013-08-23T00:00:00+00:00

正常使用时，找不到对应的记录，MyBatis 的日志是这样的。

[DEBUG] 25:52/(BaseJdbcLogger.java:debug:132)
==>  Preparing: SELECT COUNT(id) FROM paths WHERE task_id = ? AND time = ?

[DEBUG] 25:52/(BaseJdbcLogger.java:debug:132)
==> Parameters: 255103(Integer), 2013-08-22 13:40:02.208(Timestamp)

根据 MySQL 的官方文档

TIMESTAMP has a range of ‘1970-01-01 00:00:01’ UTC to ‘2038-01-19 03:14:07’ UTC.

经过测试，把毫秒设为 0 就能正常查找了，也就是2013-01-01 02:03:04.000。

MyBatis 挺好用的，据说公司里用得挺多的。(我还是不想写 Java = =)

20130822上海地铁服务中断

2013-08-22T00:00:00+00:00

八点十几分进入地铁站，准备 2 换 4 到中山公园，海伦路下楼梯的时候听到广播 4 号线延误，果断返回乘坐十号线，坐到了之前那趟 10 号线后面的第二班车。耽误了 10 分钟的时间。走到十号线站台才听到这边的广播说4号线故障。我在换乘通道里刷了一下微博，9 分钟之前就有故障告知，“上海发布”在三分钟之前转发了。看来地铁站反应还没微博快，感觉二号线客流比平时多。

晚上回来，南京东路站台电视上提示由于车门故障，国权路到江湾体育场运行延误。没有任何广播通知，估计是当时基本解决了。

我有个想法是抓取“上海metro”的微博，如果有“突发运营信息”之类的词语就推送给用户。。其实安卓版上海地铁官方应用是有这个功能的，还可以选择推送的线路，不过我这边永远是空白，不知道 iOS 怎么样。

九点多点的时候，中山公园换乘通道已经被完全封锁，凯旋路上有些打车的。中山公园站停着一辆内圈四号线，车内没有照明。

BTW，晚上回来遇到一班终点为龙阳路的二号线，这是要收车了吧。

实习感受

2013-08-19T00:00:00+00:00

实习两周了，虽然面试时选的是前端，入职之后发现其实主要是做 Java EE 的，对前端的要求不高，team 里没有专职的前端，大家都来写。现在仍然处于打杂阶段，都是自己一个人写小项目。

好的地方

环境不错，在一个创意园区
氛围挺好，一个团队的人挺像学校里的同学。我们是做新业务，也稍微有点 Startup 的感觉
用到了一点比较新的东西，比如内部的 GitLab，我们 team 也用到了 MongoDB。下周还有 Hackathon
使用 Google Apps

不好的地方

好辛苦，感觉经常加班的样子，特别是我们 team，我两次在公司吃完饭，发现貌似我们组里走得都很晚，Line Manager 曾经跟我说有时会加班到晚上九十点钟，貌似周末还有人来加班。
网速好慢，肯定到不了 100kb/s，这还是互联网公司？
木有免费的饮料
不想写 Java… 用到各种库、写配置文件，遇到很多莫名其妙的 bug
工作时用到 QQ，难道不怕腾讯获取聊天记录？或许这也是公司里 Linuxer 不多的原因？
或许因为赶进度代码质量不够好，上周差不多每天线上都有 bug 要去做 hotfix…

迁移到 Jekyll

2013-08-11T00:00:00+00:00

Wordpress 放在虚拟主机上太慢了，影响写作欲望…

迁移进行中，预计会持续很久。。

Codeforces Round #191 (Div. 2)

2013-07-13T02:35:58+00:00

比赛是在嘉定做的，只做了A，rating掉到历史新低= =

A. Flipping Game

n个0或1，从中任选i,j，翻转从i到j的数（变成x-1），求最长连续的1。由于n很小（100），直接模拟即可。

B. Hungry Sequence

输出一个递增的序列，要求任意一项不能被其他项整除。序列长度最大为10^5，每个数字不能超过10^7。

如果全部输出质数就是符合条件的，比赛的时候脑残以为质数不够，所以乱搞的，现在看来貌似不太对。。

C. Magic Five

给出一个数字，可以去掉任意个digit，不能全部去掉，可以有leading zero，问能有多少种情况使处理后的数字能被5整除。

这个思路很明显，就是找5和0，然后乘以2^i，i为前面的位数。但是实现上有一些问题。

(ans = 2^i + 2^{l+i} + 2^{2l+i} + … + 2^{(k-1)l+i})

(ans = 2^i * (1 + 2^{l} + 2^{2l} + … + 2^{(k-1)l}))

(1 + 2^{l} + 2^{2l} + … + 2^{(k-1)l} = \frac{2^{k*l}-1}{2^l-1} )

现在的重点就是求出(\frac{2^{k*l}-1}{2^l-1} )

可以根据费马小定理什么的把(\frac{a}{b} \mod{p})转换成(a* b^{p-2} \mod {p}) 但是这里有些问题，我还不太理解证明的过程，比如说费马小定理要求b与p互质，这里没法证吧= =

#include 
#include 
using namespace std;
const int MAXA = 100005;
const int MOD = 1000000007;
int pow(long long a, long long b, long long mod = MOD)
{
  //cout << a << " ^ " << b << " = ";
  long long ans = 1;
  while (b)
  {
    if (b & 1) ans = (ans * a) % mod;
    b >>= 1;
    a = (a * a) % mod;
  }
  //cout << ans << endl;
  return ans;
}
int main()
{
  string str;
  int k;
  cin >> str >> k;
  int l = str.length();
  long long ans = 0;
  for (int i = 0; i < l; i++)
  {
    if (str[i] == '5' || str[i] == '0')
    {
      ans = (ans + pow(2, i)) % MOD;
    }
  }
  ans = ans * (pow((pow(2, k) % MOD), l) % MOD - 1 + MOD) % MOD * pow((pow(2, l) - 1), MOD - 2) % MOD;
  cout << ans << endl;
  return 0;
}

D. Block Tower

对于每个联通块，可以先全部涂成蓝色，然后只保留一个为蓝色（我选的是第一个），其他都换成红色。刚开始我用了BFS，而且还用了deque、struct Point，结果segmentation fault = =

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 505;
char map[MAXN][MAXN];
int n, m;
struct Operation
{
  int x, y;
  char operation;
};
queue ansq;
void ans(int x, int y, char operation)
{
  Operation op;
  op.x = x;
  op.y = y;
  op.operation = operation;
  ansq.push(op);
}
int firsti, firstj;
void search(int x, int y)
{
  map[x][y] = 'T';
  ans(x, y, 'B');
  if (x - 1 >= 0 && map[x-1][y] == '.')
    search(x-1, y);
  if (x + 1 < n && map[x+1][y] == '.')
    search(x+1, y);
  if (y - 1 >= 0 && map[x][y-1] == '.')
    search(x, y-1);
  if (y + 1 < m && map[x][y+1] == '.')
    search(x, y+1);
  if (x == firsti && y == firstj) return;
  ans(x, y, 'D');
  ans(x, y, 'R');
}
int main()
{
  scanf("%d%d", &n;, &m;);
  gets(map[0]);
  for (int i = 0; i < n; i++)
  {
    gets(map[i]);
  }
  for (int i = 0; i < n; i++)
  {
    for (int j = 0; j < m; j++)
    {
      if (map[i][j] == '.')
      {
        firsti = i;
        firstj = j;
        search(i,j);
      }
    }
  }
  printf("%d\n", ansq.size());
  while (!ansq.empty())
  {
    Operation op = ansq.front();
    printf("%c %d %d\n", op.operation, op.x + 1, op.y + 1);
    ansq.pop();
  }
  return 0;
}

130506

2013-05-06T10:55:27+00:00

4月28号下午12306查了一下票，居然有29号的1462，果断买下，顺便买下成都到青岛的K206次，徐州换乘。

11号线一路站着，在火车站仓促地解决午饭，然后上楼候车，上海站感觉真好，只要一进去就感觉好像没有很多人的样子。只有1462和T99在一站台，要先坐电梯回到一楼，然后再走到站台上。1462只有3节YW，貌似其它都是YZ…车上大部分是男的列车员，连广播都是男的。。卧铺始发人很少，到南京基本上满了。

对面铺位是个生意人，她也是前一天的下午才买到票的，我感觉可能1462就是提前一天下午，每十分钟放几张票的…她到山东某地（忘了），大部分乘客都是短途的，南京还上来了一大三童鞋，徐州下车前三个人还讨论了一下大学生活及前途。。随遇而安吧，开心就好。貌似中铺也有个徐州下车的。

本来以为神车会一路早点的，没想到是一路小晚点。貌似无锡就看到旁边站台上写的T112到站时间，不过到了点它还没到，我们先走了。然后常州终于看到T112了，DF11好破，机车号都看不清。然后神车又先走了，貌似是在丹阳被踩的。接下来，过了高资站1462正线停车。。当时感觉特别奇怪，后来龙潭站侧近侧出踩了停在正线的T112，估计是机车有故障吧，坐这车得郁闷死了，特快被神车踩。南京停车的时候又看到了，我还以为它追不上来了呢。

南京出发晚点二十分钟吧，然后徐州之前好像依旧小晚点，徐州提前了几分钟到站，出站非常方便，下车两分钟就出站了，有点旧吉林站的感觉。

徐州作为一个中转站是很方便的，站前有麦当劳、德克士以及豆浆店。我在车上吃过15块的盒饭，感觉比518三十块的盒饭好多了。到麦当劳买杯巧克力看书。。

神车还是很爽的，就是这25G好破啊，速度快的时候晃得很厉害。坐神车，不挂科！话说现在应该求实习对吗？

呆了一个多小时实在受不了了，餐厅里有点热，十点十五左右进站候车，徐州站看起来有点旧，候车室挺多的，车也好多啊，一个候车室里平均就得十分钟一趟吧，不过基本都是过路车，每趟车上车的人不多。K206大约晚点20分钟进站，我等得很急。。济局的车，车上好像都没听到四川话，上车待一会就准备睡觉，这一觉可没睡好，盛名时刻写的兖州到泰山均速43km/h，实际在泰山站停了50分钟左右。我停车的时候睡不着。。开车了才睡着。。到济南又醒了，过了淄博、潍坊车上的人很少很少，两个列车员睡在下铺…最后也早点了二十分钟左右到青岛。其中一位还吐槽说“现在的车越开越慢了”= =

回程选择的是K878烟台到南京+G7041到安亭北。感觉胶州道路有些破旧，车站规模不比吉林西大多少。第一次坐残疾人专用车，定员57，厕所还有坐便和卫生纸，好高端。只有一个问题，就是门关不上…这车比1462平稳多了。胶济客专跟秦沈的感觉差不多，在K207上有种坐车回家的感觉…普速和动车共线，但是在胶州又分开了，普速进胶州站，动车进胶州北，貌似以前丹东到青岛的车也进过胶州北。

上车之后基本就在睡，在淄博待避了三趟动车，晚上上下行动车都多，还看到了G243合肥到青岛，这货要在淄博待避G191北京到青岛，真可怜。。然后又睡到了济南，然后从兖州睡到滁州北，时刻表上显示蚌埠要停站半小时，不过我一点感觉都没有。。睡得很好。

南京同站台停着K784鹰潭到上海，这车有人坐全程吗？比走沪昆多三百多公里。。出站之后走到玄武湖边，买报纸，进站吃绝味鸭血粉丝，南京站换乘挺舒服的，还有KFC和永和豆浆，在一个很偏僻的地方发5100。。

G7041南京发车人不多，最高速度29x，一般27x，可能因为离前车太近（前车停镇江），到丹阳之前减速几次，都到了80km/h。后来人就越来越多了，在无锡追上了K784，在苏州追上了早点10分钟的T109，T109居然是SS8牵引，好吧我是看的涂装颜色。过了昆山南车上稍微超员，安亭北有几个上车的，下车的人好多啊，感觉有五十到一百人，安亭北没有人工检票口，我拿着红纸票只好跟在别人后面…

安亭7路换安亭5路回学校，感觉不错，全程四十分钟左右。

好吧，其实其他的没什么想写的。那几天其实很想回上海，这就是人生吧。。总是不满足，总是不珍惜现在。

其实这些应该写在日记里的。。图片现在懒得传…

使用 writings.io 编辑，强烈推荐！

The 10th Tongji University Collegiate Programming Contest

2013-04-05T02:23:21+00:00

囧，居然不是按时间排序的。

比赛前两天做了一些腾讯的初赛题，热热身，发现我还是很适合这种比较水的题的，写起来觉得挺好玩。

比赛的位置非常不好。。在窗边正对着阳光，而且还没有窗帘。刚开始的时候看了A题，也就是复制粘贴那个，觉得很眼熟不过暂时没思路，然后就发现有人已经过了B，接下来就是跟着 board 做题了，没什么可说的。比赛过程中还遇到了一些问题，比如说 CodeBlocks 一直不能调试、memcpy 参数那个在前那个在后、如何从字符数组选择一些转成 String、怎么写 gcd…当然其实不用 gcd 的，J题队友推了公式，貌似思路错了。我一直没看 J 题。另外 H 题模拟也很坑。

封榜之后过了 E（似乎应该TLE的？），最后半小时左右开始写D，貌似就是个搜索吧？最后几分钟大脑空白状态，和队友一起写完，没测样例就交了，结果TLE。

最后应该是二等奖第一名吧，还不错，本来我想不比去年差太多就好的。我们两个第一次一起比赛，配合还不错，代码几乎都是我敲的，队友想到了A、J算法，还帮我出测试数据。

两年前是这样的，不知道明年还会不会过来～

江城

2013-04-01T06:28:51+00:00

刚上大学的时候发现一本新书《寻路中国》，在季风书园看了一部分觉得挺有趣的。后来发现了他写的另外一本书《江城》。前段时间看过国家地理杂志的Fuling, China Return to River Town，过了一段时间才发现，其实这篇文章的作者就是《江城》的作者“何伟”，我这才去买了这本书。

以前以为，只有吉林和武汉才算江城，其实很多城市都是沿江而建的，它们都可以叫做江城吧。这本书写的是1996年到1998年Peter Hessler在涪陵做志愿者教英语的一些经历，从一个外国人的视角看当时的中国。

大部分中国人都应该听说过涪陵这个名字吧，乌江榨菜可是大家天天都吃的，话说“涪”我还读错了很久。那时的涪陵是一座很有特色的小城，三峡工程尚未完工，出行的主要方式是轮船。

作者来到中国的那段时间正好说我上小学之前的几年，刚刚开始记事，当时的中国还没有很多外国人，我也记得邓小平去世、香港回归。

我发现，我读不懂文学评论了，因为其中晦涩的学术性与作品的优美性相去甚远。对于绝大多数文学评论，我都不太明白，它们好似一团乱麻，无可救药地充塞着令人费解的字眼：解构主义、后现代主义、新历史主义。这一切统统无法得到简单而明了的解释——就像我在涪陵的这些学生，当被问到什么是历史唯物主义，什么是中国特色的社会主义的时候，只能张口结舌。

克莱姆，出于其在华尔街工作的精明的数学头脑，记下了驾驶员摁响喇叭的总次数。在十五分钟的行车过程中，那位驾驶员一共摁响喇叭566次。每分钟37次。

这就是中国的方式。成功乃是预期之中的，而失败则遭到批评。你要么对要么不对，这里没有中间地带。

不过，这样的集体主义仅限于一些小团体、家庭、朋友和单位之内，这些紧密的社交圈也起到了一定的边界作用：它们既包容，又排他。对于自己熟知的圈子外的人，一般的涪陵人几乎很少表现出认同感。

尽管对这一段历史略知一二，我还是觉得人们对三峡大坝工程缺乏兴趣和漠不关心达到了不一般的程度。现在的人们受教育的程度远胜于以往那个年代，在一定程度上，人们应该记住所经历的历史教训，防止因盲目而重蹈覆辙。然而，十分明显的是，普通民众对于三峡大坝和下游城市移民的命运完全漠不关心。

在这本宪法里，我最喜欢的是第一章第三十二条：中华人民共和国对于因为政治原因要求避难的外国人，可以给予受庇护的权利。

因为我知道，中国人总是对其他地方的人抱着一种强烈的偏见。

据说政府有一条规定，如果气温上升到三十七度，所有人都不用上班。因此官方报告的气温总是三十五度。

外国人总是说，中国人很难搞懂，这样的断言一般来说是正确的，但在很多情况下，人们的思想高度同一，可以预测。你只要按下这几个按钮——希特勒、犹太人、日本人、鸦片战争、西藏、台湾，十有八九都可以精准地预测会有怎样的反应，甚至可以精准地预测人们会使用哪些具体的词汇。就中国的具体情况而言——大家基本上属于同一种族、闭关锁国好几百年，目前的教育制度高度单一化和政治化，这是自然而然的事情。

“中共中央总书记、国家主席江泽民推荐观看《泰坦尼克号》，富通珠宝金行独家赞助！”

这本书很有趣，翻译也很不错，有空的时候可以翻翻。。平平淡淡的生活其实并不平凡，所以世界上才会有各种纪录片、纪实文学。

十五年过去了，中国发生了很大的变化，涪陵据说已经成为有很多高楼大厦的典型中国城市。当时何伟班上的学生（大部分来自农村）现在从事着各种各样的工作，基本都过上了“优越的生活”。（《华夏地理》重返江城）

觉得当时那些由志愿者上课的学生好幸福，或许学到的英美文学的比我们现在多，为什么我们不能多学点英语经典呢。突然想到高中时候的外教，已经忘了他说过什么，只记得大部分人都在下面自习…

不知道再过十年，我会在做什么，观念会改变多少。

2013腾讯编程马拉松初赛第〇场

2013-03-30T06:04:23+00:00

很遗憾，连复赛都没进。。cin 超时，一直没想到改成 scanf…

小Q系列故事——屌丝的逆袭

略

小明系列故事——买年货

dp[i][j][l][x] 表示前i个商品，剩余金额j，剩余积分l，剩余免费商品数x。 dp[i][j][l][x] = max(dp[i-1][j][l][x], dp[i-1][j][l][x+1] + val), dp[i-1][j][l+b][x] + val, dp[i-1][j+a][l][x] + val);

#include 
#include 
#include 
#include 
using namespace std;
int dp[110][110][110][6];
int main()
{
    int n, v1, v2, k;
    int a, b, val;
    while (scanf("%d%d%d%d", &n;, &v1;, &v2;, &k;)!= EOF)
    {
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= n; i++)
        {
            scanf("%d%d%d", &a;, &b;, &val;);
            for (int j = 0; j <= v1; j++)
            {
                for (int l = 0; l <= v2; l++)
                {
                    for (int x = 0; x <= k; x++)
                    {
                        dp[i][j][l][x] = dp[i-1][j][l][x];
                        if (x < k) dp[i][j][l][x] = max(dp[i][j][l][x],
                            dp[i-1][j][l][x+1] + val);
                        if (l + b <= v2) dp[i][j][l][x] = max(dp[i][j][l][x],
                            dp[i-1][j][l+b][x] + val);
                        if (j + a <= v1) dp[i][j][l][x] = max(dp[i][j][l][x],
                            dp[i-1][j+a][l][x] + val);
                        //printf("%d %d %d %d %d\n", i,j,l,x,dp[i][j][l][x]);
                    }
                }
            }
        }
        printf("%d\n", dp[n][0][0][0]);
    }
    return 0;
}

吉哥系列故事——临时工计划

dp[i] 表示工作不超过第i天时获得的最多工资。先把工作按结束时间排序一下，然后你懂的。

#include 
#include 
#include 
#include 
using namespace std;
int dp[110][110][110][6];
int main()
{
    int n, v1, v2, k;
    int a, b, val;
    while (scanf("%d%d%d%d", &n;, &v1;, &v2;, &k;)!= EOF)
    {
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= n; i++)
        {
            scanf("%d%d%d", &a;, &b;, &val;);
            for (int j = 0; j <= v1; j++)
            {
                for (int l = 0; l <= v2; l++)
                {
                    for (int x = 0; x <= k; x++)
                    {
                        dp[i][j][l][x] = dp[i-1][j][l][x];
                        if (x < k) dp[i][j][l][x] = max(dp[i][j][l][x],
                            dp[i-1][j][l][x+1] + val);
                        if (l + b <= v2) dp[i][j][l][x] = max(dp[i][j][l][x],
                            dp[i-1][j][l+b][x] + val);
                        if (j + a <= v1) dp[i][j][l][x] = max(dp[i][j][l][x],
                            dp[i-1][j+a][l][x] + val);
                        //printf("%d %d %d %d %d\n", i,j,l,x,dp[i][j][l][x]);
                    }
                }
            }
        }
        printf("%d\n", dp[n][0][0][0]);
    }
    return 0;
}

湫湫系列故事——植树节

这道题很有趣！！搜了题解才会，其实这道题是在求单色三角形的个数。详见这里吧。。懒得画图说明了。

威威猫系列故事——篮球梦

每次攻击的时候 dp[i] = dp[i-1] + dp[i-2] + dp[i-3]，存的就是有多少种。。好多细节，略恶心，还有long long，如果数据不到一局且已经赢了，种数还是1。。

#include 
#include 
#include 
using namespace std;
int main()
{
    int a, b, t;
    while (cin >> a >> b >> t)
    {
        long long sum = 0;
        int defence = t / 30;
        int attack = t / 30 + t % 30 / 15;
        b += defence;
        int gap = b - a;
        if (attack * 3 <= gap) sum = 0;
        else if (attack == 0) sum = 1;
        else
        if (a + attack <= b)
        {
            long long dp[210];
            memset(dp, 0, sizeof(dp));
            dp[1] = dp[2] = dp[3] = 1;
            for (int i = 2; i <= attack; i++)
            {
                for (int j = 200; j >= 1; j--)
                {
                    dp[j] = 0;
                    if (j - 3 > 0) dp[j] += dp[j-3];
                    if (j - 2 > 0) dp[j] += dp[j-2];
                    if (j - 1 > 0) dp[j] += dp[j-1];
                }
            }
            for (int i = gap + 1; i <= 200; i++) sum += dp[i];
        }
        else
        {
            sum = 1;
            for (int i = 0; i < attack; i++) sum = sum * 3;
        }
        printf("%I64d\n", sum);
    }
    return 0;
}

USACO Video Game Troubles

2013-03-30T05:18:34+00:00

BNUOJ 4140

有很多游戏平台，每个平台上有很多游戏，每个游戏有花费和价值。

这道题很有趣，要背包两次，先考虑要不要买某个游戏，再考虑要不要买某个游戏平台。

看了这个题解才明白的：http://blog.sina.com.cn/s/blog_4a0c4e5d010147j3.html

循环过每个平台所有游戏之后，再考虑购买游戏平台的花费，这时候转换为另一个背包问题，要不要买这个平台。

dp[j][k] 表示第i个（当前平台）考虑了j个游戏，预算为k时的最大价值。dp[0][k] 就是前i个平台，当前预算为k的最优值。。

#include 
#include 
#include 
using namespace std;
const int MAXN = 55;
const int MAXG = 15;
int p[MAXN];
int g[MAXN];
int gp[MAXN][MAXG], pv[MAXN][MAXG];
int dp[MAXN][100010];
int main()
{
    int n, v;
    while (scanf("%d%d", &n;, &v;)!=EOF)
    {
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &p;[i]);
            scanf("%d", &g;[i]);
            for (int j = 1; j <= g[i]; j++)
            {
                scanf("%d%d", &gp;[i][j], &pv;[i][j]);
            }
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= g[i]; j++)
            {
                for (int k = v; k >= 0; k--)
                {
                    if (k >= gp[i][j]) dp[j][k] = max(dp[j-1][k], dp[j-1][k-gp[i][j]] + pv[i][j]);
                    else dp[j][k] = dp[j-1][k];
                }
            }

            for (int k = v; k >= p[i]; k--)
            {
                dp[0][k] = max(dp[0][k], dp[g[i]][k-p[i]]);
            }
        }
        printf("%d\n", dp[0][v]);
    }
    return 0;
}

130312

2013-03-12T12:33:03+00:00

还以为标题可以是 120312 呢，那样更好玩一点。

其实呢，这个世界挺神奇的，有的时候感觉很公平，有的时候又好像也不是。

还记得高中班主任问什么是幸福？我说活着就是幸福。真的啊。。活到十八、二十是很幸运的事情啊，并不是必然事件嘛。。

有的人学X很轻松，有人花了很长时间也学不会X，而如果学Y就可能完全不一样。

其实上一句话不是重点。。所以，顺其自然吧～享受生活，享受这个世界。

为什么 Kosaraju 算法一定要把所有边反向

2013-03-12T12:13:59+00:00

算法课上介绍说，Kosaraju 算法的大概步骤是

DFS反向图，记录每个点的出栈顺序
逆序（出栈顺序）遍历，找到所有的强连通分量

正确性证明略…见课程 PDF…

很自然地想到一个问题…为什么不能在原图 DFS，然后顺序遍历呢？

想想证明里的那个例子，从强连通分量 SCC1 到 SCC2 有一条边，反向之后DFS，能保证最后出栈的点一定在 SCC2 中，因此第二次 DFS 时能找到正确的结果。如果在原图 DFS，则不能保证第一个出栈的点在哪里…呃，很简单嘛…

比如说 A->B，B->A, A->C 这个图，如果出栈顺序是BAC就杯具了= =

其实这个例子是网上搜到的…

快排笔记

2013-02-27T11:20:18+00:00

另一种快排的实现方法，算法课讲的。感觉这个挺容易懂的，都忘了以前怎么写的了= =。

首先选择数组中第一个元素为 pivot，先不管它，引入 i, j 两个指针。从左向右扫描数组，j 分隔开扫描过的元素和未知的元素，从第二个元素到 i 之前都比 pivot 小，从 i 到 j 都比 pivot 大，当然等于 pivot 的元素放在哪边都可以啦。扫描时如果遇到比 pivot 小的元素，与 i 后面那个元素交换即可，然后再右移 i。最后交换第一个元素和 i 左边的数。

实际代码中 a[i] 表示数组中大于 pivot 的第一个数（当然也可能还没扫到），最后和 a[i-1] 交换。

int partition(int *a, int l, int r)
{
    int p = a[l]; // pivot
    int i = l + 1;
    for (int j = l + 1; j <= r; j++)
    {
        if (a[j] < p)
        {
            swap(a[j], a[i]);
            i++;
        }
    }
    swap(a[l], a[i - 1]);
    return i - 1;
}
void quicksort(int *a, int l, int r)
{
    int p = partition(a, l, r);
    if (l < p - 1) quicksort(a, l, p - 1);
    if (p + 1 < r) quicksort(a, p + 1, r);
}

如果选取其他 pivot 怎么办呢？先交换第一个数和新的 pivot 就可以了。

TEDxFDUSalon：因为这是真的

2012-12-27T16:09:32+00:00

上个月去看了 TEDxFDU，拖到现在还没写点什么呢，把记下来的东西随便写写好了。

暖场演讲有个很惊人的题目 Ted is SHIT，让大家思考参加活动的目的。联想自己、不要吐槽、生活中多折腾。

一、兰启昌 http://www.lanqc.com 事实与真相，事实不等于真相，我忘了他这里怎么讲的了，感觉确实是这样。。有些记者和读者都有一些偏见 “中国逻辑”比如说：A：这酒真难喝 B：… 新闻专业主义，还没找到英文怎么说，要独立于权贵、资本、大多数人或特立独行。他提到了两个他喜欢的人：李海鹏和吴晓波

二、沈奕斐社会性别：文化的力量女主内，男主外？

她介绍了社会性别的概念，有的时候社会对个体的“期望”和他/她自身的喜好是不一样的。

三、Junxian Lee 授人以鱼不如授人以渔，所以他们帮助印度洋海啸受灾某地区如何晒盐，而不是直接捐款。三个观点： follow your heart try be do have 而不是 do have be

四、刘雨阳又是一个物理转到软件工程的学生他说在做校园活动海报上的二维码什么的…想到了我们的软工项目。虚拟世界与真实世界：指令：能量数据：物质《Matrix》虚拟世界不能实现：细节（Retina也要舍弃）、随机（伪随机）

五、贝敏貌似是大学以后就一直靠家教养活自己，去旅行，在黄山差点丧命= =

六、丁琦亮 PhD：拓展人类知识，想到了这个图。研究人类学，好强大，还有这门学科。

七、龚金平顺势而为的人生。我初中开始就想，每天开开心心的就好了嘛。

=== 大概就记得这些有点意义。。好像学生都是直奔主题，教师/教授都会先说：“很高兴今天来到这里…” 最后回想一下，到底有什么收获呢？好像没什么哎…只是了解了一些别人的想法，不同的工作、人生。我感觉自己话都不会说了= =

嘉定那个 ACE Project 可以弄成类似的形式吧。。我还一次都没去过。想要变得更 social 一点，不能太宅了= = 英语社我也没帮上多少忙，不知道下学期怎么样呢。

Ruby on Rails 环境配置

2012-11-06T12:11:15+00:00

Updated @ 2013/3/21 21:21

下载 RVM (Ruby Version Manager)

在终端里执行

curl -L https://get.rvm.io bash -s stable

可能需要先安装 curl

关闭当前打开的终端窗口，重新打开
执行

sudo apt-get install build-essential openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake libtool bison subversion pkg-config

安装 Ruby 2.0.0

输入

rvm install 2.0.0

请耐心等待，可以出去转一圈或者睡一觉了…

点击终端的“编辑”菜单，选择“配置文件首选项”，切换到“标题和命令”选项卡，选择“以登录Shell方式运行命令”，然后重启终端
输入

rvm 2.0.0 –default

如果没有任何显示，应该是正常的。此时输入

ruby -v

应该会显示 ruby 的版本号。

由于某些原因，我们使用淘宝的 Rubygems 镜像

gem source -r http://rubygems.org/ gem source -a http://ruby.taobao.org

安装rails

gem install rails

至少需要半小时吧…

TopCoder SRM 558 DIV 2

2012-10-22T08:33:20+00:00

先吐个嘈。。这次题目太难了吧。。第二题整个房间没人交，第三题只有两个人交，而且都 Failed System Test…

250 略

600 读题很重要！读题很重要！又一次写好了才发现错误。。 dp[i][j]表示盖章到第i个字符，颜色为j，最少盖几次。细节很容易错= =

#include 
#include 
#include 
#include 
using namespace std;
const int MAX = 0x7f7f7f7f;
inline int min(const int &a;, const int &b;, const int &c;)
{
    cout << "min" << min(min(a, b), c)  << endl;
    return min(min(a, b), c);
}
class Stamp
{
    public:
    string str;
    int length;
    bool used[300];
    int getMinimumCost(string desiredColor, int stampCost, int pushCost)
    {
        str = desiredColor;
        length = desiredColor.size();
        int dp[55][4];
        int ans = MAX;
        for (int l = 1; l <= length; l++) // 章的长度为l
        {
            memset(used, 0, sizeof(used));
            memset(dp, 0x7f, sizeof(dp));
            for (int i = 0; i < l; i++)
            {
                used[str[i]] = true;
            }
            int sum = used['R'] + used['G'] + used['B'];
            if (sum <= 1)
            {
                if (sum == 0)
                {
                    dp[l - 1][1] = dp[l - 1][2] = dp[l - 1][3] = 1;
                }
                else
                {
                    if (used['R']) dp[l - 1][1] = 1;
                    else if (used['G']) dp[l - 1][2] = 1;
                    else if (used['B']) dp[l - 1][3] = 1;
                }
            }
            for (int i = l; i < length; i++) // 当前盖章到第i个字符（含）
            {
                // 0????????????
                for (int j = i - l; j < i; j++) // 上一个章到第j个字符（含）
                {
                    if (dp[j][1] == MAX && dp[j][2] == MAX && dp[j][3] == MAX) continue;
                    memset(used, 0, sizeof(used));
                    for (int k = i - l + 1; k <= i; k++)
                    {
                        used[str[k]] = true;
                    }
                    int sum = used['R'] + used['G'] + used['B'];
                    if (sum > 1)
                    {
                        continue;
                    }
                    if (j == i - l)
                    {
                        int temp = min(dp[j][1], dp[j][2], dp[j][3]) + 1;
                        if (sum == 0)
                        {
                            dp[i][1] = dp[i][2] = dp[i][3] = temp;
                        }
                        else
                        {
                            if (used['R']) dp[i][1] = temp;
                            else if (used['G']) dp[i][2] = temp;
                            else dp[i][3] = temp;//used['B']
                        }
                    }
                    else
                    {
                        if (sum == 0)
                        {
                            dp[i][1] = min(dp[i][1], dp[j][1] + 1);
                            dp[i][2] = min(dp[i][2], dp[j][2] + 1);
                            dp[i][3] = min(dp[i][3], dp[j][3] + 1);
                        }
                        else
                        {
                            if (used['R']) dp[i][1] = min(dp[i][1], dp[j][1] + 1);
                            else if (used['G']) dp[i][2] = min(dp[i][2], dp[j][2] + 1);
                            else dp[i][3] = min(dp[i][3], dp[j][3] + 1);
                        }
                    }
                }
            }
            if (min(dp[length - 1][1], dp[length - 1][2], dp[length - 1][3]) == MAX) continue;
            int temp = stampCost * l + min(dp[length - 1][1], dp[length - 1][2], dp[length - 1][3]) * pushCost;
            if (temp < ans) ans = temp;
        }
        return ans;
    }
};

900 通过搜索，才知道这是一个经典博弈题，叫做 The Game of Nim，异或一下就可以了，好神奇。

#include 
#include 
#include 
using namespace std;
class CatAndRabbit
{
    public:
    string getWinner(string tiles)
    {
        int length = tiles.size();
        bool hasBlack = false, hasWhite = false;
        for (int i = 0; i < length; i++)
        {
            if (tiles[i] == '#') hasBlack = true;
            else if (tiles[i] == '.') hasWhite = true;
        }
        if (!hasBlack || !hasWhite) return "Rabbit";
        int s = 0;
        while (tiles[s] == '#') ++s;
        int l = 0;
        int a[100], p = 0;
        while (s < length)
        {
            if (tiles[s] == '#')
            {
                if (tiles[s - 1] == '.')
                {
                    a[p++] = l;
                    l = 0;
                }
                else
                {
                    ++s;
                    continue;
                }
            }
            else ++l;
            ++s;
        }
        if (tiles[length - 1] == '.')
        {
            a[p++] = l;
        }
        int ans = 0;
        for (int i = 0; i < p; i++) ans = ans ^ a[i];
        if (ans == 0) return "Rabbit";
        else return "Cat";
    }
};

苏宁退货记

2012-10-16T06:42:00+00:00

10月1日于上海苏宁徐家汇旗舰店（肇嘉浜路店）购入三星NP530U3C-A01CN一台。当时发现屏幕亮度不均，苏宁员工认为正常。

10月X日（似乎是五号），去徐家汇太平洋电脑一期20楼三星售后服务站，工程师认为正常。值得一提的是当时只有我一个人去检修，却等了半小时左右，理由是工程师在修昨天的机器。

10月7日，再去三星售后，简单的说问题是电脑休眠唤醒时会进入Windows错误恢复。售后查不出问题，电脑留下来检修。

10月9日中午，工程师来电话说他们仍然找不到问题，需要返厂检测。我说要退货，万一返厂直接修好了怎么办。。

10月12日早9点多，工程师说他没有返厂，可以出具检测单。下午我就去开了检测单，注明日期是7号。然后去苏宁要求换货，苏宁说当时没货但可以帮我调货，当晚可以到，让我第二天来换，卖电脑的人还给我留了电话，好像说了有货会通知我。

10月13日早上，我没有接到电话，于是主动打电话问，苏宁说还没货，我只好去退，办了一部分手续。有些东西被我妈拿回家了，没有办法拿过来，苏宁说要我再交50元左右买个包就可以，耳机就不算了。然后说中午有些手续办不了，叫我下午再去，于是我回了趟本部。下午再去，他们复印了发票、身份证、检测单等等，然后说需要联系南京什么的，要周一晚上之后来办退款，给我写了个收条。我问了退款是退到银行卡里还是退现金，貌似她说她不清楚。

10月16日，一直打不通留的电话，我还是去了，售货员说是她手机有问题，难道你就不能给我打个电话？最后说要付款的银行卡，已经被我妈拿走了啊。。问过两次售货员退货需要什么，都没说需要这个，其实她也不清楚。总之，没有任何人说过需要付款的银行卡。火车票退票就不用银行卡的嘛。

于是上了地铁往回走，手机上网查了一下，打苏宁客服4008-365-365，某客服在询问后告诉我可以退货，于是我在上海体育馆下车坐回去。苏宁收银人员仍然坚持不能退且态度非常不好，于是我又打了一遍电话，电话里的客服让我把手机给收银员，然后收银员吼了客服一顿。。。最后客服和我说确实不行。。这个好好笑哦。。还管我要前一位客服的工号，我根本就没记嘛。。

于是现在手里一张发票一张退货单，等待快递银行卡中。。已经过了退货时间，不知道还会不会有麻烦。反正我都复印/拍照了，实在不行只好找消协什么的了～

To be continued… @十一号线马陆站 Sent from my Android…….

在实体店买东西就是为了退换货、维修的时候方便点嘛。。

苏宁的问题

应该加强对员工的培训。。说明退货需要什么，比如说身份证、付款的银行卡。
不能400和门店员工说法不一样，看他们吵真好笑。。
收银和某个新来的员工态度较差，后者不停地问我电脑是什么故障，很不相信我。。话说电脑要是没问题服务站会给我出检测报告吗？你当服务站是傻子啊。。
整个退货流程时间太长，我12号说要换货，13号知道没货了，决定退货。就算带了银行卡当天也拿不到钱。。
不能出尔反尔吧，要回赠品可以理解，但是不能先说了不要，今天又说要吧。。

本来对苏宁的印象要略好于国美的，现在。。以后肯定不会优先考虑苏宁了。

为了退换货现在已经往返三次了，单程1个半小时，地铁要7块钱。等到银行卡到了再去，难道银行卡挂失了或者销户了就不能退款了？

Trainspotter badge, Level 8!

2012-09-29T15:03:50+00:00

8月26号从昆山南坐动车回来拿到的 badge，收到邮件之后感觉很好玩，查了一下这些单词：

MTA 是纽约大都会运输署。 Tube 是伦敦地铁哦，以前只知道伦敦地铁叫 Underground…伦敦可是地铁的发源地哦。 Shinkansen 当时是新干线啦，地球人都知道。 Trans-Siberian 是西伯利亚大铁路，北京到莫斯科的国际列车就经过这里吧。

最后很好玩，”backpackers who haven’t showered in a week.”

原来火车迷也可以叫做 Trainspotter，其实以前一直以为邮件里这个单词是 Transporter…

明天或后天准备体验一下22号线。

120922

2012-09-22T14:56:31+00:00

今年第一场网络赛，还好不是完全没想法，一道简单搜索写了很久，还TLE一次，另外的概率dp，xw的想法有点问题，后来有点思路我也不愿意细想了，没到五点就撤了，很不爽。。

120921

2012-09-21T15:30:33+00:00

和老妈中午昆山101+沪宁高铁去了趟苏州，再高铁回然后镇坪路换北安线回来。

沪宁城际太火了，赶到安亭北的时候最后一张票正好被前面的人买走= = 昆山南到苏州的坑爹G上座率也是几乎100%，（全程上海到常州的，在昆山南还要待避后面的G…），苏州买票时前两班也基本没票了，去虹桥的D居然还有二等座。

20:40左右，感觉人多果断没有坐北安跨，等到的北安线有很多空座，一小时回来，感觉不错。昆山101有点慢= =

这次去观前街、苏州博物馆、平江路看了一圈。平江路那边有种古镇的感觉，很多小房子，其实再稍微多点店铺就好了，但是不要太多…听到苏州公交的本地报站了，苏州地铁还没坐过。

沪宁城际现在这样都该加车了吧…人真多。

120920

2012-09-20T15:41:10+00:00

前段时间很想写blog的，后来又不想了，今天没收到OhLife的邮件，又登陆不上。在这里写写吧= =

医院水很深，家里有这方面的人会好很多。注意身体多休息这学期选课真纠结，课表今天才定下来。有些课有点无聊没去交换有点遗憾，大四去的话更影响实习吧… GC分组学习感觉怪怪的。。不过挺好的，希望能坚持到最后，自己也多学点东西笔记本仍然纠结中。。本来看好了一个，结果京东突然涨价了，不想再挑了，要疯了。。开始做题吧，现在完全没有信心，十一看看能不能提升点。还有…有没有可能呢。。

写这个好无聊。早睡吧，多休息，都要困死了！

Codeforces Round #133 (Div. 2)

2012-08-15T15:43:08+00:00

这次比赛很爽啊，四题，room leader。Rating 终于过 1500 了。Div. 2 专场的题目貌似要简单一些。 A. Tiling with Hexagons 分成几个平行四边形，再减去相邻平行四边形重合的面积。(ab+bc+c*a-(a+b+c)+1)

B. Forming Teams 这道题有个很强烈的限制条件，每个学生最多有两个敌人。于是分为三种情况，环、链和孤立的点，如果环上的结点数为奇数，这个环上一定有个点要被取下。有偶数个节点的链也可以平分为两份，有奇数个节点的链分完之后只能是某一份多一个，奇数个有奇数个节点的链的结果还是某一份多一个，再考虑孤立的点，所以其实只要考虑环，然后剩下的节点数如果是奇数就去得掉一个。

#include 
#include 
using namespace std;
int map[105][105];
void addedge(int a, int b)
{
    map[a][++map[a][0]] = b;
}
int ans;
int visited[105];
void search(int node, int depth)
{
    if (visited[node])
    {
        if (depth - visited[node] > 1)
        {
            if ((depth - visited[node]) % 2) ++ans;
            return;
        }
        else return;
    }
    visited[node] = depth;
    for (int i = 1; i <= map[node][0]; i++)
    {
        search(map[node][i], depth + 1);
    }
}
int main()
{
    int n, m;
    cin >> n >> m;
    int a, b;
    for (int i = 0; i < m; i++)
    {
        cin >> a >> b;
        addedge(a, b);
        addedge(b, a);
    }
    for (int i = 1; i <= n; i++)
    {
        if (!visited[i]) search(i, 1);
    }
    if ((n - ans) % 2) ++ans;
    cout << ans << endl;
    return 0;
}

C. Hiring Staff 这道题也有非常强的限制条件，(m\leq n) 且 (n \neq 1)。写写算算就出来答案了。第一天需要 k 个人，第 n 天需要一个，第 n+1 天需要 k-1 个，若 (m \leq n-1)，到此结束。若 (m=n)，第 2n 天还需要一个，到此结束。其实如果 m > n，应该是第 in 天一个，第 in+1 天 k-1 个吧，(k \geq2)，直到 n+m+1 天为止。

#include 
#include 
using namespace std;
int a[1000000];
int count = 0;
int n, m, k;
void work()
{
    if (k == 1)
    {
        int i = 1;
        while (i < n + m + 1)
        {
            a[count++] = i;
            i += n - 1;
        }
    }
    else
    {
        for (int i = 0; i < k; i++) a[count++] = 1;
        a[count++] = n;
        for (int i = 0; i < k - 1; i++) a[count++] = n + 1;
        if (m <= n - 1) return;
        if (m == n)
        {
            a[count++] = n * 2;
            return;
        }
        if (m > n)
        {
            int i = 2 * n;
            while (true)
            {
                if (n + m + 1 >= i) break;
                a[count++] = i;
                if (n + m + 1 >= i) break;
                ++i;
                a[count++] = i;
                i += n - 1;
            }
        }
    }
}
int main()
{
    cin >> n >> m >> k;
    work();
    cout << count << endl;
    cout << a[0];
    for (int i = 1; i < count; i++) cout << " " << a[i];
    cout << endl;
    return 0;
}

D. Spider’s Web 这题最难的地方在于读题。对于每个 sector 处理一下就可以了。每个 sector 可能有 (10^5) 个 bridge，bridge 的总数不超过 (10^5)，开数组存不下，只好用 vector 啦。

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 1010;
int ans = 0;
vector num[MAXN];
void work(int cur, int prev, int next)
{
    int pcur = 0, pp = 0, pn = 0;
    while (num[prev][pp] < num[cur][pcur] && pp < num[prev].size()) ++pp;
    while (num[next][pn] < num[cur][pcur] && pn < num[next].size()) ++pn;
    ++pcur;
    while (pcur < num[cur].size())
    {
        int oldpp = pp, oldpn = pn;
        while (num[prev][pp] < num[cur][pcur] && pp < num[prev].size()) ++pp;
        while (num[next][pn] < num[cur][pcur] && pn < num[next].size()) ++pn;
        if (pp - oldpp != pn - oldpn) ++ans;
        ++pcur;
    }
}
int main()
{
    int n, k, temp;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> k;
        for (int j = 0; j < k; j++)
        {
            cin >> temp;
            num[i].push_back(temp);
        }
        sort(num[i].begin(), num[i].end());
    }
    for (int i = 2; i < n; i++)
    {
        work(i, i - 1, i + 1);
    }
    work(1, n, 2);
    work(n, n - 1, 1);
    cout << ans << endl;
    return 0;
}

Codeforces Round #132 (Div. 2)

2012-08-14T02:34:36+00:00

A. Bicycle Chain 略

B. Olympic Medal 可以很容易地推出公式，有些变量直接用double了，用int相乘会溢出。

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 5010;
double x[MAXN], y[MAXN], z[MAXN];
int main()
{
    int n, m, k;
    double a, b;
    cin >> n;
    for (int i = 0; i < n; i++) cin >> x[i];
    cin >> m;
    for (int i = 0; i < m; i++) cin >> y[i];
    cin >> k;
    for (int i = 0; i < k; i++) cin >> z[i];
    cin >> a >> b;

    sort(x, x + n);
    sort(z, z + k);
    double r1 = x[n - 1];
    double p2 = z[0];
    double ans = 0;
    for (int i = 0; i < m; i++)
    {
        double temp = sqrt(b * y[i] * r1 * r1 / (a * p2 + b * y[i]));
        if (temp >= r1) continue;
        ans = max(ans, temp);
    }
    printf("%.10lf\n", ans);
    return 0;
} 

C. Crosses 这题折腾死我了。。Virtual paticipation的时候我猜是个DP，完全没思路。看了题解才知道，是枚举包含Cross的最小矩形，然后算一下四角需要去掉多大面积，枚举某方向的边长，到sqrt(area)即可，全部枚举会超时。如果是矩形，a,b和c,d可以交换位置，所以算两种情况。这里要注意一下。。我有点晕，WA好多次。

#include 
#include 
#include 
using namespace std;

int main()
{
    int n, m, s;
    cin >> n >> m >> s;
    long long ans = 0;
    for (int i = 1; i <= n; i += 2)
    {
        for (int j = 1; j <= m; j += 2)
        {
            if (i * j < s) continue;
            long long v = (n - i + 1) * (m - j + 1);
            if (i * j == s)
            {
                v *= 2 * (i / 2 + 1) * (j / 2 + 1) - 1;
            }
            else
            {
                int area = i * j - s;
                if (area % 4 != 0) continue;
                area /= 4;
                int temp = 0;
                int length = sqrt(area);
                for (int k = 1; k <= length; k++)
                {
                    if (area % k != 0) continue;
                    if (k * 2 < i && area / k * 2 < j) temp++;
                    if (k * 2 < j && area / k * 2 < i) temp++;
                }
                if (length * length == area)
                    if (length * 2 < i && length * 2 < j) temp--;
                v *= temp * 2;
            }
            ans += v;
        }
    }
    cout << ans << endl;
    return 0;
}

D. Hot Days 这题的题目描述好复杂，当时看了好久才懂。第一反应是三分法，后来一想，只有两种可能嘛，一种是有足够多的车，没有“罚款”，另外一种是只有一辆车，可能有罚款。如果车的数量不够多，罚的钱和只有一辆车是一样的。注意一定会罚款的情况，因为这个WA一次= =

#include 
#include 
#include 
using namespace std;
int main()
{
    long long n, m;
    long long t, T, x, cost;
    long long ans = 0;
    cin >> n >> m;
    while (n--)
    {
        cin >> t >> T >> x >> cost;
        if (T <= t)
        {
            ans += cost + m * x;
            continue;
        }
        long long count = ceil(m / (double)(T - t));
        long long t1 = count * cost;
        long long t2 = cost + m * x;
        ans += min(t1, t2);
    }
    cout << ans << endl;
    return 0;
}

2012 Multi-University Training Contest 6

2012-08-13T11:00:58+00:00

官方题解：2012 Multi-University Training Contest 6 Solution 1001 Card int length = r - l + 1; 循环节的长度一定是LCM(r, length) / length，然后就好做了吧…代码里把lcm写成lcd了。

#include 
#include 
using namespace std;
inline int gcd(int a, int b)
{
    int t;
    while (b > 0)
    {
        t = a % b;
        a = b;
        b = t;
    }
    return a;
}
inline long long lcd(long long a, long long b)
{
    return a * b / gcd(a, b) ;
}
int main()
{
    int t, n, l, r;
    int card[55];
    int N = 52;
    scanf("%d", &t;);
    for (int caseno = 1; caseno <= t; caseno++)
    {
        for (int i = 1; i <= N; i++) scanf("%d", &card;[i]);
        scanf("%d%d%d",&n;, &l;, &r;);
        int length = r - l + 1;
        int loop = lcd(r, length) / length; // 循环节长度
        int shift = n % loop * length % r;
        shift = r - shift + 1;
        printf("Case #%d:", caseno);
        for (int i = shift; i <= r; i++) printf(" %d", card[i]);
        for (int i = 1; i < shift; i++) printf(" %d", card[i]);
        for (int i = r + 1; i <= N; i++) printf(" %d", card[i]);
        printf("\n");
    }
    return 0;
}

1006 Party All the Time 对于每个精灵，unhappiness都是与选定的聚会地相关的凹函数，而多个凹函数相加一定还是凹函数（貌似根据定义就可证），所以可以使用三分法。似乎这道题会有精度问题。

#include 
#include 
#include 
using namespace std;
const int MAXN = 50010;
const double eps = 1e-6;
double x[MAXN], w[MAXN];
int n;
double calc(double pos)
{
    double ans = 0;
    for (int i = 0; i < n; i++)
    {
        ans += w[i] * pow(fabs(x[i] - pos), 3);
    }
    return ans;
}

int main()
{
    int t;
    scanf("%d", &t;);
    for (int caseno = 1; caseno <= t; caseno++)
    {
        scanf("%d", &n;);
        for (int i = 0; i < n; i++) scanf("%lf%lf", &x;[i], &w;[i]);
        double left = x[0], right = x[n - 1];
        double leftmid, rightmid;
        double leftvalue, rightvalue;
        while (left + eps < right)
        {
            leftmid = (left + right) / 2;
            rightmid = (leftmid + right) / 2;
            leftvalue = calc(leftmid);
            rightvalue = calc(rightmid);
            if (leftvalue < rightvalue) right = rightmid;
            else left = leftmid;
        }
        printf("Case #%d: %.0lf\n", caseno, calc(left));
    }
    return 0;
} 

1008 String change 看官方题解吧。。这思路太神奇了。

1010 Easy Tree DP? 题中条件的意思是，左右子树中最大的元素一定在右子树。搜到一篇题解，遗憾的是现在找不到了。。dp[i][j]表示用了i个节点，高度小于等于j的方案数。 dp[i][j] = i * (dp[i-1][j-1] * 2 + c[i-2][k] * dp[k][j-1] * dp[i-k-1][j-1])，k为左子树的节点数。

#include 
#include 
#include 
using namespace std;
const int MAXN = 365;
const int MOD = 1000000007;
int c[MAXN][MAXN];
long long dp[MAXN][MAXN];
int main()
{
    freopen("test.in", "r", stdin);
    int t, n, d;
    c[0][0] = 1;
    for (int i = 1; i < MAXN; i++)
    {
        c[i][0] = 1;
        for (int j = 1; j <= i; j++)
        {
            c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
        }
    }
    n = 360;
    memset(dp, 0, sizeof(dp));
    for (int i = 1; i <= n; i++) dp[1][i] = 1;
    for (int i = 2; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            dp[i][j] += 2 * dp[i-1][j-1] % MOD;
            dp[i][j] %= MOD;
            for (int k = 1; k < i - 1; k++)
            {
                dp[i][j] += c[i-2][k] * dp[k][j-1] % MOD * dp[i-1-k][j-1] % MOD;
                dp[i][j] %= MOD;
            }
            dp[i][j] *= i;
            dp[i][j] %= MOD;
        }
    }
    scanf("%d", &t;);
    for (int caseno = 1; caseno <= t; caseno++)
    {
        scanf("%d%d", &n;, &d;);
        printf("Case #%d: %lld\n", caseno, ((dp[n][d] - dp[n][d-1]) % MOD + MOD) % MOD);
    }
    return 0;
}

2012 Multi-University Training Contest 5

2012-08-13T10:19:23+00:00

官方题解：2012 Multi-University Training Contest 5 Solution

1003 Gold miner 分组背包，详见《背包问题九讲》。用点积判断是否在一条直线上。

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 210;
struct gold
{
    int x, y, t, v;
}g[MAXN];
int dp[40010];
bool sameGroup(int a, int b)
{
    return g[a].x * g[b].y == g[b].x * g[a].y;
}
bool comp(const gold &a;, const gold &b;)
{
    return a.y < b.y;
}
int main()
{
    int n, t;
    int group[MAXN][MAXN];
    int caseno = 0;
    while (scanf("%d%d", &n;, &t;)!= EOF)
    {
        int groupCount = 0;
        memset(group, 0, sizeof(group));
        for (int i = 0; i < n; i++)
            scanf("%d%d%d%d", &g;[i].x, &g;[i].y, &g;[i].t, &g;[i].v);
        sort(g, g + n, comp);
        for (int i = 0; i < n; i++)
        {
            bool found = false;
            for (int j = 1; j <= groupCount; j++)
            {
                if (sameGroup(i, group[j][1]))
                {
                    gold* prev = &g;[group[j][group[j][0]]];
                    ++group[j][0];
                    group[j][group[j][0]] = i;
                    g[i].t += prev->t;
                    g[i].v += prev->v;
                    found = true;
                    break;
                }
            }
            if (found) continue;
            ++groupCount;
            ++group[groupCount][0];
            group[groupCount][1] = i;
        }
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= groupCount; i++)
        {
            for (int time = t; time >= 0; time--)
            {
                for (int j = 1; j <= group[i][0]; j++)
                {
                    //if (time - g[group[i][j]].t < 0) break;
                    if (time - g[group[i][j]].t >= 0)
                    dp[time] = max(dp[time], dp[time - g[group[i][j]].t]
                                      + g[group[i][j]].v);
                }
            }
        }
        printf("Case %d: %d\n", ++caseno, dp[t]);
    }
    return 0;
}

1004 History repeat itself 不停地求sqrt(N)，得到比N小的新平方数的个数，然后加上这个数，直到找不到新的平方数为止。此时正好有N个非平方数（新加的数都是平方数）。然后可以很方便地推出公式求和。

#include 
#include 
#include 
using namespace std;
int main()
{
    int t, n;
    cin >> t;
    while (t--)
    {
        scanf("%d", &n;);
        long long m = n;
        long long add = sqrt(m);
        long long count = 0;
        while (add)
        {
            m += add;
            count += add;
            add = sqrt(m) - count;
        }
        cout << m << " ";
        long long x = count - 1;
        cout << x * (x+1) * (2*x+1)/3+(x+x*x)/2 + (m - count*count + 1) * count << endl;
    }
    return 0;
}

1007 Permutation 很容易想到这道题其实就是求，一些数相加和为N，它们的最小公倍数有多少种情况。遗憾的是没往下想，直接想DP没思路。官方题解：由于1不影响最小公倍数，问题转化为相加小于等于N的若干正整数的最小公倍数的可能数。再考虑，如果两个数不互质，最小公倍数与少一些因子变得互质的情况相同。所以只要考虑这些正整数是质数即可，注意每个数可能出现多次。 dp[i][j]表示前i种质数，构成和为j有多少种情况。 dp[i][j] = dp[i-1][j] + dp[i-1][j-k*prime[i]]

#include 
#include 
#include 
#include 
using namespace std;
long long dp[1010][1010];
int main()
{
    int n, primeCount = 0;
    int p[1000];
    for (int i = 2; i < 1010; i++)
    {
        int s = sqrt(i);
        bool prime = true;
        for (int j = 2; j <= s; j++)
        {
            if (i % j == 0)
            {
                prime = false;
                break;
            }
        }
        if (prime) p[++primeCount] = i;
    }
    int temp;
    while (scanf("%d", &n;) != EOF)
    {
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i <= primeCount; i++) dp[i][0] = 1;
        long long ans = 0;
        for (int i = 1; i <= primeCount; i++)
        {
            if (n - p[i] < 0)
            {
                for (int j = 0; j <= n; j++) ans += dp[i-1][j];
                break;
            }
            temp = p[i];
            for (int j = n; j > 0; j--)
            {
                dp[i][j] = dp[i - 1][j];
            }
            while (n - temp >= 0)
            {
                for (int j = n; j > 0; j--)
                {
                    if (j - temp < 0) break;
                    dp[i][j] += dp[i - 1][j - temp];
                }
                temp *= p[i];
            }
        }
        cout << ans << endl;
    }
    return 0;
}

1011 Xiao Ming’s Hope 找规律，这题我用cin居然超时，不知道为什么。

#include 
#include 
using namespace std;
int main()
{
    int n;
    while (scanf("%d", &n;) != EOF)
    {
        int count = 0;
        do
        {
            if (1 & n) ++count;
            n >>= 1;
        } while(n);
        printf("%d\n", 1 << count);
    }
    return 0;
}

TopCoder SRM 551 DIV 2

2012-08-08T06:06:05+00:00

250 略

500 枚举中心，然后两边往中间移，当时想错了= =

#include 
#include 
using namespace std;
class ColorfulChocolates
{
    public:
    int maximumSpread(string chocolates, int maxSwaps)
    {
        int ans = 1;
        for (int i = 0; i < chocolates.length(); i++)
        {
            int left = i - 1;
            int leftCount = 0;
            int rightCount = 0;
            int right = i + 1;
            char color = chocolates[i];
            int curSwaps = maxSwaps;
            int dis;
            while (left >= 0 || right < chocolates.length())
            {
                if (left >= 0 && chocolates[left] == color)
                {
                    dis = i - 1 - leftCount - left;
                    leftCount++;
                    curSwaps -= dis;
                    if (curSwaps < 0) break;
                    ans = max(ans, leftCount + rightCount + 1);
                }
                if (right < chocolates.length() && chocolates[right] == color)
                {
                    dis = right - (i + 1 + rightCount);
                    rightCount++;
                    curSwaps -= dis;
                    if (curSwaps < 0) break;
                    ans = max(ans, leftCount + rightCount + 1);
                }
                --left;
                ++right;
            }
        }
        return ans;
    }
};

950 DP 三种纸杯蛋糕，相邻的朋友得到的蛋糕不一样。很容易想出dp[i][j][k][l]表示前i个朋友，发了j个A纸杯蛋糕，k个B纸杯蛋糕，第i个朋友的蛋糕种类为l。问题是怎么处理最后一个人和第一个不能相同呢，其实只要枚举第一个蛋糕是哪种，DP三次，然后处理最后一个人获得的蛋糕即可。

#include 
#include 
#include 
using namespace std;
const int MOD = 1000000007;
class ColorfulCupcakesDivTwo
{
    int dp[55][55][55][3];
    int length, count[3];
    public:
    void work()
    {
        for (int i = 1; i < length; i++)
        {
            for (int j = 0; j <= i; j++) // 用A的数量
            {
                for (int k = 0; k <= i - j; k++) // 用B的数量
                {
                    if (dp[i][j][k][0])
                    {
                        if (count[1] - k > 0) dp[i+1][j][k+1][1] = (dp[i+1][j][k+1][1] + dp[i][j][k][0]) % MOD;
                        if (count[2] - (i - j - k) > 0) dp[i+1][j][k][2] = (dp[i+1][j][k][2] + dp[i][j][k][0]) % MOD;
                    }
                    if (dp[i][j][k][1])
                    {
                        if (count[0] - j > 0) dp[i+1][j+1][k][0] = (dp[i][j][k][1] + dp[i+1][j+1][k][0]) % MOD;
                        if (count[2] - (i - j - k) > 0) dp[i+1][j][k][2] = (dp[i][j][k][1] + dp[i+1][j][k][2]) % MOD;
                    }
                    if (dp[i][j][k][2])
                    {
                        if (count[0] - j > 0) dp[i+1][j+1][k][0] = (dp[i][j][k][2] + dp[i+1][j+1][k][0]) % MOD;
                        if (count[1] - k > 0) dp[i+1][j][k+1][1] = (dp[i][j][k][2] + dp[i+1][j][k+1][1]) % MOD;
                    }
                }
            }
        }
    }
    int countArrangements(string cupcakes)
    {
        length = cupcakes.length();
        memset(count, 0, sizeof(count));
        for (int i = 0; i < length; i++)
        {
            ++count[cupcakes[i] - 'A'];
        }
        int ans = 0;
        if (count[0])
        {
            memset(dp, 0, sizeof(dp));
            dp[1][1][0][0] = 1;
            work();
            for (int j = 0; j <= length; j++)
            {
                for (int k = 0; k <= length - j; k++)
                {
                    ans = (ans + dp[length][j][k][1]) % MOD;
                    ans = (ans + dp[length][j][k][2]) % MOD;
                }
            }
        }
        if (count[1])
        {
            memset(dp, 0, sizeof(dp));
            dp[1][0][1][1] = 1;
            work();
            for (int j = 0; j <= length; j++)
            {
                for (int k = 0; k <= length - j; k++)
                {
                    ans = (ans + dp[length][j][k][0]) % MOD;
                    ans = (ans  + dp[length][j][k][2]) % MOD;
                }
            }
        }
        if (count[2])
        {
            memset(dp, 0, sizeof(dp));
            dp[1][0][0][2] = 1;
            work();
            for (int j = 0; j <= length; j++)
            {
                for (int k = 0; k <= length - j; k++)
                {
                    ans = (ans + dp[length][j][k][0]) % MOD;
                    ans = (ans + dp[length][j][k][1]) % MOD;
                }
            }
        }
        return ans;
    }
};

2012 Multi-University Training Contest 4

2012-08-08T05:41:54+00:00

官方题解：http://page.renren.com/601081183/note/864084778 1001 Image Recognition 从01矩阵中找四条边都是1的正方形。按照官方题解做的。可以预处理出每一点上下左右四个方向上全部是1的长度，用l, r, u, d表示。接下来的想法是对于每条对角线（左上到右下），判断各点(i, j)到能到达的最远点(i + min(r[i][j], d[i][j], j + min(r[i][j], d[i][j])，共min(r[i][j], d[i][j]个点里，哪些点往左上可以延伸到原来的(i, j)点，也就是(x, y)的坐标减去min(l[x][y], u[x][y])。这样是三次方的算法，会超时的。在扫描对角线的时候记录各点能往左上延伸到哪里，相当于记录下坐标。若点(i, j)为1，定义一个区间为从点(i, j)开始到最远点(i + min(r[i][j], d[i][j], j + min(r[i][j], d[i][j])。当扫描到区间始点时，减去左上延伸到始点(i, j)以外的点的个数，扫描到区间终点时，加上左上延伸到始点以外的点的个数，这样就能算出区间内符合条件的点的个数。用线段树来维护每个点往左上能延伸到哪里，线段树的每个区间存区间内点的个数即可。复杂度O(n^2*logn）。写得好累啊。。

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 1010;
int map[MAXN][MAXN];
int u[MAXN][MAXN], d[MAXN][MAXN], l[MAXN][MAXN], r[MAXN][MAXN];
int a[MAXN];
int visit[MAXN][MAXN];
struct node
{
    int l, r, count;
}tree[MAXN * 4];
void build(int num, int l, int r)
{
    tree[num].l = l;
    tree[num].r = r;
    tree[num].count = 0;
    if (l != r)
    {
        int mid = (l + r) / 2;
        build(num * 2, l, mid);
        build(num * 2 + 1, mid + 1, r);
    }
}
void insert(int num, int pos, int value)
{
    tree[num].count += value;
    if (tree[num].l == tree[num].r) return;
    int mid = (tree[num].l + tree[num].r) / 2;
    if (pos <= mid) insert(num * 2, pos, value);
    else insert(num * 2 + 1, pos, value);
}
int query(int num, int l, int r)
{
    if (tree[num].l == l && tree[num].r == r) return tree[num].count;
    int mid = (tree[num].l + tree[num].r) / 2;
    if (r <= mid) return query(num * 2, l, r);
    if (l > mid) return query(num * 2 + 1, l, r);
    return query(num * 2, l, mid) + query(num * 2 + 1, mid +1, r);
}
int work(int xx, int yy, int count)
{
    int ans = 0;
    build(1, 1, count);
    int x = xx, y = yy;
    //memset(visit, 0, sizeof(visit)); 会超时
    for (int i = 1; i <= count; i++) visit[i][0] = 0;
    for (int i = 1; i <= count; i++)
    {
        if (map[x][y] == 1)
        {
            a[i] = i - min(u[x][y], l[x][y]) + 1;
            if (i > 1) ans -= query(1, 1, i - 1);
            insert(1, a[i], 1);
            int temp = i + min(d[x][y], r[x][y]) - 1;
            visit[temp][++visit[temp][0]] = i;
        }
        if (visit[i][0]) for (int j = 1; j <= visit[i][0]; j++)
        {
            ans += query(1, 1, visit[i][j]);
        }
        ++x;
        ++y;
    }
    return ans;
}
int main()
{
    int t, casenum = 0;
    int n;
    cin >> t;
    while(t--)
    {
        scanf("%d", &n;);
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
            {
                scanf("%d", &map;[i][j]);
                if (map[i][j] == 1)
                {
                    u[i][j] = u[i-1][j] + 1;
                    l[i][j] = l[i][j-1] + 1;
                }
                else
                {
                    u[i][j] = 0;
                    l[i][j] = 0;
                }
            }
        memset(d, 0, sizeof(d));
        memset(r, 0, sizeof(r));
        for (int i = n; i >= 1; i--)
            for (int j = n; j >= 1; j--)
            {
                if (map[i][j] == 1)
                {
                    d[i][j] = d[i+1][j] + 1;
                    r[i][j] = r[i][j+1] + 1;
                }
                else
                {
                    d[i][j] = 0;
                    r[i][j] = 0;
                }
            }
        int ans = 0;
        for (int i = 1; i <= n; i++)
        {
            ans += work(1, i, n - i + 1);
        }
        for (int i = 2; i <= n; i++) ans += work(i, 1, n - i + 1);
        printf("Case %d: %d\n", ++casenum, ans);
    }
    return 0;
} 

1004 Trouble 给出五组数，每组各取一个，问能否使和为一。分成两组、两组、一组。前两组求所有情况，存在sum1里，中间两组存在sum2里，排序sum1、sum2，然后对于最后一组的每个数，找sum1、sum2里有没有两个数的和为这个数的相反数。复杂度O(n^3)。

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 205;
long long sum1[MAXN*MAXN], sum2[MAXN*MAXN];
long long num[6][MAXN];
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        int n;
        cin >> n;
        for (int i = 0; i < 5; i++)
        {
            for (int j = 0; j < n; j++) scanf("%I64d", &num;[i][j]);
        }
        int count = 0;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                sum1[count] = num[0][i] + num[1][j];
                sum2[count++] = num[2][i] + num[3][j];
            }
        }
        sort(sum1, sum1 + count);
        sort(sum2, sum2 + count, greater());
        bool found = false;
        for (int i = 0; i < n; i++)
        {
            long long goal = -num[4][i];
            int p1 = 0;
            int p2 = 0;
            while (p1 < count && p2 < count)
            {
                if (sum1[p1] + sum2[p2] == goal)
                {
                    found = true;
                    break;
                }
                if (sum1[p1] + sum2[p2] < goal) p1++;
                else p2++;
            }
            if (found) break;
        }
        if (found) puts("Yes");
        else puts("No");
    }
    return 0;
} 

1009 Query 给出两个字符串，随时可能修改某个字符，找出从任意字符开始，最长字符相同的长度。这题如果想到怎么建线段树就很好做了，可惜当时想不到。记录区间里第一个不同的字符的位置。找所求位置到最后第一个不同字符的位置即可。

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int MAXL = 1000010;

char s1[MAXL], s2[MAXL];
struct node
{
    int l, r, pos;
}tree[MAXL * 4];
int length;

inline int getleft(const int &a;, const int &b;)
{
    if (a == -1) return b;
    if (b == -1) return a;
    return min(a, b);
}

void build(int num, int l, int r)
{
    tree[num].l = l;
    tree[num].r = r;
    if (l < r)
    {
        int mid = (l + r) / 2;
        build(num * 2, l, mid);
        build(num * 2 + 1, mid + 1, r);
        tree[num].pos = getleft(tree[num*2].pos, tree[num*2 + 1].pos);
    }
    else
    {
        if (s1[l] == s2[l]) tree[num].pos = -1;
        else tree[num].pos = l;
    }
}

int query(int num, int l, int r)
{
    if (l == tree[num].l && r == tree[num].r) return tree[num].pos;
    int mid = (tree[num].l + tree[num].r) / 2;
    if (r <= mid) return query(num * 2, l, r);
    if (l > mid) return query(num * 2 + 1, l , r);
    return getleft(query(num * 2, l, mid), query(num * 2 + 1, mid + 1, r));
}

void modify(int num, int pos)
{
    if (tree[num].l == tree[num].r)
    {
        if (s1[pos] == s2[pos]) tree[num].pos = -1;
        else tree[num].pos = tree[num].l;
    }
    else
    {
        int mid = (tree[num].l + tree[num].r) / 2;
        if (pos <= mid) modify(num * 2, pos);
        if (pos > mid) modify(num * 2 + 1, pos);
        tree[num].pos = getleft(tree[num*2].pos, tree[num*2 + 1].pos);
    }
}

int main()
{
    int t, caseno = 0, q, action, a, pos;
    char ch;
    cin >> t;
    char useless[10];
    while (t--)
    {
        printf("Case %d:\n", ++caseno);
        gets(useless);
        scanf("%s", s1);
        scanf("%s", s2);
        length = min(strlen(s1), strlen(s2));
        //cout << length << endl;
        build(1, 0, length - 1);
        scanf("%d", &q;);
        while (q--)
        {
            scanf("%d", &action;);
            if (action == 1)
            {
                scanf("%d %d %c", &a;, &pos;, &ch;);
                if (pos >= length) continue;
                if (a == 1)
                {
                    if (s1[pos] == ch) continue;
                    if (s1[pos] != s2[pos] && ch != s2[pos])
                    {
                        s1[pos] = ch;
                        continue;
                    }
                    else s1[pos] = ch;
                }
                if (a == 2)
                {
                    if (s2[pos] == ch) continue;
                    if (s1[pos] != s2[pos] && ch != s1[pos])
                    {
                        s2[pos] = ch;
                        continue;
                    }
                    else s2[pos] = ch;
                }
                modify(1, pos);
            }
            else
            {
                scanf("%d", &pos;);
                int result = query(1, pos, length - 1);
                if (result != -1) printf("%d\n", result - pos);
                else printf("%d\n", length - pos);
            }
        }
    }
    return 0;
} 

2012 Multi-University Training Contest 3

2012-08-08T04:09:17+00:00

官方题解：http://blog.renren.com/blog/601081183/863771603

1001 Arcane Numbers 1 问任意一个A进制有限小数，能否用B进制有限小数表示。 A进制小数可以转换为X*A^(-n)，n为小数部分位数，这个数除以任意次B^(-i)，i从1递增，直到得到一个整数，也就是说，如果A的质因子在B中都包含即可。注意A的某个质因子可能大于sqrt(A)，这道题就因为这个WA到最后= =

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 1000010;
int prime[MAXN];
bool notprime[MAXN];
int primecount = 0;
void getprime()
{
    memset(notprime, 0, sizeof(notprime));
    for (int i = 2; i < MAXN; i++)
    {
        if (!notprime[i])
        {
            prime[primecount++] = i;
            for (int j = 2; i * j < MAXN; j++)
            {
                notprime[i * j] = true;
            }
        }
    }
}
int main()
{
    int t;
    long long a, b;
    cin >> t;
    getprime();
    for (int tt = 1; tt <= t; tt++)
    {
        printf("Case #%d: ", tt);
        cin >> a >> b;
        if (a < 0 || b < 0)
        {
            puts("NO");
            continue;
        }
        if (a == b && a != 0)
        {
            puts("YES");
            continue;
        }
        if (a <= 1 || b <= 1)
        {
            puts("NO");
            continue;
        }
        int end = sqrt(a);
        bool ok = true;
        for (int i = 0; i < primecount; i++)
        {
            if (prime[i] > end) break;
            if (a % prime[i] == 0)
            {
                if (b % prime[i] != 0)
                {
                    ok = false;
                    break;
                }
                while (a % prime[i] == 0)
                {
                    a /= prime[i];
                }
            }
        }
        if (a > 1)
        {
            if (b % a != 0) ok = false;
        }
        if (ok) puts("YES");
        else puts("NO");
    }
    return 0;
}

1004 Magic Number 求字符串间的编辑距离 dp[i][j]可以表示为把第一个字符串前i个字符转换为第二个字符串前j个字符需要的操作数。 dp[i][j] = min(dp[i-1][j]+1（删除原串第i个字符）, dp[i][j-1]+1（插入新串第j个字符）, dp[i-1][j-1]+(oldstr[i]==newstr[j])?0:1（修改）)

#include 
#include 
#include 
#include 
using namespace std;
char magic[1510][15];
char query[15];
inline int min(const int &a;, const int &b;, const int &c;)
{
    if (a < b) return a < c ? a : c;
    else return b < c ? b : c;
}

int main()
{
    int t, n, m;
    int f[15][15];
    int limit;
    scanf("%d", &t;);
    for (int tt = 1; tt <= t; tt++)
    {
        scanf("%d%d", &n;, &m;);
        printf("Case #%d:\n", tt);
        getchar();
        for (int i = 0; i < n; i++) gets(magic[i]);
        for (int ii = 0; ii < m; ii++)
        {
            scanf("%s%d", query, &limit;);
            int ans = 0;
            for (int jj = 0; jj < n; jj++)
            {
                int x = strlen(query);
                int y = strlen(magic[jj]);
                f[0][0] = 0;
                for (int i = 1; i <= x; i++) f[i][0] = i;
                for (int j = 1; j <= y; j++) f[0][j] = j;
                for (int i = 1; i <= x; i++)
                {
                    for (int j = 1; j <= y; j++)
                    {
                        f[i][j] = min(f[i-1][j]+1, f[i][j-1]+1, f[i-1][j-1] + ((query[i-1] == magic[jj][j-1])? 0:1));
                    }
                }
                if (f[x][y] <= limit) ++ans;
            }
            printf("%d\n", ans);
        }
    }
    return 0;
} 

1005 Triangle LOVE 给出一个竞赛图（由无向完全图给每条边加方向构成），问有没有长度为3的环。方法一，从任意一点出发遍历整个图，搜的时候记录深度，找环。http://euyuil.com/2687/codeforces-117c-cycle/ 官方题解里的增量算法有点晕。。竞赛图上如果有环，则一定存在长度为3的环。因为若有长度为n的环，一定有长度为n-1的环，画一下就懂了。所以只要DFS判断有没有环即可。最简单的想法：若存在两个点出度相同则存在长度为3的环。先找出两个点A和B，若A到B有边，此时A出度为1，B出度为0。对于其他任意一点C，有以下四种情况：AB出度都加一，AB出度不变、A出度加一，B出度不变、A出度不变，B出度加一。要想使AB出度相同，必须有B的出度加一、C的出度不变的情况，B到C、C到A有边才可以。这样ABC就形成了一个环。神奇的图论啊！

1006 Flowers 花在一段时间内开放，问某一时刻最多开多少花。很明显，离散化区间更新的线段树，没想到这道题过的人这么多。。大家都好强啊。把每个区间离散为三个点，如[1,4]分为[1,1],[2,3]和[4,4]即可。

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 100010;
struct flower
{
    int s, t;
}f[MAXN];
struct Node
{
    int l, r;
    int sum, inc;
}tree[MAXN * 4 * 4];
int mycount;
int a[MAXN * 2];

void build(int num, int l, int r)
{
    tree[num].l = l;
    tree[num].r = r;
    int mid = (l + r) / 2;
    if (l < r)
    {
        build(num * 2, l, mid);
        build(num * 2 + 1, mid + 1, r);
    }
}

int convert(int x)
{
    int left = 0;
    int right = mycount - 1;
    int mid;
    while (left < right)
    {
        mid = (left + right) / 2;
        if (x > a[mid]) left = mid + 1;
        else right = mid;
    }
    return left * 2;
}

void getsegment(int x, int &s;, int &t;)
{
    int left = 0;
    int right = mycount - 1;
    int mid;
    while (left <= right)
    {
        mid = (left + right) / 2;
        if (x == a[mid])
        {
            s = mid * 2;
            t = mid * 2;
            return;
        }
        if (x > a[mid] && x < a[mid + 1])
        {
            s = mid * 2 + 1;
            t = mid * 2 + 1;
            return;
        }
        if (x > a[mid])
        {
            left = mid + 1;
        }
        else
        {
            right = mid - 1;
        }
    }
}

void add(int num, int l, int r, int value)
{
    if (tree[num].l == l && tree[num].r == r)
    {
        tree[num].inc += value;
        return;
    }
    int mid = (tree[num].l + tree[num].r) / 2;
    if (l > mid) add(num * 2 + 1, l, r, value);
    else if (r <= mid) add(num * 2, l, r, value);
    else
    {
        add(num * 2, l , mid, value);
        add(num * 2 + 1, mid + 1, r, value);
    }
}

int query(int num, int l, int r)
{
    if (l == tree[num].l && r == tree[num].r)
    {
        return tree[num].sum + tree[num].inc;
    }
    int mid = (tree[num].l + tree[num].r) / 2;
    if (tree[num].inc)
    {
        add(num * 2, tree[num].l, mid, tree[num].inc);
        add(num * 2 + 1, mid + 1, tree[num].r, tree[num].inc);
        tree[num].sum += tree[num].inc;
        tree[num].inc = 0;
    }
    if (l > mid) return query(num * 2 + 1, l, r);
    else if (r <= mid) return query(num * 2, l , r);
    else
    {
        return query(num * 2, l, mid) + query(num * 2 + 1, mid + 1, r);
    }
}

int main()
{
    int t;
    int n, m;
    cin >> t;
    for (int tt = 1; tt <= t; tt++)
    {
        memset(tree, 0, sizeof(tree));
        printf("Case #%d:\n", tt);
        cin >> n >> m;
        int temp = 0;
        for (int i = 0; i < n; i++)
        {
            scanf("%d%d", &f;[i].s, &f;[i].t);
            a[temp++] = f[i].s;
            a[temp++] = f[i].t;
        }
        sort(a, a + temp);
        mycount = unique(a, a + temp) - a;
        build(1, 0, (mycount - 1) * 2);
        for (int i = 0; i < n; i++)
        {
            add(1, convert(f[i].s), convert(f[i].t), 1);
        }
        int pos;
        for (int i = 0; i < m; i++)
        {
            scanf("%d", &pos;);
            if (pos < a[0] || pos > a[mycount - 1])
            {
                printf("0\n");
                continue;
            }
            int s, t;
            getsegment(pos, s, t);
            printf("%d\n", query(1, s, t));
        }
    }
    return 0;
} 

1009 Cut the cake 对于颜色相间的正方形，用dp[i][j]表示右下角为(i,j)的最大矩形边长，实时更新答案，首先判断(i,j)，(i-1,j)，(i,j-1)这三个点，若颜色不合法则记为1。若dp[i][j-1]等于dp[i-1][j]，要判断左上角那个点的颜色是否符合。若dp[i][j-1]不等于dp[i-1][j]，dp[i][j] = min(dp[i][j-1], dp[i-1][j]) + 1。对于颜色相同的矩形，其实就是一个找最大子矩形的问题，推荐王知昆的论文《浅谈用极大化思想解决最大子矩形问题》，用到里面第二种方法。定义悬线为从矩形上边，上端点覆盖了一个障碍点或达到整个矩形上端的有效竖线（不覆盖任何障碍点），把悬线尽量左右移动，就可以形成一个矩形。考虑每个悬线（最多NM个）最多能移动多少就能求出最大子矩形。需要left[i][j]，right[i][j]，height[i][j]三个数组，分别记录，往左、往右、往上能移动到哪里。从上往下扫，然后每行从左往右、从右往左各扫一遍，leftmost记录最左非障碍点位置，left[i][j] = max(left[i-1][j], leftmost)，右边同理。遇到障碍点就把left[i][j]置为1，right[i][j]置为m，height[i][j]置为0。O(NM)

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 1010;
char map[MAXN][MAXN];
int dp[MAXN][MAXN];
int height[MAXN][MAXN], l[MAXN][MAXN], r[MAXN][MAXN];
int work(char ch, const int &n;, const int &m;)
{
    memset(height, 0, sizeof(height));
    int ans = 0;
    int leftmost , rightmost;
    for (int j = 1; j <= m; j++)
    {
        l[0][j] = 1;
        r[0][j] = m;
    }
    for (int i = 1; i <= n; i++)
    {
        leftmost = 1;
        rightmost = m;
        for (int j = 1; j <= m; j++)
        {
            if (map[i][j] != ch)
            {
                leftmost = j + 1;
                height[i][j] = 0;
                l[i][j] = 1; //不影响下一行的min 和 max
                r[i][j] = m;
            }
            else
            {
                height[i][j] = height[i-1][j] + 1;
                l[i][j] = max(l[i-1][j], leftmost);
            }
        }
        for (int j = m; j >= 1; j--)
        {
            if (map[i][j] == ch)
            {
                r[i][j] = min(r[i-1][j], rightmost);
                ans = max(ans, (r[i][j] - l[i][j] + 1 + height[i][j]) * 2);
            }
            else
            {
                rightmost = j - 1;
            }
        }
    }
    return ans;
}
int main()
{
    char s[MAXN];
    int t, n, m;
    cin >> t;
    for (int tt = 1; tt <= t; tt++)
    {
        scanf("%d%d", &n;, &m;);
        gets(s);
        for (int i = 1; i <= n; i++) gets(map[i] + 1);
        int ans = 0;
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                if (i > 1 && j > 1)
                {
                    if (map[i][j] == map[i][j-1] || map[i][j] == map[i-1][j]) dp[i][j] = 1;
                    else
                    {
                        if (dp[i][j-1] != dp[i-1][j]) dp[i][j] = min(dp[i][j-1], dp[i-1][j]) + 1;
                        else
                        {
                            int count = dp[i][j-1];
                            if (map[i-count][j-count] == map[i][j]) dp[i][j]  = count + 1;
                            else dp[i][j] = count;
                        }
                    }
                }
                else dp[i][j] = 1;
                if (dp[i][j] > ans) ans = dp[i][j];
            }
        }
        ans *= 4;
        ans = max(ans, work('B', n, m));
        ans = max(ans, work('R', n, m));
        printf("Case #%d: %d\n", tt, ans);
    }
    return 0;
}

1010 MAP 我擦啊，这么简单的题意，说得这么恶心。用 map 和 set 写起来挺爽的，貌似数据都是按顺序的，用不到 map… C++ 还有 istringstream 这么神奇的东西啊。貌似这题数据是\r\n，所以。。如果gets读换行符就会被坑了= =

#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
int main()
{
    int t, n;
    string url;
    map<string, int> querymap;
    set urlset[105];
    int c[105];
    cin >> t;
    for (int tt = t; tt <= t; tt++)
    {
        cin >> n;
        string name;
        string line;
        querymap.clear();
        memset(c, 0, sizeof(c));
        double ans = 0;
        for (int i = 0; i < n; i++)
        {
            cin >> name;
            querymap.insert(pair<string, int>(name, i));
            urlset[i].clear();
            getline(cin, line);
            istringstream iss(line);
            while (iss >> url)
            {
                //cout << url << endl;
                c[i]++;
                urlset[i].insert(url);
            }
        }
        for (int i = 0; i < n; i++)
        {
            cin >> name;
            int index = querymap[name];
            getline(cin, line);
            istringstream iss(line);
            int r = 0;
            int count = 0;
            double sum = 0;
            while (iss >> url)
            {
                ++r;
                if (urlset[index].count(url))
                {
                    ++count;
                    sum += count / (double)r;
                }
            }
            if (c[i]) ans += sum / c[i];
        }
        printf("Case #%d: %.6lf\n", tt, ans / n);
    }
    return 0;
} 

Codeforces 78C Beaver Game

2012-08-06T16:08:12+00:00

http://codeforces.com/problemset/problem/78/C

n块木头，每块长度为m，两人对战（呃，其实是beaver），每人选一块木头并把它分为长度相同的多块，每块长度不得小于k，不能继续分者输。

貌似yds讲过类似的题，第一想法就是如果是偶数块木头，先手输，因为此时后手可以完全复制先手的策略，先手必输。如果有奇数块木头，那么先手应该选一块，把它直接分成不可分割的各小块，这样问题转化成前一种情况（此时先手相当于新情况的后手）。如果不可分割先手直接输，否则胜。

于是从2到sqrt(m)枚举分成多少块即可，注意特殊情况：k=1时一定可分割。

#include 
#include 
#include 
using namespace std;
int main()
{
    int n, m, k;
    bool split = false;
    cin >> n >> m >> k;
    int temp = sqrt(m);
    for (int i = 2; i <= temp; i++) if (m % i == 0 && m / i >= k)
    {
        split = true;
        break;
    }
    if (k == 1 && m > 1) split = true;
    if (split && n % 2) puts("Timur");
    else puts("Marsel");
    return 0;
} 

现在应该去做比赛的…刚才犹豫了一下没去做，于是睡觉去吧= =

ZOJ Monthly, July 2012

2012-08-04T03:53:21+00:00

118 - ZOJ Monthly, July 2012 A Magic Number 找规律

B Battle Ships 敌人生命值为l，我们有n个船，每个船可以造无限个，造船时间为t[i]，攻击力为attack[i]。 dp[i][j]表示攻击敌人i个生命值，当前攻击力为j时的时间最小花费。 dp[i + j * t[k]][j + attack[k]] = min(dp[i + j * t[k]][j + attack[k]], dp[i][j] + t[k]) 比赛时想出来这个挺爽的，不过接下来就没出题目…

#include 
#include 
#include 
#include 
using namespace std;
const int INF = 0x7f7f7f7f;
const int POWERMAX = 330;
int main()
{
    int n, l;
    int dp[350][350];
    int t[50], attack[50];
    while (cin >> n >> l)
    {
       memset(dp, 127, sizeof(dp));
        for (int i = 0; i < n; i++)
        {
            scanf("%d%d", &t;[i], &attack;[i]);
        }
        dp[0][0] = 0;
        int ans = INF;
        for (int i = 0; i < l; i++)
        {
            for (int j = 0; j <= POWERMAX; j++)
            {
                if (dp[i][j] == INF) continue;
                for (int k = 0; k < n; k++)
                {
                    if (j + attack[k] <= POWERMAX)
                    {
                        if (i + j * t[k] < l)
                        dp[i + j * t[k]][j + attack[k]] =  min(dp[i + j *t[k]][j + attack[k]], dp[i][j] + t[k]);
                    }
                    if (j == 0) continue;
                    if (i + j >= l)
                    {
                        ans = min(ans, dp[i][j] + 1);
                    }
                    else
                    {
                        dp[i+j][j] = min(dp[i+j][j], dp[i][j] + 1);
                    }
                }
            }
        }
        cout << ans << endl;
    }
    return 0;
}

E Treasure Hunt I 一棵树，某人从一点出发，在限定的时间内返回，求最大收益。简单的树形DP，这种题目很少写，非常不熟练。dp[node][j]表示刚好用j个单位时间遍历node获得的最大值，具体思路见代码，j要递减，保证dp[node][j-l-map[node][i]*2]表示从node出发，走0到i-1节点后获得的最大值，

#include 
#include 
#include 
using namespace std;
const int MAXN = 105;
const int INF = 0x7f7f7f7f;
int v[MAXN];
int map[MAXN][MAXN];
int dp[MAXN][205];
int n, k, m;
void dfs(int node)
{
    dp[node][0] = v[node];
    for (int i = 1; i <= n; i++)
    {
        if (map[node][i] == INF) continue;
        if (dp[i][0] >= 0) continue;
        dfs(i);
        for (int j = m; j > 0; j--)
        {
            for (int l = 0; l + map[node][i] * 2 <= j; l++)
            dp[node][j] = max(dp[node][j], dp[i][l] + dp[node][j-l-map[node][i]*2]);
        }
    }
}
int main()
{
    while (cin >> n)
    {
        for (int i = 1; i <= n; i++) scanf("%d", &v;[i]);
        int u, v, w;
        memset(map, 127, sizeof(map));
        memset(dp, -1, sizeof(dp));
        for (int i = 1; i < n; i++)
        {
            scanf("%d%d%d", &u;, &v;, &w;);
            map[u][v] = map[v][u] = w;
        }
        cin >> k >> m;
        dfs(k);
        int ans = 0;
        for (int i = 0; i <= m; i++) ans = max(ans, dp[k][i]);
        cout << ans << endl;
    }
    return 0;
}

H Treasure Hunt IV 找规律，刚开始没发现和平方有关，交上去TLE，囧。

#include 
#include 
#include 
using namespace std;
bool work(int x)
{
    int sum = 0;
    for (int i = 1; i <= x; i++) sum += x / i;
    if (sum % 2) return false;
    return true;
}
long long getans(long long x)
{
    long long a = sqrt(x);
    if (a % 2 == 0) return a / 2 * (a - 1) + x - a * a + 1;
    else return (a + 1) / 2 * a;
}
int main()
{
    long long a, b;
    while (cin >> a >> b)
    {
        if (a == 0) cout << getans(b) << endl;
        else cout << getans(b) - getans(a - 1) << endl;
    }
    return 0;
}

J Watashi’s BG 原来BG是请客的意思啊。物品数为30，容量为10000000的背包。原来…搜索就可以过。两个减枝，一是要排序，二是如果后面那些都取还没有当前答案大，那就不用搜索了。

#include 
#include 
#include 
#include 
using namespace std;
int n, m;
int cost[35];
int sum[35];
int ans;
void search(int p, int money)
{
    //cout << p << " " << money << endl;
    if (ans == m) return;
    if (money > ans) ans = money;
    if (p == n) return;
    if (sum[p] + money <= ans) return;
    search(p+1, money);
    if (money + cost[p] <= m) search(p+1, money + cost[p]);
}
int main()
{
    while (cin >> n >> m)
    {
        for (int i = 0; i < n; i++) cin >> cost[i];
        sort(cost, cost + n, greater());
        memset(sum, 0, sizeof(sum));
        for (int i = n - 1; i >= 0; i--)
        {
            sum[i] = sum[i+1] + cost[i];
        }
        ans = 0;
        search(0, 0);
        cout << ans << endl;
    }
    return 0;
} 

另外一个想法，把物品分成两份，各15个，于是两侧各2^15种情况，对于每种情况在另外那边二分找最适合的，需要先排序。曾经把这个二分写错。

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 55;
int a[32768], b[32768];
int cost[MAXN];
int calculate(int *ar, int left, int right)
{
    int end = 2 << (right-left) ;
    for (int i = 1; i < end; i++)
    {
        int count = 0;
        ar[i] = 0;
        for (int j = 1; j <= i; )
        {
            if (i & j) ar[i] += cost[left + count];
            j = j << 1;
            ++count;
        }
    }
    return end;
}

int search(int *ar, int l, int r, int m)
{
    //cout << l << " " << r << " " << m << endl;
    int left = l;
    int right = r;
    while (left < right)
    {
        int mid = (left + right) / 2;
        if (ar[mid] <= m && ar[mid+1] > m) return ar[mid];
        if (ar[mid] <= m)
        {
            left = mid + 1;
        }
        else
        {
            right = mid - 1;
        }
    }
    return ar[left];
}
int main()
{
    int n, m;
    while (cin >> n >> m)
    {
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &cost;[i]);
        }
        memset(a, 127, sizeof(a));
        memset(b, 127, sizeof(b));
        a[0] = b[0] = 0;
        if (n <= 15)
        {
            int end = calculate(a, 1, n);
            sort(a + 1, a + end);
            cout << search(a, 0, end - 1, m) << endl;
        }
        else
        {
            int aend = calculate(a, 1, 15);
            int bend = calculate(b, 16, n);
            sort(b + 1, b + bend);
            int ans = 0;
            for (int i = 0; i < aend; i++)
            {
                if (a[i] > m) continue;
                ans = max(ans, search(b, 0, bend -1, m - a[i]) + a[i]);
            }
            cout << ans << endl;
        }
    }
    return 0;
}

也可以两边都排序，然后扫一遍就行，这种会更好写。

K Watermelon Full of Water 买西瓜的时候一定选西瓜延续到当天并且花费最少的策略。（西瓜放这么多天不会坏吗…）贪心、堆。用一个结构体wm存延续到哪一天last，和总花费cost，根据cost构造最小堆。堆初始化为0 0，如果延续不到“今天”就pop，然后根据堆顶元素创建新的wm，再push进去就好了。xenocide 写的代码好短。。好强大。

#include 
#include 
#include 
using namespace std;
const int MAXN = 50010;
struct wm
{
    int last;
    long long cost;
};

bool operator < (const wm &a;, const wm &b;)
{
    return a.cost > b.cost;
}

int main()
{
    int n;
    int last[MAXN]; // last[i] 表示第 i 天必须买瓜（从0开始）
    long long price[MAXN];
    priority_queue q;
    while (cin >> n)
    {
        for (int i = 0; i < n; i++) cin >> price[i];
        for (int i = 0; i < n; i++) scanf("%d", &last;[i]);
        while (!q.empty()) q.pop();
        wm temp;
        temp.cost = temp.last = 0;
        q.push(temp);
        for (int i = 0; i < n; i++)
        {
            while (q.top().last < i) q.pop();
            temp = q.top();
            temp.cost += price[i];
            temp.last = i + last[i];
            q.push(temp);
        }
        while (q.top().last < n) q.pop();
        cout << q.top().cost << endl;
    }
    return 0;
}

To do: 最后一题的线段树解法是什么意思 F题应该可以做，估计会很麻烦 C题xw给我讲了比较神奇的思路，应该也可做