题目给出一个串n<=1000 串只会出现a,b,c三种字符
 abc或bca可切成一块
 设最后切出m0个abc , m1个bca，则答案为min{m0,m1}
 求试答案最大

 dp[i,j]表示前面i个字符切出了j个abc，能获得的最多dp[i,j]个bca

 转移是看最后这个三个字母是什么
 dp[i-3,j-1]    “abc”
 dp[i-3,j]+1   "bca"
 dp[i-1,j]

 注意dp[i,j]  3*j<=i  ， 对于不存在的值不能引用，否则会出错！！

 貌似这种有两个要求值的，都是设成一个已知
 如这里前i个，有j个abc
 
*/

zoj 3449

/*

一个数字a（最多100000位），本来a = ∑ai*10^i，不断变为a' = ∑ai*x^i (x=1,2...9) 。

直至a‘<10 ，求此时的a'

比较变化前后的结果，发现变化后减少了∑ai(10^i-b^i)

一开始我就用Java大整数去逼近（减去10^i-b^i），使得结果趋近于10且小于10

超时了

看了watashi的，∑ai*10^i = ∑ai*x^i  (mod 10-x)

“于是我们知道对10-b求模是关于这种运算的不变量，可以发现答案就是b+(n-10)%(10-b)”

其实我之前的那个不断逼近，其实就是 mod 10 - x 而已，脑残了！！！

因为(a^n - b^n) % (a-b) = 0

可以几位合在再mod会快点

最后结果要不断加上10-x，使得逼近于10

*/

zoj 3450

/*

一个定点p0，n个目标点 ，每个目标点有敌人wi,要消灭该点需要ti时间

弱目标点在同一直线，必须先消灭近的才能消灭远的

问在T时间内最多能消除的敌人

分组背包

注意的是，坐标比较大，用double会精度不够

看了watashi的做法

他将坐标都除以他们的gcd ，相等的就是同一直线了，而gcd就用来判断距离了！！

这样将大数变小了！！！

注意的是gcd(abs(x),abs(y))要加绝对值

*/

zoj 3451

/*

给出足球起点坐标，初速度大小，初速度方向，问球能不能进。

球每碰地一次速度减半

参考watashi的

注意有力量不足的情况

*/

 zoj 3354

/*

给出一种映射f,问一个序列经过任意次映射的复合，问能得到多少种不同的文本

"he may encrypt the letter for several times. "

here may be ai=aj when i≠j. 不是一一映射

如果是一一映射的，就是一个一个的环了（因为出度、入度为 1）

看watashi的

这题就变成环引出尾巴出来了

答案就成了：max{x[i]} + LCM{y[i]}

x[i]为尾巴长度，y[i]为环长度

注意求x[],y[]数组的方法，用栈

而求LCM时，要分解质因子才行

因为LCM(a%MOD,b%MOD) != LCM(a,b)%MOD

*/

cf 56E

/*

n张多米诺骨牌排成一行，每一张在位置xi，高度为hi

它倒下的话会影响到[xi,xi+hi-1]，问每张骨牌最多能影响右边的多少张骨牌

令dp[i]表示第i张骨牌能影响到的最远的骨牌为dp[i]

dp[i] = max{dp[j]}   x[i] <= x[j] <= x[i] + h[i] - 1

则第i张骨牌能影响到的骨牌数目为dp[i] - i + 1

我一开始用线段树搞，用单调队列也行

看了别人代码，神奇，直接算就行了

第i张骨牌，检查的范围是[x[i],x[i]+h[i]-1]

如果在检查过程中发现j，其中dp[j]能影响的最远范围已经超过x[i]+h[i]-1的话，就不用再检查j之后到x[i]+h[i]-1

的骨牌了，因为从x[j]到x[i]+h[i]-1的已经被j考虑过了（也可认为是j到x[i]+h[i]-1最后只会收敛到dp[j]）

直接return dp[j]即可

反之，若未超过，则令 j = dp[j] + 1

跳跃性检查

（认为j到dp[j]收敛到dp[j]了，所以下次检查dp[j]+1）

*/

CF57D
/*
 题意：n,m的网格，有一些static particles，规定任意两个不能在同一行、列，不能在相邻的对角线
  A dynamic particle选择非static的cell作为起点和终点，然后从起点选择最短路径走到终点（不经过
  static particles）。问平均路长

  参见解题报告：http://www.codeforces.com/blog/entry/1171
 题目的那种规定，发现，对于同一行、列，如果要跨过那个'X'，就需要多加2
 而对于连续行的'X'，如下图：
 1..X.....
 2....X...
 3......X.
 1的左边到1、2、3的右边需要多加2
 2的左边到2、3的右边也需要多加2
 ...
 另外，对于下图：
 1..X..... 
 2......X.
 3....X...
 1的左边到2的右边需多加2，而到3的右边不需加
 2的右边到3的左边需多加2
 所以，从上往下，对于连续的行，寻找递增或递减的一块，然后对于这一连续的块，统计从左边到右边
 或右边到左边需要多加的步数2
 
 解题报告的框架，两两点距离之和（包括'X'）- 'X'到所有点距离和*2 + 'X'到'X'距离和*2
                                                                       这里多减了2倍'X'到'X'的，所以要加上
  最后，再加上因为'X'存在要绕路需要多加的距离
*/


CF 58D
/*
 题意：n个单词（lowercase），先要分成n/2行，每行2个单词，两个单词用分隔符d隔开
 要使得所有行串起来字典序最小，问如何安排每两行的单词
 
 分隔符d可以<'a' , > 'z'
 若已知第一个单词，那么要使字典序最小，第2个单词肯定是长度为avg-lena中字典序最小的单词
 avg是每一行两个单词的长度和
 
 可以先按照 单词+d 来排序，然后按从小到大安排
 每个排在前面的单词，然后加上长度为avg-lena中字典序最小的单词
*/


SRM 496 PalindromfulString 容斥写法  ★★★★
/*
 问长度为N的字符串(uppercase)中，至少有K个长度为M的回文串的个数
 N<=11

 一开始我在那里dp推，发现有重复之类的东西不好搞
 看了Sevenkplus的，容斥，感觉好神奇
 
 最多有P = N - M + 1个回文串
 由于规模比较小，枚举选出哪几个作为回文串，使得至少有K个，令这个模式为Ti
 （如N = 3, M= 2 , K = 1 ，一个合法的模式为 010）
 则答案为|T0∪T1...∪Tc|，这里就要用到容斥了
 = ∑|Ti|
   -∑|Ti∩Tj|
   +∑|Ti∩Tj∩Tk|
   ...
     直接套用的话复杂度为2^(2^P) ！！

  与平常的容斥有点不一样，这里存在很多“Tj包含于Ti”，即其交集就是子集了
  如011包含于010
  因为满足011的肯定满足010，所以011是010的子集，这里注意了！！二进制枚举Ti的超集Tj，是模式Ti的子集

  画个韦恩图，一个集合Tj要计算的次数就是先减去其余集合Ti在这部分算的次数（减完就为空了），再加上1
  即为 1 - 其余集合Ti在这部分算的次数
 用num[i]表示集合Ti需要算的次数，则num[i] = 1 - ∑num[ii]  ii为i的超集
 for(int j = i+1 ; j < (1<<P) ; j++)
 {
  if((j & i) == i)//j是i的子集
   num[j] -= num[i];
 }
 所以集合Ti对答案的贡献为 ans += num[i]*26^cnt
 O((2^p)^2)
 cnt为集合Ti独立变量的个数
 对Ti,求独立变量的个数，可以先建图（利用回文串两端相等的性质），然后dfs算出连通块的个数就是独立变量的个数了
*/


TCO'10 Qualification Round 1A 1000pt MegadiamondHunt
/*
 将只含有'<','>'的串，每次去掉<..<>..>连着的几个
 如果去掉中有n对，则得分为n^2
 求最大得分
 
 一开始以为去掉的顺序没关系，过不了最后一个sample
 看了LayCurse的代码，它是每次选择 极大的<..<>..>中最小的一个去掉
 这样子去贪心...
 如 <<<>><>>
 如果先去掉<<>>，然后剩下<<>> 得分为 2^2+2^2
 但若先去掉<>，则剩下<<<>>> 得分为 1 + 3^2
 因为，考虑一个极大的<..<>..>,若它能扩大，则它的左右肯定先去掉了一个
 极大的<..<>..>，如果已去掉的那个比当前的大，得分是不会比先去掉当前
 这个较小的大，所以每次选极大中的最小那个去掉
*/

zoj 3458
/*
 0 < b - a < 1 + 2sqrt(a)  求 floor(sqrt(a)+sqrt(b))^n % 2(a+b)

 看watashi的，没接触过这种问题，做法挺神奇( ⊙ o ⊙ )！

 由 0 < b - a < 1 + 2sqrt(a)
  => 0 < sqrt(b) - sqrt(a) < 1
 令Xn = (sqrt(b)+sqrt(a))^2n = (b+a+2sqrt(ab))^n
    Yn = (sqrt(b)-sqrt(a))^2n = (b+a-2sqrt(ab))^n
    Zn = Xn +Yn = (b+a+2sqrt(ab))^n + (b+a-2sqrt(ab))^n
 
 由于X1 = b+a+2sqrt(ab) , Y1 = b+a-2sqrt(ab)
 是方程(U-X1)(U-Y1) = 0 ，即 U^2 - 2(a+b)U + (a-b)^2 = 0 的根
 则Zn+2 = 2(a+b)Zn+1 - (a-b)^2Zn
 用矩阵乘法可以求得Zn
 由于Yn<1 ，所以floor(Xn) = Zn - 1，所以最后答案Zn-1即可

 以上方法有个地方
 “
 由于X1 = b+a+2sqrt(ab) , Y1 = b+a-2sqrt(ab)
 是方程(U-X1)(U-Y1) = 0 ，即 U^2 - 2(a+b)U + (a-b)^2 = 0 的根
 则Zn+2 = 2(a+b)Zn+1 - (a-b)^2Zn
 ”
 我不太懂，查了下特征根的一点东西
 若An+2 = pAn+1 +qAn
 则An = C1α^n + C2β^n
 上面应该是逆过来
 由Zn = Xn +Yn = (b+a+2sqrt(ab))^n + (b+a-2sqrt(ab))^n
 推出Zn+2 = 2(a+b)Zn+1 - (a-b)^2Zn
*/


zoj 3461
/*
 给出一个无向图，有边权，点权。点权val[i]为正的表示要将val[i]分出给点权为负的，每个点可以作为中间节点
 点权val[i]为负的表示要接收val[i]，传送的花费为路径的距离，求最小距离
 n<=16

 按照题意，花费即为∑val[i] = 0 的树的MST 
 我有想过需要划分成几部分，起初没想过怎么划分

 解题报告是枚举子集作为一部分树，dp求解（n那么小，要往集合方面想吧！）
 即dp[mask] = dp[mask^i] + mst[i];
 注意需要sum[mask] = 0 的才有意义
*/


zoj 3463
/*
 一只手，相对拇指不动，至少要占5个键的位置，至多可以弹到9个键。
 拇指移动距离x需要花费floor(sqrt(x))，已知左右手初始位置和接下来
 需要弹奏的1000个键，求最小花费。

 状态比较明显，dp[n,l,r]表示已经弹了n个音符，左、右手拇指分别在l,r
 的最小代价
 无效状态很多，不能计算，否则会超时
 枚举左右手到需要弹的位置，其他情况不用考虑，不会更优

 这句话不太懂："But, one finger touching the key between two fingers of the other hand is fobidden."
 貌似不用处理？
 
 看watashi的代码的
 sqrt的初始化很漂亮

 hdu 3651是简化版，都是无效状态不用算，决策是直接到需要的位置
*/


zoj 3464
/*
 N个人，起初在一条线上。
 每个人有速度vi，且每个人最多只能跑带着棒Ts，问最快时间接棒跑完L

 贪心，最快的人跑最后Ts，倒数第二快的跑倒数第二Ts...
*/



TCO'10 Wildcard Round 500pt CalculationCards
/*
 n<=50张卡 如3张：+1 ,-2 , *3  其排列有
 0 + 1 - 2 * 3 = -5
 0 + 1 * 3 - 2 = 1
 0 - 2 + 1 * 3 = 1
 0 - 2 * 3 + 1 = -5
 0 * 3 + 1 - 2 = -1
 0 * 3 - 2 + 1 = -1
 期望为-1.6666666666666667
 求给定的n张卡的期望值

 看解题报告http://www.topcoder.com/wiki/display/tc/TCO'10+Wildcard+Round
 以及bmerry代码的

 不可能n!的枚举
 设+、-卡共有s张
 按照一个+、-卡后接连续的*卡分类，则有s部分，其全排列不影响期望（总共s!种，但期望都一样）
 所以只考虑无序的（无序可以用默认的一种顺序，即卡出现的先后顺序，或者说编号）
 ***a1***a2*** ... as***
 ***表示*卡
 由于是等概率的，所以总体来统计，每个+、-卡都会接同样的*卡，
 既然每张+、-卡情况一样，那就考虑a1卡
 其后会接0,1...,m张*卡
 答案就是 sum * (0,1,...m)张*卡的期望   sum = ∑ai
 求k张*卡的期望可以用dp做
 看bmerry代码的做法，解题报告的麻烦一点吧
 一开始只有s张a卡排着，然后插入一张张*卡
 dp[i,j]表示插入了前面i张*卡，a1后接j张*卡，它们构成的期望值
 分第i张卡插不插入到a1之后构成j张连续的*卡，概率为 该插入的位置/总位置
 dp[i,j] =
    dp[i-1,j] * (n-j-1)/n
   + m[i]*dp[i-1,j-1] * j/n
 n为s+i

 这道题一个很好的想法就是答案为sum * (0,1,...m)张*卡的期望   sum = ∑ai   ！！！！！！
 而求后接k张*卡的期望，bmerry的做法是一张一张卡插入，然后求得期望
 小规模到大规模，通过考虑插入位置来实现，这个做法应该较好
*/


TCO 2010 Qualification Round 1 250pt
/*
 题意：一个只有B,G组成的串，要将他们swap相邻的，变成BB...GG或GG...BB
 求最少的次数  串长<=50
 我用n^2的求逆序对，太慢了
 看了别人的，直接就是累计将每个字母B移到左边的步数
 if(row[i] == 'B')
 {
  tot += i - x;
  x ++;
 }
 x是当前需要放B的位置，交换后就++移到下个位置
*/



TCO'10 Qualification Round 2 1000pt HandlesSpelling
/*
 给出一个文本串，一些模式串
 现要将模式串覆盖文本串，不能有重叠部分
 求使得A^2 - B 最大
 A是最长覆盖的长度，B是还未覆盖的个数

 一开始一直关注A^2 - B ，不知怎么做
 解题报告是分开来做
 要求得A^2 - B的最大值，可以通过枚举A
 枚举某一段作为最大覆盖值，然后看其左右未覆盖的个数

 而计算为覆盖的个数可以通过dp了
 dp[i,j]表示[i,j]为覆盖的个数
 枚举[i,i']一段是被覆盖的，则答案就是min(dp[i'+1,j])
 注意的是，初始化有些dp[i,j]=0，就直接continue
*/


SRM 216 Refactoring
/*
 问一个数n<=2*10^9 可以拆分成多少种因子相乘的情况
 24 = 2*2*2*3
   = 2*2*6
   = 2*3*4
   = 2*12
   = 3*8
   = 4*6
 
 不需要高深的数学知识！！！
 暴力dfs做
 f(n) = 1 + ∑f(n/i) 
 i 为其因子,i > 1 && i <= n/i（保证不会进入多余的分支）
 为了保证无序，可以多加一个参数start，表示该轮的因子>=start
*/



SRM 223 PrimeAnagrams
/*
 给出一个数字串len<=8
 求将其分为三部分，每部分都是素数，且乘积最小

 看解题报告的
 8! = 40320 ，而分成3部分情况为C(7,2) = 21种
 所以枚举全排列，然后分成3部分来做

 Brute Force ！！！！！！
*/


zoj 3471 mask dp
/*
 n<=10个球，i碰j会产生a[i,j]的能量，j同时会消失
 问最多产生的能量之和
 
 我知道跟mask有关，为啥还是想不出？
 
 要从整体来看！！
 现在有一些球，掩码为mask
 假设最先碰撞的是u->v，然后v消失了
 局面就变成了没有v的一些球了, mask^(1<<v)，一个子问题了
 所以转移就是枚举u,v
 dp[mask] = max(dp[mask^(1<<v)+a[u][v]) 

 从局面来看吧！！！

 一开始我是像zoj 3461 dp[mask] = dp[mask^i] + mst[i];
 发现会出问题，这样子是隔离了一部分，但显然隔离了后会丢失了连接着两部分的那个值
 
*/

zoj 3470
/*
 如图，问某个数字上下左右的数字是多少
 既然题目给了一副对应的坐标，发现，问题的重点就在于点坐标跟数字的转换
 
 我是先找出数字val在第n圈 即 (n-1)^2 < val <= n^2
 然后该圈的起点start就是(n-1)^2 + 1 ， 然后通过比较start，就能求出坐标了
 发现奇数圈会使minx--,miny-- ; 偶数圈会使maxx++,maxy++
 数量关系是minx = miny = -(n-1)/2 , maxx = maxy = n/2
 
 然后点(x,y)转化为值，跟上面类似的
 求出第n圈  二分判断 minx<=x<=maxx , miny<=y<=maxy
 然后求出角落的点等等...
*/


zoj 3468
/*
 Dice游戏，一开始Attacker Defender各有骰子n,m个
 双方拿出一定骰子来投，累计和
 谁多点谁赢
 Attacker拿出至少1个来攻击
 问Attacker一次攻击赢的概率
 骰子数目<=8
 枚举Attacker投出的和为j，然后计算达到j的方法数，以及Defender投出的和小于j的方法数
 
 用背包的方法计算方法数
*/

CF 60D
/*
 n<=10^6个点，每个点有权值a[i]<=10^7 各不相同
 若存在一个数x，使得a[i],a[j],x   is a beautiful triple
 即a^2 + b^2 = c^2   a,b,c互素
 则i可以传播laugh到j
 问最少需要需要让多少个顶点自行laugh，然后传播到全部的顶点

 看了解题报告的
 并查集做
 但如何判断beautiful triple 两两判断O(n^2)会超时

 有个性质：对于满足a^2 + b^2 = c^2的数，可用勾股数公式生成：
 (x^2-y^2 , 2xy , x^2+y^2)  x>y
 该公式能生成所有的素勾股数（互质），需1奇1偶 ，且gcd(x,y) = 1
 也能生出部分派生勾股数(如 6 8 10) ， 2奇或2偶
 
 由于a[i]<=MAX       MAX= 10^7
 所以必有x^2-y^2 <= MAX , 2xy <= MAX  但x^2+y^2不一定<= MAX
 2y^2<=MAX
 x^2<=MAX+y^2<=3MAX/2
 => x<=sqrt(3MAX/2) , y <= sqrt(MAX/2)
 所以枚举x,y复杂度为O(MAX)
 (注意x,y是1奇1偶且gcd(x,y) = 1)

 参考watashi代码写的 
*/


CF60E
/*
 一开始 n <= 10^6 个 Mushroom 按升序排成一条直线 ， 每个Mushroom重为a[i]
 下一秒时，a[i] , a[i+1] 之间会出现一个a[i]+a[i+1]的Mushroom
 而x秒时，某人重新排序这些Mushroom
 问再经过y秒，所有Mushroom的重量之和

 0 a1  a2  a3
 1 a1  a1+a2  a2  a2+a3  a3
 2 a1  2a1+a2  a1+a2  a1+2a2  a2  2a2+a3  a2+a3  a2+2a3  a3
 3 ...
 设时间i时重量为Ti 则Ti = 3Ti-1 - (a1+an)
 所以前x可用矩阵乘法求出Tx
 然后由于sort，最大的值是Fx-1*an-1 + Fx*an （找规律 Fx-1*ai-1 + Fx*ai , Fx*ai-1 + Fx-1*ai）
 F是斐波那契数列  F[-1] = 0 , F[0] = 1
 然后修改a1+an值即可，再次矩阵乘法 算出后来的y秒
*/


noip2002 G2 字串变换 双向BFS
/*
 给出A,B串
 以及一些变化方法，即x->y
 求A变到B的最短步数
 
 bfs慢点
 双向会快点
 由于x->y是单向的，所以两边的结构不同，优先扩展队列长度短的优化就有用了
 注意反向BFS时扩展的顺序是y->x
*/

poj 2411
/*
 问n*m的棋盘放置1*2的骨牌的方案数
 n,m<=11
 
 枚举行，递推计算列
 dp[row,col,s]  row行之前已经放好,且当前row行处于s状态
 递推 通过在row行，col列之后放置，扩展计算
 dp[row,col,s1] += dp[row-1,col,s2]

 不是记忆化搜索 是从0递推
 为了打表，在每个分支都计算了  即:dp[row][col][s1] += dp[row-1][col][s2];
 否则，可以在最后的时候才计算的
*/

sgu 131
/*
 n*m棋盘，问用1*2, 2*2去掉一个角的骨牌覆盖完的方案数
 
 状态定义为 dp[row,s]表示当前第row行状态为s，且前row-1行已经覆盖完的方案数
 则 dp[row,s] <-- dp[row-1,s']
 转移是枚举row这一行每个位置（注意是整行）怎么放
 同时，若枚举了row怎么放，则由状态的定义，row-1之前的必须覆盖完，就知道了s'是什么了！！！
 
 每个位置有7种放法，除了被之前的方法限制了，就不足
*/


hdu 2640
/*
 n*m的棋盘，有一些位置不能放，问最多能放多少个十字架
    @
 @@@
    @

 注意的是，每个@都需要放，所以棋盘相应的位置需要是空的
*/


xmu 1118
/*
 求用1*1,1*2,1*3的砖块铺满 3*N的板的方案数目
 1*3，最多影响3行 所以状态需要记录当前行以及前一行的情况  2bit 共4种
 _    *    _    *
 _    _    *    *
 _表示空，*表示被覆盖

 dp[row,s]表示row-1之前的已经覆盖完了，row-1,row的状态为s时的值
 
 对row这一行的每个位置，枚举其放的方法
 虽然说4种状态，实际上转移时很多是不需要的。因为为了满足row-1之前的是覆盖完的

不放，可以转移两种，即上面的1,2种类型
*/



hdu 2240
/*
 给出如图n*5棋盘，其中第一块最多只能用c个，其余的不限
 问能否铺满
 跟sgu 131类似
 不过这里dp的值是记录最少使用的1
 b1,b2是之前的方法对当前的影响
*/



hdu 2606
/*
 用1*1, 2*2, 3*3, 4*4覆盖完N*4的棋盘的方案总数
 递推
 dp[n] =  dp[n-1]         最底部放4个1*1
           + 4*dp[n-2]     最底部组合出2*4的，总共有4种
           + 4*dp[n-3]     最底部组合出3*4的，总共有4种  2个是2块2*2上下交错 2个是一块3*3
           + 3*dp[n-4]     最底部组合出4*4的，总共有3种  2个是3块2*2上下交错 1个是一块4*4
    + 2*(dp[n-5]+dp[n-6]...+dp[0])    用2*2上下交错放的
 则dp[n-1] = ....
 两式相减，得到dp[n] = 2dp[n-1] +3dp[n-2] - dp[n-4] - dp[n-5]    n>=5
 至于n<=4的，结合上面的dp[n]的式子计算

 脑残了，wa了好几次
 没想到可以2*2上下交错  脑残
*/



hnu 10816 ugly number
/*
 题意：给出n个素数<=10000  n<=10
 问[x,y]区间内只包含这些素数因子的数，要求全部打印出来
 x,y<=2^31
 一开始看到规模吓了一跳
 事实上，只含有这些因子的数是很少的
 注意不是倍数！！之前第一印象看成倍数，搞个容斥了，算了下2和3的，数据巨大....
 
 像poj 的 ugly number那样子做
 由于每个数都得乘以这些素数来扩展
 用num[]数组存储生成的所有数
 pos[i]表示素数pr[i]当前要乘以num[pos[i]]
 初始num[0] = 1  pos[i] = 0
 然后每一步扩展一个数，该数为num[tot] = min(num[pos[i]]*pr[i])
 然后判断每个num[pos[i]]*pr[i] 是否 = num[tot]，是的话 pos[i]+1
 
 这种思想还是没能很好掌握...
 肯定的是，每个数都得乘以pr[1],pr[2]...
 要用pos[i]记录当前pr[i]乘到哪个数了！！！
*/



08 ZhuHai Contest  E Magic Squares 双向bf
/*
 问一个排列变为3*3幻方的最小步数
 每一步可以选择一个角进行旋转
 
 状态数不多9!
 先全排列得到目标状态
 再双向bfs  挺快的
 用康托展开（变进制）判重更快
*/


poj 3255 无向图值次短路 ★★★
/*
 给出一个无向图 n<=5000, m <= 30000
 求1到n的值次短的路，如果有多条最短路，但次短的还是需要大于最短的
 允许点、边走多次

 靠解题报告保养~~~ T_T
 求1到其他点的最短路dist[] ，再求n到其他点的最短路rdist[]
 枚举每条边，找到次短的 dist[u] + (u,v) + rdist[v]

 启示:  枚举哪条边作为中间的必须经过的边u->v，然后连接1->u, v->n
*/


scu 3904
/*
 一个序列seq[i]   n<=10^5                -10000<=seq[i]<=10000
 将其划分成几部分，使得每一部分之和>=0
 求所有的划分方法数
 显然dp[i] = ∑dp[j]   (sum[i] - sum[j] >= 0)
 O(n^2)会超时
 用线段树加速
 我一开始是以下标作为线段树的数轴，记录该段Min[p],Max[p],还有一个sDp[p]记录该段所有dp值
 但这样比较慢，维护相对多了点

 看了标程，是先计算所有的sum[]，然后离散化
 以sum值作为数轴来搞，用树状数组就很容易写了

*/


中大第三本 ch2 负权数
/*
 平时 N = anR^n + ... + a0R^0  其中R>0
 负权数是R < 0,使用负权数表示的优点是对于负数，不用前置的符号
 比如 -15 = 1*(-2)^5 + 1*(-2)^4 + 0*(-2)^3 + 0*(-2)^2 + 0*(-2)^1 + 1*(-2)^0
 现给出N,  -16<= R <=-2
 求N的负权数R表示（题目的答案输出一行，表明表示是唯一的）
 (无论正权、负权，系数ai都是 0<=ai<|R|)
 
 因为取余运算只使用语正整数除法，所以不能通过连续连除求余的方法！！！！
 写成普通形式时：

 N >= 0
 N = an|R|^n + ... + a0|R|^0 R < 0
 i为奇数时:
  ai|R|i = R(i+1) + (|R|-ai)Ri          为了保证a'>=0
 i为偶数
  ai|R|i = aiRi
 所以先将N写成正权形式，然后再修改为负权的

 同理
 N < 0
 N = -(an|R|^n + ... + a0|R|^0) R < 0
 i为奇数时:
   -ai|R|i = aiRi         为了保证a'>=0
 i为偶数
  -ai|R|i = R(i+1) + (|R|-ai)Ri

 最后对a'[]进行修正，使得0 <= a'i < |R|

 感觉挺不错的一道题，通过对正权的形式，修正为负权的
*/

 R*C<=100000  递归会爆
 要用非递归...
*/
http://www.cppblog.com/Yuan/archive/2010/08/09/122849.html



POJ 1149 构图不错
/*
 题意: 给出m个猪圈，n个顾客。每个顾客有一些钥匙开猪圈的，开了后那些猪可重新分配也行
    顾客要买Bi头猪  顾客走后门就关了就不能再调整猪了  
    猪圈一开始有一些猪，猪圈可容纳无限的猪
    问能卖出去的最大猪的数目

 这道题，我一开始做，构图是正确，一个小地方写错了，搞了我半天了！
 构图如下：
 S向猪圈连边，容量为猪圈猪的数目
 顾客向T连边，容量为顾客要买的数目
 顾客的钥匙对应的猪圈向顾客连边，容量无限
 如果顾客i跟前面的顾客j有共同的钥匙就能连j->i，容量无限
 
 我这样子构图跟网上的有点不一样，不过核心都是差不多吧 
 “若第i个人与他后面的第j个人有同一个猪圈的钥匙，则从i引边到j,容量为无穷大”

 网上详细构图：http://imlazy.ycool.com/post.2059102.html
 他这种构图方法更巧，去掉了猪圈了（猪圈数目较大）  不过对我就难想到
*/


hdu 2888
二维RMQ  用dp[i][j][k1][k2]表示矩形(i,j)  (i+(1<<k1)-1,j+(1<<k2)-1)的最值





8.10


hdu 3485 
求长度为n的不包含101子串串的个数  跟hdu 2604类似

如图，长度为n的合法串，后缀可以是0，001,0011,00111,...
所以dp[n]=dp[n-1]+dp[n-3]+dp[n-4]+...+dp[1]
而dp[n-1]=dp[n-2]+dp[n-4]+...+dp[1]
两式相减，得到dp[n]=2*dp[n-1]-dp[n-2]+dp[n-3]



hdu 3486
/*
 题意：给出n个数，求分成多少段，使得每段的最大值之和>k （末尾不足一段的丢弃）
 二分分成多少段，直接做即可 O(nlogn)
 用线段树会更慢，O(nlognlogn)
*/


hdu 3482
/*
 题意:问满足条件的长度为n的串的个数  条件是每个长度为m的子串的数字要么全不同、要么全相同
 分类讨论
 m=1  1
 m=2  2^n
 m>n (不存在长度为m的子串)   m^n
 m<=n  m!+m (其实，确定了前m个后面的都会确定的，所以m!  再加上全相同)
*/



hdu 3478
/*
 题意：给出一个无向图，一个起点，问是否在某个时候，这个人有可能在所有点都可以出现
     人不能停留在原地
 画一下图就知道，只要存在奇圈，那么奇圈的点就可以任何时刻都出现人
 同时，对于奇圈外的，奇圈可以源源不断地传到奇圈外
 这样肯定存在某个时刻，其他点也可以同时出现人（因为源源不断传出来，所以肯定会波及所有）
*/
http://www.cppblog.com/Yuan/archive/2010/08/11/123005.html




8.11

hdu 3516
/*
 题意:给出n个点，如果满足 xi < xj and yi > yj for all i < j  就可以在点(xi,yj)向点i,j连边
 求把他们连成一棵树的最小代价
 跟矩阵连乘的加括号一样
 dp[i][j]=min{dp[i][k]+dp[k+1][j]+(pt[k+1].x-pt[i].x)+(pt[k].y-pt[j].y)}
 n<1000
 需要四边形不等式  O(n^2)
*/


hdu 3512
/*
    题意：给出上面n个数，下面n个数，求完美匹配的最大边最小。边权定义为两个数相乘。可以负数
    应该有点YY的
    先分一下情况
    同号：大*小  才能使最大那个最小
    异号：小*小  才能使最大那个最小
    一点贪心的思想
    上面的那些正数跟下面的负数匹配
    上面的那些负数跟下面的正数匹配
    这样剩下来的（当然可以没有剩下），肯定是同号的，而且这些数更接近于0

    现在再来看那些 正数*负数 的情况
    刚才提到“小*小  才能使最大那个最小”，而且越小的话越好
    所以上面那些最大的正数跟下面那些最小的负数匹配（顺序匹配，大-大，小-小）
    同理，上面的那些最小的负数跟下面那些最大的正数匹配

    就这样先排序，然后找出各自的0的位置
    再分类一下即可
*/
http://www.cppblog.com/Yuan/archive/2010/08/11/123105.html

8.12

hdu 3481

/*
 题意：问长度为n的bad serial串的个数。bad serial 指每一个长度为m的子串都不是good serial
 (good serial指要么全相同，要么全不同)，所以bad serial就是两个以上不同，但不能m个都不同

 dp[i,j](1<=j<m)表示长度为i的串最后j个数字互不相同的串个数（即str[i-j]与末尾这j个数中一个相同）

 考虑dp[i+1,j+1]
 (1)dp[i+1,j+1]+=dp[i,j]*(m-j)   选一个与i及之前j个数字都不同的
 (2)dp[i+1,k]+=dp[i,j]  2<=k<=j  选一个与i之前j个数字某个相同的 str[i+1]=str[i+1-k]
 还有一种特殊的就是dp[i,1]，即末尾几个数字都相同的合法串个数
 (3)dp[i+k,1]+=dp[i,j]  (1+k<=m-1, j>1||i==1)
 如果j=1的话有可能一连串都相同导致不合法，要j>1
 特殊的是i=1，j=1就可取，因为1之前没有数字，认为与1不同（跟j>1一样）

 心得：只考虑最后一个字符（第i+1），考虑怎么合法过来的
     dp转移时，由之前的转移过来难写的话，写成从当前扩展到之后的！
     按照题意定义状态，这里要2个以上不同，定义末尾有j个不同（j=1时是特殊情况，即末尾可以几个连续相同）
*/


hdu 3510
/*
 题意：给出n个任务，m台机器  任务间有依赖关系，这些关系构成一棵树  问最短完成时间
 显然完成时间不能少于最深的深度，而每次只能选叶子被机器加工
 这样，每次选深度最深的叶子加工（用PQ）直到完成
 如果不选深度最深的，可能会使时间变长
*/



hdu 3508
/*
 题意：问n内，与n互质的所有数的乘积模n是多少
 打了一些数据，发现只有1和n-1
 当n=1,2,4,p^k,2*p^k时  答案为n-1
*/


hdu 3483
/*
 题意：给出N,x,M 要计算
 N
 ∑(k^x)*(x^k) MOD M
 k=1
        x  
 用到二项式定理，(n+1)^x = ∑C(x,k)n^k  
        k=0
 然后构造矩阵，求和  S(n)表示前n项和
http://www.cppblog.com/Yuan/archive/2010/08/13/123268.html
*/


hdu 3366
/*
 如果已经知道走这些passage的顺序的话，应该可以dp出来的
 但是这里不确定顺序，要选择最优，可以按照P/Q从大到小排序
 遇到匪徒几率Q越小，出去几率P越大，肯定是我们优先考虑的！
 Help Bill to find out the probability that he can escape from this castle if he chose the optimal strategy.

 dp[i][j]表示现在有钱j，在i个passage处，最后能够出去的概率
 dp[n-1,j]=P[n-1]
 dp[i,j]=P[i]+Q[i]*dp[i+1,j-1]+(1-P[i]-Q[i])*dp[i+1,j]   j>0
 dp[i,j]=P[i]+(1-P[i]-Q[i])*dp[i+1,j]   j=0

 概率题期望题，一般都是表示现在离目标的值
 （因为当前接下来的方案确定了，概率也知道了，而当前从前面过来就不确定概率了，其概率跟路径有关）
*/

8.13

zoj 2597
/*
 题意：题目定义一种n位的yellow code  相邻两个数之间要差别至少[n/2]。让你构造出n位的yellow code
 观察发现，n位可以由n-1位复制一遍，然后最后一列再算一下得来
 对最后一列的前n个爆搜即可，后n个是前n个取反
*/

zoj 1619
/*
 题意：n个人n个礼物混乱，问每人取一个，最终m个人取到自己的概率
 直接用错排公式即可  C(n,m)*D[n-m]/n!
 或者dp
 dp[i,j]表示前i个人j个取得自己的概率
 dp[i,j]可以先安置好i-1的，然后再用乘法原理乘起来
 dp[i,j] = dp[i-1,j]*(i-1-j)/i    先把i-1个人安置出j个人取到自己的情况，为使还是j个人，第i个人需跟剩下的i-1-j个人其中一个交换
   + dp[i-1,j-1]*1/i       先把i-1个人安置出j-1个人取到自己的情况，然后第i个人取到自己的概率
   + dp[i-1,j+1]*(j+1)/i  先把i-1个人安置出j+1个人取到自己的情况，然后第i个人跟这j+1个人之一交换

*/


8.14

zoj 2703 被这道题卡了好久，还是wa

8.16
做了下伸展树的
spoj 4487     1470


8.17

cii 2193
/*
 sample：
 ##-(##+###)
 3333333
 用下面的数字去填上面的#使得该式子最大  有多个时输出字典序最小的
 
 首先，去括号
 没有真的去掉，利用括号前的那些正负号来确定每个数字真实的正负号
 为每个数字或者括号这样的整体添加正负号
 如下面的例子  +(-(+a+b)+c)
 这里在最外的括号及a也要有一个正号

 为了转化出上面的式子用一个栈
 1) '(' 如果其前面不是符号，就需要添加一个符号（跟栈顶一样） push(top)
 2) '(' pop
 3) '±' push(op^top)  这里把负号当成1
 4) '#' 如果其前面不是符号就需要添加一个符号（跟栈顶一样） push(top)
    然后连读... 存起这个数  再pop
 
 正数存在positive 负数存在negative

 现在就来贪心  先将digit排序
 对于正数，每次将digit里最大的数赋值给positive里长度最大的，或长度相同靠后的
 对于负数，每次将digit里最小的数赋值给negative里长度最大的，或长度相同靠前的
 
 可用一个堆来实现，取出后再放进去（这时长度少1了）

*/

今天排位赛，以下的这道树DP想了我好囧！

一开始乱搞高斯消元。我第二次写高斯消元，还是自己默的。醉~~

然后发现，会出现自由元，为了求得最小值，不得二进制枚举了？但n<=100，我乱搞了一下，给我WA,不给我TLE

错了8、9次吧？心碎，只好用树dp做。（膜拜下林mm秒杀它。...Orz）
(后来看了下提交记录，16:41还是提交高斯消元，原来我交了10次高斯。。ft)

每个点记录三个状态：

A[u]  选u     u及其后代都亮

B[u]  不选u   u及其后代都亮

C[u]  不选u  u不亮，但是其后代都亮

显然有A[u]=∑C[v]   v是u的儿子

B[u],C[u]比较难求一点，需要多一次dp

假设u有n个儿子

dp[i,j]表示u的前i个儿子中有j个儿子是按了开关的（即A[v]）的最小值

dp[i,j] = min(dp[i-1,j]+B[v],dp[i-j,j-1]+A[v])

那么

B[u]=min(dp[n,k]); k为奇数

C[u]=min(dp[n,k]); k为偶数

  一个数据：
6
1 2
2 3
2 4
2 5
5 6
ans : 4

#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;

const int MAXN = 100;

vector<int>G[MAXN+10];

int A[MAXN+10],B[MAXN+10],C[MAXN+10];
int dp[MAXN+10][MAXN+10];

void treeDp(int u,int p)
{
    A[u]=1;
    vector<int>son;
    for(int i=0,size=G[u].size();i<size;i++)
    {
        int v=G[u][i];
        if(v==p)continue;
        treeDp(v,u);
        A[u]+=C[v];
        son.push_back(v);
    }
    int n=son.size();
    //dp一下 A[v]  B[v]
    dp[0][0]=0;
    for(int i=1;i<=n;i++)
    {
        int v=son[i-1];
        dp[i][0]=dp[i-1][0]+B[v];
        for(int j=1;j<=i;j++)
        {
            dp[i][j]=MAXN;
            if(i-1>=j)dp[i][j]=min(dp[i][j],dp[i-1][j]+B[v]);
            dp[i][j]=min(dp[i][j],dp[i-1][j-1]+A[v]);
        }
    }
    B[u]=C[u]=MAXN;
    for(int k=0;k<=n;k++)
    {
        if(k&1)B[u]=min(B[u],dp[n][k]);
        else C[u]=min(C[u],dp[n][k]);
    }
}
int main()
{
    int n;
    while(scanf("%d",&n),n)
    {
        for(int i=1;i<=n;i++)G[i].clear();
        for(int i=1;i<n;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        treeDp(1,0);
        printf("%d\n",min(A[1],B[1]));
    }
    return 0;
}

状态表示为
dp[u,0] u父亲未亮，u及子树都已经点亮
dp[u,1] u父亲、u未亮，子树都亮
dp[u,2] u父亲、u及子树都亮了
转移是：
dp[u,0] <- 奇数个dp[v,2] + 剩下的dp[v,0]    v是u的儿子
dp[u,1] <- 偶数个dp[v,2] + 剩下的dp[v,0]
dp[u,2] <- 自身点亮1次 + 所有都是dp[v,1]
注意的是有一种思想：
方正点灯的顺序是无关的，所以在考虑u时，其子树该点的都已经点亮，u是最后点的
这样会清晰很多，就不会再去考虑v是否还点
所以实际情况从底往上点灯。

There is a tree

Time Limit:1000MS  Memory Limit:65535K

题型: 编程题   语言: 无限制

Description

Tree is a graphy without loop and direction when defined in the graphy theory realm. There is a tree with a light and a button at each node. If the button is presses, the state of light at this node will switch to the other state, meaning that it will trun from ON to OFF, or from OFF to ON. Besides, the state of light in the neighbour nodes will also switch from ON to OFF or OFF to ON.

At the beginning, all the lights are in the state OFF. It is your task to find out at least how many operations of switching should be performed in order to make all the light ON.

Input

There are mutiple of data sets in the file.

        At each case, the first line contains an integer n, indicating the number of Nodes in the tree. (n<=100)

        Then following n – 1 lines. Each line contains a pair number of x y, meaning that Node x and Node y is linked with an edge.

        The input file is terminated by a 0.

Output

For each case, output the minimal number of operations to light up all the lights.

Sample Input

3

1 2

1 3

0

Sample Output

1

 
数据： in.txt  out.txt

 题目定义一种叫做n-circle five-angle 的图，问生成树的个数，每个点都算一个不同的点

 

Illustration 1: 4-circle five-angle graph

   首先，中间的环肯定要去掉一些，但是去掉多少条、哪几条呢？
   可以枚举情况。就拿样例说，我们去掉任意的两条，得到下图：

   红色的边表示去掉的。
   1）对于非红色边组成的环，4条边任意一条都能删除，即4^n-i 这里i是中间环要删除的边数
   2）对于红色边组成的环，这4*i条边只能删除一条，删多了就会不连通了，也即4*i种
   再乘上一个组合数C(n,i)即可
   所以F(n) = ∑ 4^n-i*4*i*C(n,i)    1≤i≤n
   样例给了2，注意是2条平行边形成的环！
   

#include<cstdio>
#include<cstring>

int C[101][101],F[101];

int pow4(int n)//4^n
{
    int ans=1,p=4;
    while(n)
    {
        if(n&1)ans=ans*p%2007;
        p=p*p%2007;
        n>>=1;
    }
    return ans;
}
int main()
{
    //freopen("in","r",stdin);
    //freopen("out","w",stdout);
    for(int i=1;i<=100;i++)
    {
        C[i][i]=C[i][0]=1;
        for(int j=1;j<i;j++)
            C[i][j]=(C[i-1][j]+C[i-1][j-1])%2007;
    }
    for(int n=2;n<=100;n++)
    {
        F[n]=0;
        for(int i=1;i<=n;i++)
            F[n]=(F[n]+pow4(n-i)*4*i*C[n][i])%2007;
    }
    int n,T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        printf("%d\n",F[n]);
    }        
    return 0;
}

Problem A. Spanning Tree

A peculiar graph, called n-circle five-angle graph, consists of a polygon with n vertices in the center, and each side of the central polygon is linked with a pentagon(pentagon: a polygon with 5 sides). There is an example of 4-circle five-angle graph below. Obviously, there are 4 vertices in the central polygon.

Now, it is you time to calculate how many spanning trees could this special graph generate. Pay attention that all the vertices in the graph should be regarded as different ones. Do you still remember the definition of spanning tree? Perhaps you may be familiar with the terminology of MST(minimal spanning tree). Yes, a spanning tree T of a connected, undirected graph G is a tree composed of all the vertices and some (or perhaps all) of the edges of G.

Illustration 1: 4-circle five-angle graph

Input:

First line: T, the number of test case.

Then follow T lines, each line contains a number n(n <= 2 <= 100), indicating it is an n-circle five-angle graph.

Output：

For each test case, output the answer mod 2007 pre line.

Sample Input

Sample Output

 
测试数据：in.txt   out.txt