证明

因为所有简单多边形都可切割为一个三角形和另一个简单多边形。考虑一个简单多边形P，及跟P有一条共同边的三角形T。若P符合皮克公式，则只要证明P加上T的PT亦符合皮克公式（I），与及三角形符合皮克公式（II），就可根据数学归纳法，对于所有简单多边形皮克公式都是成立的。

多边形

设P和T的共同边上有c个格点。

• P的面积： i_P + b_P/2 - 1
• T的面积： i_T + b_T/2 - 1
• PT的面积：

(i_T + i_P + c - 2) + (b_T- c + 2 + b_P - c + 2 ) /2 - 1

= i_PT + b_PT/2 - 1

三角形

证明分三部分：证明以下的图形符合皮克定理：

1. 所有平行于轴线的矩形；
2. 以上述矩形的两条邻边和对角线组成的直角三角形；
3. 所有三角形（因为它们都可内接于矩形内，将矩形分割成原三角形和至多3个第二点提到的直角三角形）。

矩形

设矩形R长边短边各有m,n个格点：

• A_R = (m-1)(n-1)
• i_R = (m-2)(n-2)
• b_R = 2(m+n)-4

i_R + b_R/2 - 1

= (m-2)(n-2) + (m+n) - 2 - 1

= mn - (m + n) +1

= (m-1)(n-1)

直角三角形

易见两条邻边和对角线组成的两个直角三角形全等，且i,b相等。设其斜边上有c个格点。

• b = m+n+c-3
• i = ((m-2)(n-2) - c + 2)/2

i + b/2 - 1

= ((m-2)(n-2) - c + 2)/2 + (m+n+c-3)/2 - 1

= (m-2)(n-2)/2 + (m+n - 3)/2

= (m-1)(n-1)/2

一般三角形

推广

• 取格点的组成图形的面积为一单位。在平行四边形格点，皮克定理依然成立。套用于任意三角形格点，皮克定理则是A = 2i + b - 2。
• 对于非简单的多边形P，皮克定理A = i + b/2 - χ(P)，其中χ(P)表示P的欧拉特征数。
• 高维推广：Ehrhart多项式；一维：植树问题。
• 皮克定理和欧拉公式（V-E+F=2）等价。

定理提出者

Georg Alexander Pick，1859年生于维也纳，1943年死于特莱西恩施塔特集中营。

相关书籍

• 《格点和面积》 闵嗣鹤着

外部连结

• 以皮克定理证明欧拉公式（英）
• 谈求面积的 Pick 公式，蔡聪明
• http://www.cut-the-knot.org/ctk/Pick.shtmlde:Satz von Pick

en:Pick's theorem fr:Théorème de Pick it:Teorema di Pick pl:Wzór Picka ru:Теорема Пика

目前我知道的求逆序最快的适合ACM/ICPC的算法是归并排序时计算逆序个数，时间复杂度是nlog2n，而空间复杂度2n。JAVA模板（服务器是校内的）。

归并求逆序简单原理：
归并排序是分治的思想，具体原理自己去看书吧。利用归并求逆序是指在对子序列 s1和s2在归并时，若s1[i]>s2[j]（逆序状况），则逆序数加上s1.length-i,因为s1中i后面的数字对于s2[j]都是逆序的。

TJU 2242:
直接上模板，记得m的奇偶要考虑的哦。

PKU 1007:
求逆序数，然后排序输出就行了。

PKU 1804, PKU 2299:
是最简单的关于逆序对的题目，题目大意是给出一个序列，求最少移动多少步可能使它顺序，规定只能相邻移动。
相邻移动的话，假设a b 相邻，若a<b 交换会增加逆序数，所以最好不要做此交换；若a==b 交换无意思，也不要进行此交换；a>b时，交换会减少逆序，使序列更顺序，所以做交换。
由上可知，所谓的移动只有一种情况，即a>b，且一次移动的结果是逆序减1。假设初始逆序是n，每次移动减1，那么就需要n次移动时序列变为顺序。所以题目转化为直接求序列的逆序便可以了。

ZJU 1481:
这题和本次预选赛的F略有相似，不过要简单得多。题意是给定序列s，然后依次将序列首项移至序列尾，这样共有n-1次操作便回到了原序列（操作类似于循环左移）。问这n-1次操作和原序列，他们的逆序数最小的一次是多少？
有模板在手，直观地可以想到是，对于这n次都求逆序数，然后输出最小的一次就可以了，但这样做的复杂度有O(n*nlogn),太过复杂。
如果只求初始序列的逆序数的话，只要后面的n-1次操作的逆序数能够在O(1)的算法下求得，就能保证总体O(nlogn)的复杂度了。事实上，对于每次操作确实可以用O(1)的算法求得逆序数。将序列中ai移到aj的后面，就是ai做j-i次与右邻的交换，而每次交换有三个结果：逆序+1、逆序-1、逆序不变。由于题目中说明序列中无相同项，所以逆序不变可以忽略。逆序的加减是看ai与aj间（包括aj）的数字大小关系，所以求出ai与aj间大于ai的数字个数和小于ai的数字个数然后取差，就是ai移动到aj后面所导致的逆序值变化了。
依据上面的道理，因为题目有要求ai是移动到最后一个数，而ai又必定是头项，所以只要计算大于ai的个数和小于ai的个数之差就行了。然后每次对于前一次的逆序数加上这个差，就是经过这次操作后的逆序数值了。

PKU 2086:
这题不是求逆序对，而是知道逆序数k来制造一个序列。要求序列最小，两个序列比较大小是自左向右依次比较项，拥有较大项的序列大。
其实造序列并不难，由1804可知，只要对相邻数做调整就能做到某个逆序数了。难点是在求最小的序列。举例 1 2 3 4 5,要求逆序1的最小序列是交换4 5，如果交换其他任意相邻数都无法保证最小。由此可以想到，要保证序列最小，前部分序列可以不动（因为他们已经是最小的了），只改动后半部分。而我们知道n个数的最大逆序数是n*(n-1)/2，所以可以求一个最小的p，使得 k<p*(p-1)/2。得到前半部分是1到n-p，所有的逆序都是由后半部分p个数完成的。
考虑k=7,n=6的情况，求得p=5,即前部分1不动，后面5个数字调整。4个数的最大逆序是5 4 3 2,逆序数是6，5个数是6 5 4 3 2,逆序数是10。可以猜想到，保证5中4个数的逆序不动，调整另一个数的位置就可以增加或减少逆序数，这样就能调整出6-10间的任意逆序。为了保证最小，我们可以取尽量小的数前移到最左的位置就行了。2前移后逆序调整4，3前移后调整了3，4调整2，5调整1，不动是调整0，可以通过这样调整得到出6-10，所以规律就是找到需要调整的数，剩下的部分就逆序输出。需要调整的数可以通过总逆序k-(p-1)*(p-2)/2+(n-p)求得。

PKU 1455:
这是一道比较难的关于逆序数推理的题目，题目要求是n人组成一个环，求做相邻交换的操作最少多少次可以使每个人左右的邻居互换，即原先左边的到右边去，原右边的去左边。容易想到的是给n个人编号，从1..n，那么初始态是1..n然后n右边是1，目标态是n..1，n左边是1。
初步看上去好象结果就是求下逆序（n*(n-1)/2 ?），但是难点是此题的序列是一个环。在环的情况下，可以减少许多次移动。先从非环的情况思考，原1-n的序列要转化成n-1的序列，就是做n(n-1)/2次操作。因为是环，所以(k)..1,n..k+1也可以算是目标态。例如：1 2 3 4 5 6的目标可以是 6 5 4 3 2 1,也可以是 4 3 2 1 6 5。所以，问题可以转化为求形如(k)..1,n..k+1的目标态中k取何值时，逆序数最小。
经过上面的步骤，问题已经和ZJU1481类似的。但其实，还是有规律可循的。对于某k，他的逆序数是左边的逆序数+右边的逆序数，也就是(k*(k-1)/2)+((n-k)*(n-k-1)/2) （k>=1 && k<=n）。展开一下，可以求得k等于n/2时逆序数最小为((n*n-n)/2)，现在把k代入进去就可以得到解了。
要注意的是k是整数，n/2不一定是整数，所以公式还有修改的余地，可以通用地改为(n/2)*(n-1)/2。

PKU 2893:
用到了求逆序数的思想，但针对题目还有优化，可见M*N PUZZLE的优化。

PKU 1077:
比较经典的搜索题，但在判断无解的情况下，逆序数帮了大忙，可见八数码实验报告。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ray58750034/archive/2006/10/08/1325939.aspx

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ray58750034/archive/2006/10/08/1325939.aspx

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ray58750034/archive/2006/10/08/1325939.aspx

       一般采取树形结构来存储并查集，在合并操作时可以利用树的节点数(加权规则)或者利用一个rank数组来存储集合的深度下界--启发式函数，在查找操作时进行路径压缩使后续的查找操作加速。这样优化实现的并查集，空间复杂度为O(N)，建立一个集合的时间复杂度为O(1)，N次合并M查找的时间复杂度为O(M Alpha(N))，这里Alpha是Ackerman函数的某个反函数，在很大的范围内这个函数的值可以看成是不大于4的，所以并查集的操作可以看作是线性的。
它支持以下三种操作:
　　－Union (Root1, Root2) //合并操作；把子集合Root2和子集合Root1合并.要求：Root1和 Root2互不相交,否则不执行操作.
　　－Find (x) //搜索操作；搜索元素x所在的集合,并返回该集合的名字--根节点.
　　－UFSets (s) //构造函数。将并查集中s个元素初始化为s个只有一个单元素的子集合.
　　－对于并查集来说，每个集合用一棵树表示。
　　－集合中每个元素的元素名分别存放在树的结点中，此外，树的每一个结点还有一个指向其双亲结点的指针。  
       －为简化讨论，忽略实际的集合名，仅用表示集合的树的根来标识集合。

以下给出我的两种实现:

  1//Abstract: UFSet                  
  2
  3//Author:Lifeng Wang （Fandywang）
  4
  5
  6
  7
  8// Model One 与Model 2 路径压缩方式不同,合并标准不同
  9
 10const int MAXSIZE = 500010;
 11
 12int rank[MAXSIZE];    // 节点高度的上界
 13
 14int parent[MAXSIZE]; // 根节点
 15
 16int FindSet(int x){// 查找+递归的路径压缩
 17
 18    if( x != parent[x] ) parent[x] = FindSet(parent[x]);
 19
 20     return parent[x];
 21
 22}
 23
 24void Union(int root1, int root2){
 25
 26     int x = FindSet(root1), y = FindSet(root2);
 27
 28     if( x == y ) return ;
 29
 30     if( rank[x] > rank[y] ) parent[y] = x;
 31
 32     else{
 33
 34         parent[x] = y;
 35
 36         if( rank[x] == rank[y] ) ++rank[y];
 37
 38     }
 39
 40}
 41
 42void Initi(void){
 43
 44     memset(rank, 0, sizeof(rank));
 45
 46     for( int i=0; i < MAXSIZE; ++i ) parent[i] = i;
 47
 48}
 49
 50
 51
 52
 53// Model Two
 54
 55const int MAXSIZE = 30001;
 56
 57int pre[MAXSIZE]; //根节点i,pre[i] = -num,其中num是该树的节点数目;
 58
 59                   //非根节点j,pre[j] = k,其中k是j的父节点
 60
 61int Find(int x){//查找+非递归的路径压缩
 62
 63     int p = x;
 64
 65     while( pre[p] > 0 )    p = pre[p];
 66
 67     while( x != p ){
 68
 69         int temp = pre[x]; pre[x] = p; x = temp;
 70
 71     }
 72
 73     return x;
 74
 75}
 76
 77void Union(int r1, int r2){
 78
 79     int a = Find(r1); int b = Find(r2);
 80
 81     if( a == b ) return ; 
 82
 83     //加权规则合并
 84
 85     if( pre[a] < pre[b] ){
 86
 87         pre[a] += pre[b]; pre[b] = a;
 88
 89     }
 90
 91     else {
 92
 93         pre[b] += pre[a]; pre[a] = b;
 94
 95     }
 96
 97}
 98
 99void Initi(void)
100
101{
102
103    for( int i=0; i < N; ++i ) pre[i] = -1;
104
105}        　　
106
107

POJ 1611 The Suspects          最基础的并查集
POJ 2524 Ubiquitous Religions 最基本的并查集
POJ 1182 食物链       并查集的拓展
注意: 只有一组数据;
要充分利用题意所给条件:有三类动物A,B,C，这三类动物的食物链
构成了有趣的环形。A吃B， B吃C，C吃A。也就是说:只有三个group
POJ 2492 A Bug's Life 并查集的拓展
法一:深度优先遍历
每次遍历记录下该点是男还是女，只有:男-〉女，女-〉男满足，否则，找到同性恋，结束程序。
法二:二分图匹配
法三:并查集的拓展:和1182很像，只不过这里就有两组，而1182是三组,1611无限制
POJ 1861 Network == zju_1542    并查集+自定义排序+贪心求"最小生成树"
答案不唯一，不过在ZOJ上用QSORT()和SORT()都能过，在POJ上只有SORT()才能过...
POJ 1703 Find them, Catch them 并查集的拓展
这个和POJ 2492 A Bug's Life很像，就是把代码稍微修改了一下就AC了！
注意：And of course, at least one of them belongs to Gang Dragon, and the same for Gang Snake. 就是说只有两个组。
POJ 2236 Wireless Network        并查集的应用
需要注意的地方：1、并查集；2、N的范围，可以等于1001；3、从N+1行开始，第一个输入的可以是字符串。
POJ 1988 Cube Stacking            并查集很好的应用
1、与 银河英雄传说==NOI2002 Galaxy一样；2、增加了一个数组behind[x],记录战舰x在列中的相对位置；3、详细解题报告见银河英雄传说。

JOJ 1905 Freckles   == POJ 2560 最小生成树

法一：Prim算法；法二：并查集实现Kruskar算法求最小生成树

JOJ 1966 Super Market III == PKU 1456 Supermarket 带限制的作业排序问题（贪心+并查集）

提高题目：
POJ 2912 Rochambeau
POJ 1733 Parity game   
POJ 1308 Is It A Tree?

上次在湖大，其中的一道题数据很强，我试了好多种优化都TLE，相信只能用线段树才能过。回来之后暗暗又学了一次线段树，想想好像是第三次学了，像网络流一样每学一次都有新的体会。

把问题简化一下：

在自然数，且所有的数不大于30000的范围内讨论一个问题：现在已知n条线段，把端点依次输入告诉你，然后有m个询问，每个询问输入一个点，要求这个点在多少条线段上出现过；

最基本的解法当然就是读一个点，就把所有线段比一下，看看在不在线段中；

每次询问都要把n条线段查一次，那么m次询问，就要运算m*n次，复杂度就是O(m*n)

这道题m和n都是30000，那么计算量达到了10^9；而计算机1秒的计算量大约是10^8的数量级，所以这种方法无论怎么优化都是超时

-----

因为n条线段是固定的，所以某种程度上说每次都把n条线段查一遍有大量的重复和浪费；

线段树就是可以解决这类问题的数据结构

举例说明：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次

在[0,7]区间上建立一棵满二叉树：（为了和已知线段区别，用【】表示线段树中的线段）

                                               【0,7】

                                      /                                  \

                     【0,3】                                           【4,7】

                  /               \                                    /                \

       【0,1】             【2,3】                 【4,5】               【6,7】

         /      \                 /      \                       /      \                      /      \

【0,0】 【1,1】【2,2】 【3,3】   【4,4】 【5,5】 【6,6】 【7,7】

每个节点用结构体：

struct line

{

      int left,right;//左端点、右端点

      int n;//记录这条线段出现了多少次，默认为0

}a[16];

和堆类似，满二叉树的性质决定a[i]的左儿子是a[2*i]、右儿子是a[2*i+1];

然后对于已知的线段依次进行插入操作：

从树根开始调用递归函数insert

 1void insert(int s,int t,int step)//要插入的线段的左端点和右端点、以及当前线段树中的某条线段
 2
 3{
 4
 5      if (s==a[step].left && t==a[step].right)
 6
 7      {
 8
 9            a[step].n++;//插入的线段匹配则此条线段的记录+1
10
11            return;//插入结束返回
12
13      }
14
15      if (a[step].left==a[step].right)   return;//当前线段树的线段没有儿子，插入结束返回
16
17      int mid=(a[step].left+a[step].right)/2;
18
19      if (mid>=t)    insert(s,t,step*2);//如果中点在t的右边，则应该插入到左儿子
20
21      else if (mid<s)    insert(s,t,step*2+1);//如果中点在s的左边，则应该插入到右儿子
22
23      else//否则，中点一定在s和t之间，把待插线段分成两半分别插到左右儿子里面
24
25      {
26
27            insert(s,mid,step*2);
28
29            insert(mid+1,t,step*2+1);
30
31      }
32
33}
34
35

三条已知线段插入过程：

[2,5]

--[2,5]与【0,7】比较，分成两部分：[2,3]插到左儿子【0,3】，[4,5]插到右儿子【4,7】

--[2,3]与【0,3】比较，插到右儿子【2,3】；[4,5]和【4,7】比较，插到左儿子【4,5】

--[2,3]与【2,3】匹配，【2,3】记录+1；[4,5]与【4,5】匹配，【4,5】记录+1

[4,6]

--[4,6]与【0,7】比较，插到右儿子【4,7】

--[4,6]与【4,7】比较，分成两部分，[4,5]插到左儿子【4,5】；[6,6]插到右儿子【6,7】

--[4,5]与【4,5】匹配，【4,5】记录+1；[6,6]与【6,7】比较，插到左儿子【6,6】

--[6,6]与【6,6】匹配，【6,6】记录+1

[0,7]

--[0,7]与【0,7】匹配，【0,7】记录+1

插入过程结束，线段树上的记录如下（红色数字为每条线段的记录n）：

                                               【0,7】

                                                    1

                                  /                                      \

                     【0,3】                                           【4,7】

                         0                                                     0

                 /                 \                                     /                 \

       【0,1】                 【2,3】                【4,5】                【6,7】

            0                           1                           2                          0

          /    \                      /      \                     /     \                    /      \

【0,0】 【1,1】 【2,2】 【3,3】 【4,4】 【5,5】 【6,6】 【7,7】

     0            0             0            0             0            0                 1           0

询问操作和插入操作类似，也是递归过程，略

2——依次把【0,7】 【0,3】 【2,3】 【2,2】的记录n加起来，结果为2

4——依次把【0,7】 【4,7】 【4,5】 【4,4】的记录n加起来，结果为3

7——依次把【0,7】 【4,7】 【6,7】 【7,7】的记录n加起来，结果为1

不管是插入操作还是查询操作，每次操作的执行次数仅为树的深度——logN

建树有n次插入操作，n*logN，一次查询要logN，m次就是m*logN；总共复杂度O(n+m)*logN，这道题N不超过30000，logN约等于14，所以计算量在10^5～10^6之间，比普通方法快了1000倍；

这道题是线段树最基本的操作，只用到了插入和查找；删除操作和插入类似，扩展功能的还有测度、连续段数等等，在N数据范围很大的时候，依然可以用离散化的方法建树。

湖大的那道题目绕了个小弯子，alpc12有详细的题目和解题报告，有兴趣的话可以看看http://www.cppblog.com/sicheng/archive/2008/01/09/40791.html

线段树的经典题目就是poj1177的picturehttp://acm.pku.edu.cn/JudgeOnline/problem?id=1177

Bellman-Ford算法与另一个非常著名的Dijkstra算法一样，用于求解单源点最短路径问题。Bellman-ford算法除了可求解边权均非负的问题外，还可以解决存在负权边的问题（意义是什么，好好思考），而Dijkstra算法只能处理边权非负的问题，因此 Bellman-Ford算法的适用面要广泛一些。但是，原始的Bellman-Ford算法时间复杂度为 O（VE）,比Dijkstra算法的时间复杂度高，所以常常被众多的大学算法教科书所忽略，就连经典的《算法导论》也只介绍了基本的Bellman-Ford算法，在国内常见的基本信息学奥赛教材中也均未提及，因此该算法的知名度与被掌握度都不如Dijkstra算法。事实上，有多种形式的Bellman-Ford算法的优化实现。这些优化实现在时间效率上得到相当提升，例如近一两年被热捧的SPFA（Shortest-Path Faster Algoithm 更快的最短路径算法）算法的时间效率甚至由于Dijkstra算法，因此成为信息学奥赛选手经常讨论的话题。然而，限于资料匮乏，有关Bellman-Ford算法的诸多问题常常困扰奥赛选手。如：该算法值得掌握么？怎样用编程语言具体实现？有哪些优化？与SPFA算法有关系么？本文试图对Bellman-Ford算法做一个比较全面的介绍。给出几种实现程序，从理论和实测两方面分析他们的时间复杂度，供大家在备战省选和后续的noi时参考。

Bellman-Ford算法思想

Bellman-Ford算法能在更普遍的情况下（存在负权边）解决单源点最短路径问题。对于给定的带权（有向或无向）图 G=（V,E），其源点为s，加权函数 w是 边集 E 的映射。对图G运行Bellman-Ford算法的结果是一个布尔值，表明图中是否存在着一个从源点s可达的负权回路。若不存在这样的回路，算法将给出从源点s到 图G的任意顶点v的最短路径d[v]。

Bellman-Ford算法流程分为三个阶段：

（1）    初始化：将除源点外的所有顶点的最短距离估计值 d[v] ←+∞, d[s] ←0;

（2）    迭代求解：反复对边集E中的每条边进行松弛操作，使得顶点集V中的每个顶点v的最短距离估计值逐步逼近其最短距离；（运行|v|-1次）

（3）    检验负权回路：判断边集E中的每一条边的两个端点是否收敛。如果存在未收敛的顶点，则算法返回false，表明问题无解；否则算法返回true，并且从源点可达的顶点v的最短距离保存在 d[v]中。

算法描述如下：

Bellman-Ford(G,w,s) ：boolean   //图G ，边集 函数 w ，s为源点

1        for each vertex v ∈ V（G） do        //初始化 1阶段

2            d[v] ←+∞

3        d[s] ←0;                             //1阶段结束

4        for i=1 to |v|-1 do               //2阶段开始，双重循环。

5           for each edge（u,v） ∈E(G) do //边集数组要用到，穷举每条边。

6              If d[v]> d[u]+ w(u,v) then      //松弛判断

7                 d[v]=d[u]+w(u,v)               //松弛操作   2阶段结束

8        for each edge（u,v） ∈E(G) do

9            If d[v]> d[u]+ w(u,v) then

10            Exit false

11    Exit true

下面给出描述性证明：

   首先指出，图的任意一条最短路径既不能包含负权回路，也不会包含正权回路，因此它最多包含|v|-1条边。

   其次，从源点s可达的所有顶点如果 存在最短路径，则这些最短路径构成一个以s为根的最短路径树。Bellman-Ford算法的迭代松弛操作，实际上就是按顶点距离s的层次，逐层生成这棵最短路径树的过程。

在对每条边进行1遍松弛的时候，生成了从s出发，层次至多为1的那些树枝。也就是说，找到了与s至多有1条边相联的那些顶点的最短路径；对每条边进行第2遍松弛的时候，生成了第2层次的树枝，就是说找到了经过2条边相连的那些顶点的最短路径……。因为最短路径最多只包含|v|-1 条边，所以，只需要循环|v|-1 次。

每实施一次松弛操作，最短路径树上就会有一层顶点达到其最短距离，此后这层顶点的最短距离值就会一直保持不变，不再受后续松弛操作的影响。（但是，每次还要判断松弛，这里浪费了大量的时间，怎么优化？单纯的优化是否可行？）

如果没有负权回路，由于最短路径树的高度最多只能是|v|-1，所以最多经过|v|-1遍松弛操作后，所有从s可达的顶点必将求出最短距离。如果 d[v]仍保持 +∞，则表明从s到v不可达。

如果有负权回路，那么第 |v|-1 遍松弛操作仍然会成功，这时，负权回路上的顶点不会收敛。

例如对于上图，边上方框中的数字代表权值，顶点A,B,C之间存在负权回路。S是源点，顶点中数字表示运行Bellman-Ford算法后各点的最短距离估计值。

此时d[a]的值为1，大于d[c]+w(c,a)的值-2，由此d[a]可以松弛为-2，然后d[b]又可以松弛为-5,d[c]又可以松弛为-7.下一个周期，d[a]又可以更新为更小的值，这个过程永远不会终止。因此，在迭代求解最短路径阶段结束后，可以通过检验边集E的每条边(u,v)是否满足关系式 d[v]> d[u]+ w(u,v) 来判断是否存在负权回路。