第一天到了之后，发现宾馆不错。看上去挺高档的，有网线是最重要的！不知怎么搞就轻松搞定了Wifi共享，房间里两个人同时上。Windows易用性还是不错的，就是重启之后怎么都用不了让我十分郁闷。于是每次的换一个网络名(SSID)重建。

第二天，衡牛的课，上午讲简单图论，下午讲动态规划。中午一帮人出去玩，吃KFC，逛商场，因为极热还买了条衣服……晚上在宾馆看电影……

第三天，在老师的吩咐下，早上睡到了9点多，左手手臂超痛，大概是背那电脑背的（出去玩的时候都背着）。然后出去吃东西，回来，下午高一小朋友们也不去听课了，所以再出去玩。记得那边有一个“19号”，应该是个喝饮料的地方，里面的设计很有风格，3层楼的木制结构房屋，很有复古的感觉。苗苗同学还拍了很多照片，有空我会传到相册里。

最后一天，考试。5个小时4道题目。30分钟搞定第二题，接下来没搞定一题。最后第一天骗分还让过了9个点，剩下的那个是因为不小心删除了样例的特判。这骗分为什么就是正确算法？不知道……第三题，写个裸搜估计只能过1个点，所以还是放弃了。第四题，裸搜，输0骗分，拿了30……总分220，全场大概10+吧。这次考试基本没什么区分度，所以还是看Day2了。

省选搞完了，生活发生大转变了。社团什么的让高一去搞，机器人什么的顶多快比赛的时候抽一天玩，要学习学习再学习。不过有机会的话这里还是要更新的。

加油，对自己，对同学，对对手。

NOIP2007结束后，好多人劝我赶快退役，转向其他竞赛或者把文化课弄好，专心攻保送。可是终究没这样选择，不仅是因为这样做会让我觉得愧对舒老师给我的加入竞赛班的机会，也有一种对OI的喜爱在内。这么长时间过去了，而面对AC的那种喜悦，仍像当初一样，丝毫没有减弱。大概这就是OI相对于其他学科竞赛的魅力所在吧，至少我这么认为。

If you are not the shark , you are the food.弱肉强食，这大自然的规律，同时也体现在竞赛的残酷性上。一行代码定生死，机器是公正的，它只知道执行代码，它没有感情。重视主要矛盾的时候也不能忽视次要矛盾，一个小小的疏忽就能带来爆0的悲剧。再一次，像NOIP2007前那样，用这句话来提醒自己，绝对不能有小的疏忽。写错了比写不出来更痛苦啊。

还有就是要冷静，无论在赛前、赛时、赛后，绝对不能浮躁。赛前的浮躁影响状态，赛时的紧张影响发挥，赛后的冲动影响心态。所以，冷静。多读读题目，多想想算法，多测测数据……

基本上就是这样吧，以上的一切与所有的朋友和对手共勉。

God bless me , and may god bless all OIer.

第一题，我想出了搜索打表的方法，由于某些因素的影响，没写完我就走了。

第二题，状态DP能得部分分，正确方法是网络流。相邻格子黑白染色，源到黑格子连一条容量为这个格子权值的边，黑格子向相邻的白格子连一条无穷大的边，白格子向汇连一条容量为它的权值的边。最后答案是总权值-最小割。

第三题，提交答案式，随机随便搞吧。

集训结束了，这种没意义的题解也不会继续了。新日子要到来啦！

第一题，看上去是在讲编码，画了下就成石子归并模型了。四边形不等式优化。注意1的特判。

第二题，离散化+线段树。朴素40分。

第三题，用不同方法过不同数据。小数据30分，特殊图30分，剩下就是大数据了。我看出了特殊图是求桥可惜写错了。英勇爆0。

今天也是汤牛和xc牛选的套题。第一题给出平面上一些线段（平行于坐标轴），求围成的正方形个数。第二题给出两个串，求第二个串是否能分解为一系列的第一个串的前缀。第三题为提交答案式，求5*m的棋盘用3个格子组成的-、|、以及L字形及其旋转所产生图形的覆盖数。

第一题，朴素40分。正解是每次处理一条对角线，需要树状数组。

第二题，朴素40分。正解是KMP。

第三题，裸搜20分（我怎么只有10分），状态压缩DP60分（我为什么一开始就写矩阵然后还编译不通过(2^10 * 2^10 的矩阵啊)）。

最近天天考不好，今天早点睡。Bless TOMORROW。

第一题，一个图上求最短路，需要拆点。然后加个最优化剪枝就可以了。无奈的是我在剪枝的时候不慎将指向边的i当做指向点的，结果就造成了大紊乱，成功地失去了100分的70%。

第二题，动态规划，需要优化，据说有单调性。我把阶段分错了，有后效性，结果朴素的30分只拿到10分。

第三题，线段树。先用一些不存在的点把线段树建好，如果有点进来就用它来代替虚假点。好像被我写慢了，不过还好重测一次就过了。

在不可抗拒因素的影响下，今天的日记只能这么粗略带过。不过我声明，所有我个人的作品，不涉及版权或保密等问题的（包括但不限于），一定会基于自由协议发布。

汉诺塔 Hanoi
【问题描述】
汉诺塔由三根柱子（分别用A、B、C表示）和n个大小互不相同的空心盘子组成。一开始n个盘子都摞在柱子A上，大的在下面，小的在上面，形成了一个塔状的锥形体。
对汉诺塔的一次合法的操作是指：从一根柱子的最上层拿一个盘子放到另一根柱子的最上层，同时要保证被移动的盘子一定放在比它更大的盘子上面（如果移动到空柱子上就不需要满足这个要求）。我们可以用两个字母来描述一次操作：第一个字母代表起始柱子，第二个字母代表目标柱子。例如，AB就是把柱子A最上面的那个盘子移到柱子B。汉诺塔的游戏目标是将所有的盘子从柱子A移动到柱子B或柱子C上面。
有一种非常简洁而经典的策略可以帮助我们完成这个游戏。首先，在任何操作执行之前，我们以任意的次序为六种操作（AB、AC、BA、BC、CA和CB）赋予不同的优先级，然后，我们总是选择符合以下两个条件的操作来移动盘子，直到所有的盘子都从柱子A移动到另一根柱子：
（1）这种操作是所有合法操作中优先级最高的；
（2）这种操作所要移动的盘子不是上一次操作所移动的那个盘子。
可以证明，上述策略一定能完成汉诺塔游戏。现在你的任务就是假设给定了每种操作的优先级，计算按照上述策略操作汉诺塔移动所需要的步骤数。
【输入格式】
输入有两行。第一行为一个整数n（1≤n≤30），代表盘子的个数。第二行是一串大写的ABC字符，代表六种操作的优先级，靠前的操作具有较高的优先级。每种操作都由一个空格隔开。
【输出格式】
只需输出一个数，这个数表示移动的次数。我们保证答案不会超过10的18次方。
【样例】
3
AB BC CA BA CB AC
输出 7
2
AB BA CA BC CB AC
输出 5
【数据规模】
对于20%的数据，n ≤ 10。
对于100%的数据，n ≤ 30。

安全的航线 Flight
【问题描述】
在设计航线的时候，安全是一个很重要的问题。首先，最重要的是应采取一切措施确保飞行不会发生任何事故，但同时也需要做好最坏的打算，一旦事故发生，就要确保乘客有尽量高的生还几率。
当飞机迫降到海上的时候，最近的陆地就是一个关键的因素。航线中最危险的地方就是距离最近的陆地最远的地方，我们称这种点为这条航线“孤地点”。孤地点到最近陆地的距离被称为“孤地距离”。作为航空公司的高级顾问，你接受的第一个任务就是尽量找出一条航线的孤地点，并计算这条航线的孤地距离。
为了简化问题，我们认为地图是一个二维平面，陆地可以用多边形近似，飞行线路为一条折线。航线的起点和终点都在陆地上，但中间的转折点是可能在海上（如下图所示，方格标示出了孤地点）。
【输入格式】
输入的第一行包括两个整数C和N（1≤C≤20，2≤N≤20），分别代表陆地的数目的航线的转折点的数目。
接下来有N行，每行有两个整数x,y。(x,y)表示一个航线转折点的坐标，第一个转折点为航线的起点，最后一个转折点为航线的终点。
接下来的输入将用来描述C块大陆。每块输入由一个正整数M开始（M≤30），M表示多边形的顶点个数，接下来的M行，每行会包含两个整数x,y，(x,y)表示多边形的一个顶点坐标，我们保证这些顶点以顺时针或逆时针给出了该多边形的闭包，不会出现某些边相交的情况。此外我们也保证输入数据中任何两块大陆不会相交。
输入的所有坐标将保证在-10,000到10,000的范围之间。
【输出格式】
输出一个浮点数，表示航线的孤地距离，数据保留2位小数。
【样例】
1 2
-9 -6
5 1
3
0 16
-16 -12
17 -6
输出 0.00
2 3
12 4
16 17
3 9
4
1 0
4 19
19 14
6 12
3
10 10
5 3
18 2
输出 2.94
【数据规模】
对于50%的数据，1≤C≤2，2≤N≤5;
对于100%的数据，1≤C≤20，2≤N≤20。

堵塞的交通 Traffic
【问题描述】
有一天，由于某种穿越现象作用，你来到了传说中的小人国。小人国的布局非常奇特，整个国家的交通系统可以被看成是一个2行C列的矩形网格，网格上的每个点代表一个城市，相邻的城市之间有一条道路，所以总共有2C个城市和3C-2条道路。
小人国的交通状况非常槽糕。有的时候由于交通堵塞，两座城市之间的道路会变得不连通，直到拥堵解决，道路才会恢复畅通。初来咋到的你决心毛遂自荐到交通部某份差事，部长听说你来自一个科技高度发达的世界，喜出望外地要求你编写一个查询应答系统，以挽救已经病入膏肓的小人国交通系统。
小人国的交通部将提供一些交通信息给你，你的任务是根据当前的交通情况回答查询的问题。交通信息可以分为以下几种格式：
Close r1 c1 r2 c2：相邻的两座城市(r1,c1)和(r2,c2)之间的道路被堵塞了；
Open r1 c1 r2 c2：相邻的两座城市(r1,c1)和(r2,c2)之间的道路被疏通了；
Ask r1 c1 r2 c2：询问城市(r1,c1)和(r2,c2)是否连通。如果存在一条路径使得这两条城市连通，则返回Y，否则返回N；
【输入格式】
第一行只有一个整数C，表示网格的列数。接下来若干行，每行为一条交通信息，以单独的一行“Exit”作为结束。我们假设在一开始所有的道路都是堵塞的。
【输出格式】
对于每个查询，输出一个“Y”或“N”。
【样例】
2
Open 1 1 1 2
Open 1 2 2 2
Ask 1 1 2 2
Ask 2 1 2 2
Exit
输出Y
N
3
Open 1 1 1 2
Ask 1 1 1 2
Close 1 1 1 2
Ask 1 1 1 2
Exit
输出
Y
N
【数据规模】
对于30%的数据，C≤1,000，信息条数≤1,000；
对于100%的数据，C≤100,000，信息条数≤100,000。

接下来仍是简单的仅用来备忘的日记式题解。

汉诺塔：我们班有人用递推做出来了，而我是找规律的。搜了一批发现，答案有2^n、2*3^(n-1)-1以及3^(n-1)，总共3种情况。（在n=3时，对应的优先序列分别可以是{AB AC BC BA CA CB}、{AB AC BA CB CA BC}和{AB AC BC BA CB CA}。）第一和第三种比较容易看出来，第二种我是借助Excel乱试才发现的。知道了这样以后，把输入序列拿过来，另n=3，看答案是7、9或者17，再分别套上面的公式去做。这题找规律找得我很得意，为后面的悲惨埋下了伏笔……

安全的航线：计算几何。我不会，听汤牛讲解的时候是说二分答案，把顶点扩充成圆、边扩充成矩形，然后判断所有航线段是不是都在这个图形内。计算几何很麻烦，有人整个早上在做这题……

堵塞的交通：生死一行代码。我能再考场上想出正确算法却时间不够，有个小东西写反了，错了，结果人家朴素还比我多20分！我写麻烦了，其中有个东西，我连续复制了16次！总代码有200多行！其实能写得更漂亮，只是考场上搞不定。做法是用线段树维护。每个线段维护它的左上能不能到右上、右下，同理左下能不能。如果用U来表示上、D来表示下，就是需要维护UU、UD、DU、DD共4种状态。遇到询问的时候，我们可以直接看如果只有这一段，原点到目标点能不能联通。刚写完了这个，还有1个多小时，我洋洋得意，以为200有希望了（第二题放弃）。突然发现，比如说左上是原点，左上不能直接到左下，却可以在左边绕一大圈到左下，然后左下可以到目标点这种情况。想了半个小时没想出来。后来想到，如果是这样，左上一定在左边的某一个竖着联通的地方与左下联通了，那么只要找出最近的竖着的就好了！用树状数组求和来维护竖着的有几个，然后二分去找最近的竖着的，判断左上左下能不能同时到那个竖着的，可以的话判断左下到目标点能不能联通，都满足那么就输出Y。当然还有右边这样的情况、以及左边右边都这样绕的情况。这些我都考虑好了，自己造出了一个样例，就是左右都要绕的情况，发现不对！此时已经没有时间了！我匆匆调，两三分钟内都没发现问题，老师在催交卷，只好交了。30分（我很不厚道地说句，数据不厚道，说小数据只有3个的朴素能过5个！）后来结束后检查发现，找到那个竖着的东西，再去判那种相交情况的时候，没有考虑左右！因为我的程序里左右是分明的，原先读入的时候有判断，以为子程序会自己处理这样的情况，可事实是没有！改了后80，再检查，发现，后来改的时候打反了一个字母，再改，100！我相信如果考场上我能再多5分钟，就能发现这个弱智的错误，足够细心不引入新的那个错误，这样就能满分了，更是在别人都没有想出正确算法的情况下！生死一行代码，一个小小的疏忽能带来0分的后果，在NOIP2007前我就用这句话来提醒自己，而现在，这个警钟又被敲响！大家不要BS我那写烂掉的程序，中间有2大段30多行能用1行代替的，总大小9K少一点。不过到底还是离AC很近了。我很高兴编译的时候这200多行的程序只有一个常量忘了定义，语言强熟悉程度加强了:)

循环的债务 Debt
【问题描述】
Alice、Bob和Cynthia总是为他们之间混乱的债务而烦恼，终于有一天，他们决定坐下来一起解决这个问题。不过，鉴别钞票的真伪是一件很麻烦的事情，于是他们决定要在清还债务的时候尽可能少的交换现金。
比如说，Alice欠Bob 10元，而Cynthia和他俩互不相欠。现在假设Alice只有一张50元，Bob有3张10元和10张1元，Cynthia有3张20元。一种比较直接的做法是：Alice将50元交给Bob，而Bob将他身上的钱找给Alice，这样一共就会有14张钞票被交换。但这不是最好的做法，最好的做法是：Alice把50块给Cynthia，Cynthia再把两张20给Alice，另一张20给Bob，而Bob把一张10块给C，此时只有5张钞票被交换过。
没过多久他们就发现这是一个很棘手的问题，于是他们找到了精通数学的你为他们解决这个难题。
【输入文件】
输入的第一行包括三个整数：x1、x2、x3（-1,000≤x1，x2，x3≤1,000），其中
x1代表Alice欠Bob的钱（如果x1是负数，说明Bob欠了Alice的钱）
x2代表Bob欠Cynthia的钱（如果x2是负数，说明Cynthia欠了Bob的钱）
x3代表Cynthia欠Alice的钱（如果x3是负数，说明Alice欠了Cynthia的钱）
接下来有三行，每行包括6个自然数：
a100，a50，a20，a10，a5，a1
b100，b50，b20，b10，b5，b1
c100，c50，c20，c10，c5，c1
a100表示Alice拥有的100元钞票张数，b50表示Bob拥有的50元钞票张数，以此类推。另外，我们保证有a10+a5+a1≤30，b10+b5+b1≤30，c10+c5+c1≤30，而且三人总共拥有的钞票面值总额不会超过1,000。
【输出文件】
如果债务可以还清，则输出需要交换钞票的最少张数；如果不能还清，则输出“impossible”（注意单词全部小写，输出到文件时不要加引号）。
【样例】
10 0 0
0 1 0 0 0 0
0 0 0 3 0 10
0 0 3 0 0 0
输出 5
-10 -10 -10
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
输出 0
【数据规模】
对于30%的数据，x1、x2、x3 ≤ |50|。
对于100%的数据，x1、x2、x3 ≤ |1,000|。

小约翰的游戏 John
【问题描述】
小约翰经常和他的哥哥玩一个非常有趣的游戏：桌子上有n堆石子，小约翰和他的哥哥轮流取石子，每个人取的时候，可以随意选择一堆石子，在这堆石子中取走任意多的石子，但不能一粒石子也不取，我们规定取到最后一粒石子的人算输。
小约翰相当固执，他坚持认为先取的人有很大的优势，所以他总是先取石子，而他的哥哥就聪明多了，他从来没有在游戏中犯过错误。小约翰一怒之前请你来做他的参谋。自然，你应该先写一个程序，预测一下谁将获得游戏的胜利。
【输入文件】
本题的输入由多组数据组成，第一行包括一个整数T，表示输入总共有T组数据（T≤500）。
每组数据的第一行包括一个整数N（N≤50），表示共有N堆石子，接下来有N个不超过5000的整数，分别表示每堆石子的数目。
【输出文件】
每组数据的输出占一行，每行输出一个单词。如果约翰能赢得比赛，则输出“John”，否则输出“Brother”，请注意单词的大小写。
【样例】
2
3
3 5 1
1
1
输出
John
Brother
【数据规模】
对于40%的数据，T ≤ 250。
对于100%的数据，T ≤ 500。

仙人图(II) Cactus
【问题描述】
如果某个无向连通图的任意一条边至多只出现在一条简单回路（simple cycle）里，我们就称这张图为仙人图（cactus）。所谓简单回路就是指在图上不重复经过任何一个顶点的回路。
举例来说，上面的第一个例子是一张仙人图，而第二个不是——注意到它有三条简单回路：（4，3，2，1，6，5，4）、（7，8，9，10，2，3，7）以及（4，3，7，8，9，10，2，1，6，5，4），而（2，3）同时出现在前两个的简单回路里。另外，第三张图也不是仙人图，因为它并不是连通图。
显然，仙人图上的每条边，或者是这张仙人图的桥（bridge），或者在且仅在一个简单回路里，两者必居其一。定义在图上两点之间的距离为这两点之间最短路径的距离。定义一个图的直径为这张图相距最远的两个点的距离。现在我们假定仙人图的每条边的权值都是1，你的任务是求出给定的仙人图的直径。
【输入文件】
输入的第一行包括两个整数n和m（1≤n≤50,000以及0≤m≤10,000）。其中n代表顶点个数，我们约定图中的顶点将从1到n编号。
接下来一共有m行。代表m条路径。每行的开始有一个整数k（2≤k≤1000），代表在这条路径上的顶点个数。接下来是k个1到n之间的整数，分别对应了一个顶点，相邻的顶点表示存在一条连接这两个顶点的边。一条路径上可能通过一个顶点好几次，比如对于第一个样例，第一条路径从3经过8，又从8返回到了3，但是我们保证所有的边都会出现在某条路径上，而且不会重复出现在两条路径上，或者在一条路径上出现两次。
【输出文件】
只需输出一个数，这个数表示仙人图的直径长度。
【样例】
15 3
9 1 2 3 4 5 6 7 8 3
7 2 9 10 11 12 13 10
5 2 14 9 15 10
输出 8
10 1
10 1 2 3 4 5 6 7 8 9 10
输出 9
对第一个样例的说明：
如图，6号点和12号点的最短路径长度为8，所以这张图的直径为8。
使用Pascal语言的选手请注意：
你的程序在处理大数据的时候可能会出现栈溢出。如果需要调整栈空间的大小，可以在程序的开头填加一句：{$M 5,000,000}，其中5,000,000即指代栈空间的大小，请根据自己的程序选择适当的数值。
【数据规模】
对于30%的数据，m ≤ 50。
对于100%的数据，m ≤ 1,000。

今天的题目有点难，我还没有全部写过。下面的题解仅用来备忘，希望大牛能提供更好的题解。

循环的债务：听同学说是一个动态规划，用f[i][j]表示Alice有现金i，Bob有现金j需要的代价，然后转移，也有人用BFS过了。我只过了两个点:(

小约翰的游戏：Nim游戏的改编。我当时是画出了[3,3]为起始状态的有向图，根据ICG的定义，手算答案。与经典的Nim游戏答案比较发现，只有在所有状态都为0或1的时候出现不一向。大胆猜测，特判这种情况，居然AC了！后来有同学证明了这是正确的算法。

仙人图(II)：我写的只是裸的枚举根BFS，居然只有10分！数据不厚道，一个小一点的点都没有！这题应该是一个树形动归或者类似的题目，下午大家讨论了大半天，好像是DFS下来，根据是不是环的起点什么的采取不同的操作。求强连通分支然后缩点应该也是可以的吧，只是还是很麻烦？听说太复杂了，我也就顿时失去了写的欲望。另外，这题是欧洲某ACM比赛的原题。

题目和相关数据在这里。

中位数 median

给出1~n的一个排列，统计该排列有多少个长度为奇数的连续子序列的中位数是b。中位数是指把所有元素从小到大排列后，位于中间的数。
【输入】第一行为两个正整数n和b ，第二行为1~n 的排列。
【输出】输出一个整数，即中位数为b的连续子序列个数。
【样例】输入 输出
5 4
1 2 3 4 5 2
6 3
1 2 4 5 6 3 1
7 4
5 7 2 4 3 1 6 4
第三个样例解释：{4}, {7,2,4}, {5,7,2,4,3}和{5,7,2,4,3,1,6}。
【数据规模】
编号 1 2 3 4 5 6 7 8 9 10
N 10 50 100 300 1000 3600 10000 25000 55555 100000

叶子的颜色color

给一棵m个结点的无根树，你可以选择一个度数大于1的结点作为根，然后给一些结点（根、内部结点和叶子均可）着以黑色或白色。你的着色方案应该保证根结点到每个叶子的简单路径上都至少包含一个有色结点（哪怕是这个叶子本身）。
对于每个叶结点u，定义c[u]为从根结点到u的简单路径上第一个最后一个有色结点的颜色。给出每个c[u]的值，设计着色方案，使得着色结点的个数尽量少。
【输入】第一行包含两个正整数m, n，其中n是叶子的个数，m是结点总数。结点编号为1，2，…，m，其中编号1，2，… ，n是叶子。以下n行每行一个0或1的整数（0表示黑色，1表示白色），依次为c[1]，c[2]，…，c[n]。以下m-1行每行两个整数a，b（1<=a < b <= m），表示结点a和b 有边相连。
【输出】仅一个数，即着色结点数的最小值。
【样例】
输入
5 3
0
1
0
1 4
2 5
4 5
3 5
输出
2
【数据规模】
数据 1 2 3 4 5 6 7 8 9 10
m 10 50 100 200 400 1000 4000 8000 10000 10000
n 5 23 50 98 197 498 2044 4004 5021 4996

跳舞dance

一次舞会有n个男孩和n个女孩。每首曲子开始时，所有男孩和女孩恰好配成n对跳交谊舞。每个男孩都不会和同一个女孩跳两首（或更多）舞曲。
有一些男孩女孩相互喜欢，而其他相互不喜欢（不会“单向喜欢”）。每个男孩最多只愿意和k个不喜欢的女孩跳舞，而每个女孩也最多只愿意和k个不喜欢的男孩跳舞。
给出每对男孩女孩是否相互喜欢的信息，舞会最多能有几首舞曲？
【输入】第一行包含两个整数n和k。以下n行每行包含n个字符，其中第i行第j个字符为’Y'当且仅当男孩i和女孩j相互喜欢。
【输出】仅一个数，即舞曲数目的最大值。
【样例】
3 0
YYY
YYY
YYY
输出 3
3 0
YYY
YYN
YNY
输出 2
2 0
YN
YN
输出 0
2 1
YN
YN
输出 1
【数据规模】
数据 1 2 3 4 5 6 7 8 9 10
n 1 3 5 8 10 40 40 50 50 50
k 1 2 2 1 4 0 14 10 20 30

循环赛match

n支队伍打比赛，每两支队伍恰好比赛一场。平局时各得1分，而有胜负时胜者3分，负者0分。
假设三支队伍得分分别为3, 3, 3，则可能有两种情况：
队伍 A B C 得分
A - 3 0 3
B 0 - 3 3
C 3 0 - 3
队伍 A B C 得分
A - 0 3 3
B 3 - 0 3
C 0 3 - 3

给出n支队伍的最终得分（即所有比赛均已结束），统计有多少种可能的分数表。
【输入】第一行包含一个正整数n，队伍的个数。第二行包含n个非负整数，即每支队伍的得分。
【输出】输出仅一行，即可能的分数表数目。保证至少存在一个可能的分数表。【样例】
3
3 3 3
输出 2
2
0 3
输出 1
3
4 1 2
输出 1
6
5 6 7 7 8 8
输出 121
【数据规模】
数据 1 2~3 4~6 7~12 13~19 20~25
n 3 4 5 6 7 8

我来写个简单的题解，用来备忘。

中位数：记录下从1到i的，比给定数大的数字的个数big[i]，比给定数小的数字的个数small[i]。我们即要求这样的i、j组数，即big[ j ] – big[ i - 1] == small[ j ] – small[ i - 1 ]，同时i小于等于给定数所在的位置，j大于等于给定数所在的位置。上式变形得big[ j ] – small[ j ] == big[ i - 1 ] – small[ i - 1 ]。令t[ i ] = big[ i ] – small[ i ]，枚举i作为目标序列的结尾（一定要在给定数的后面），那么所有在给定数之前出现的t[ k ]的个数就是以i为结尾的符合题意的序列数。

叶子的颜色：注意题目有修改！（看上面。）树形动归。先枚举一个根，对每个点有3个状态：黑、白、无色，表示当前节点在这个状态下要满足题意需要的代价。每个叶子节点涂对应颜色的代价为1，其余为无穷大。一个节点，例如涂黑色，那么代价就是每个min(儿子涂黑色-1,儿子涂白色,儿子不涂)的和加1。如果不涂色，就是每个min(儿子涂黑色,儿子涂白色,儿子不涂)的和。到最后只要用枚举根的三个值里的最小值去更新全局答案就可以了。O(n^2)的算法会超时。实践发现任选节点作为根的答案是一样的。当然也可以进行优化，能够在枚举根的情况下优化到O(n)级别。我没有具体实践过，留给读者思考。

跳舞：二分答案，网络流。构图：讲每个男男女女都拆成两个点，喜欢和不喜欢。从源向男喜欢连一条容量为枚举答案的边，男喜欢向男不喜欢连一条容量为k的边，女不喜欢向女喜欢连一条容量为k的边，女喜欢向汇连一条为枚举答案的边。对于相互喜欢的男女，从男喜欢到女喜欢连一条为1的边，相互不喜欢的男女，从男不喜欢到女不喜欢连一条为1的边。如果最大流为枚举的n倍，那么这个答案是可行的，否则不可行。

循环赛：可以用最小表示来压缩状态，但是我不会写。如果写搜索的话，超时3个点（共25个点）。先从小到大排序，然后枚举每支队伍与其他队伍的比赛结果。一个可行性剪枝，如果当前队伍枚举完要枚举下一支的时候，如果当前队伍的分数不等于要求的分数的话，剪枝。

我总共344分，我们班有388分的大牛，只在最后一题超时3点！我的结果：第一题AC，第二题超时3个点，第三题骗分90分（今天RP暴涨了？我写了个匈牙利算法，先对相互喜欢的人做，如果有完备匹配，那么把那些匹配边删掉，再做下一次。然后把不喜欢的边加上，至多做k次。当然小数据是要搜索的！删边是绝对不行的，但是为什么能对这么多呢？），最后题搜索超4个点。

就这样，第一天过去了。

题目和数据都可以在我的网络硬盘里找到，您可以点这里直接进入本文相关的目录。

Treap=Tree+Heap。Treap本身是一棵二叉搜索树，它的左子树和右子树也分别是一个Treap，和一般的二叉搜索树不同的是，Treap纪录一个额外的数据，就是优先级。Treap在以关键码构成二叉搜索树的同时，还满足堆的性质(在这里我们假设节点的优先级大于该节点的孩子的优先级)。

如果您是一个初学者，在读下面的文字的时候，请同时参阅NOCOW上的Treap介绍。

简单的说，Treap通过给予每个节点一个附加的随机优先级，在保证Treap数据域的排序二叉树性质的前提下，使节点的优先级同时满足堆的性质。经过种种的分析证明，在一般情况下这样做可以让Treap维持平衡。

和大多数平衡树一样，Treap的操作用到了旋转。从图（参见NOCOW上的Treap介绍）上看出，右旋即将该节点的左子节点提升到根，左旋则相反。你可以用这样的方法来记住。

插入方法：如果当前节点为空，则新建节点，加入数据，设置特征值。否则若插入数小于当前节点，插入其左子树；如果不是，就插入右子树。插入后，要根据情况旋转，来保证堆的性质。

删除方法：这是比其他平衡树树好写得多的操作。首先找到要删除的节点。如果它没有子节点，则将自己删除。若只有一个子树，那么用这个子树来代替自己。如果有两个子树，那么选择优先级比较大的，将其转到根，然后才删除要删的节点所在的子树。举例来说，如果要删除当前节点，它有两个子树，其中左子树优先级比较大，那么右旋，递归地删除其右子树。

查找：和普通的排序二叉树一样。

分离合并等，都是通过虚拟节点来实现的。由于我没有实践过，所以不敢乱讲。

NOI2004的郁闷的出纳员和2006年的生日快乐是练习平衡树的很好的题目。当然如果您才刚入门，不妨用它来写一个排序，来检验其正确性。

看到有人求代码，我来贴一个吧。很丑很长，不过还算比较好写。

 
#include <iostream>
#include <cassert>
 
using namespace std;
 
struct Treap
{
    Treap *lSon , *rSon;
    int key;
    unsigned rank;
};
 
void leftRoutate( Treap*& cur )
{
    assert( cur -> rSon );
    Treap* t = cur -> rSon;
    cur -> rSon = t -> lSon;
    t -> lSon = cur;
    cur = t;
}
 
void rightRoutate( Treap*& cur )
{
    assert( cur -> lSon );
    Treap* t = cur -> lSon;
    cur -> lSon = t -> rSon;
    t -> rSon = cur;
    cur = t;
}
 
void ins( Treap*& cur , int key )
{
    if ( cur == NULL ) {
        cur = new Treap;
        cur -> lSon = cur -> rSon = NULL;
        cur -> key = key;
        cur -> rank = rand();
    } else {
        if ( key <= cur -> key ) {
            ins( cur -> lSon , key );
            if ( cur -> lSon -> rank > cur -> rank ) {
                rightRoutate( cur );
            }
        } else {
            ins( cur -> rSon , key );
            if ( cur -> rSon -> rank > cur -> rank ) {
                leftRoutate( cur );
            }
        }
        // 维护附加域
    }
}
 
bool findKey( Treap*& cur , int key )
{
    if ( cur == NULL ) {
        return false;
    } else {
        if ( key == cur -> key ) return true;
        if ( key < cur -> key ) {
            return findKey( cur -> lSon , key );
        } else {
            return findKey( cur -> rSon , key );
        }
    }
}
 
void del( Treap*& cur , int key )
{
    if ( cur == NULL ) return;
    if ( key < cur -> key ) {
        del( cur -> lSon , key );
        return;
    }
    if ( key > cur -> key ) {
        del( cur -> rSon , key );
        return;
    }
    if ( cur -> lSon == NULL && cur -> rSon == NULL ) {
        delete cur;
        cur = NULL;
        return;
    }
    if ( cur -> lSon == NULL && cur -> rSon != NULL ) {
        Treap* t = cur;
        cur = cur -> rSon;
        delete t;
        return;
    }
    if ( cur -> lSon != NULL && cur -> rSon == NULL ) {
        Treap* t = cur;
        cur = cur -> lSon;
        delete t;
        return;
    }
    if ( cur -> lSon != NULL && cur -> rSon != NULL ) {
        if ( cur -> lSon -> rank > cur -> rSon -> rank ) {
            rightRoutate( cur );
            del( cur -> rSon , key );
        } else {
            leftRoutate( cur );
            del( cur -> lSon , key );
        }
        return;
    }
}
 
void midWalk( Treap* cur )
{
    if ( cur ) {
        midWalk( cur -> lSon );
        cout << cur -> key << " ";
        midWalk( cur -> rSon );
    }
}
 
int minimum( Treap* cur )
{
    while( cur -> lSon ) cur = cur -> lSon;
    return cur -> key;
}
 
int maximun( Treap* cur )
{
    while( cur -> rSon ) cur = cur -> rSon;
    return cur -> key;
}
 
Treap* root;
 
int main()
{
    int opt;
    cout << "1.Insert\n2.midWalk\n3.Delete\n4.Find\n5.getMin\n6.getMax\n0.Exit\n" << endl;
    cin >> opt;
    while ( opt != 0 ) {
        if ( opt == 1 ) {
            int t;
            cin >> t;
            ins( root , t );
        }
        if ( opt == 2 ) {
            midWalk( root );
            cout << endl;
        }
        if ( opt == 3 ) {
            int t;
            cin >> t;
            del( root , t );
        }
        if ( opt == 4 ) {
            int x;
            cin >> x;
            cout << ( findKey( root , x ) ? "Yes" : "No" ) << endl;
        }
        if ( opt == 5 ) {
            cout << minimum( root ) << endl;
        }
        if ( opt == 6 ) {
            cout << maximun( root ) << endl;
        }
        cin >> opt;
    }
}