博客园_Var Bob:^Joy;

像程序一样去学习

2011-06-09T08:19:00Z

学了好多东西也写了很多很多程序

算起来我是在初一开始认识这些的当时学习了Pascal 然后初中三年又学了一些算法

然后就可以写一写简单的程序了随后就初中毕业进了高中

如果说要开始认真学习算法和数据结构 是去年的这个时候吧

当时也是出于好奇因为有很多问题之前的学的东西远远不能解决

学习算法实现程序真的给我带来了不少东西其中有很多实在是在意料之外的

也许将来就离不开写程序了

一般的程序都得有个输入当然有的程序不需要输入

因为这些程序需要干什么写程序的人早就设定好了这种设定也可以算是一种输入吧

在不断学习新东西的人好比就是不断地读取输入流的程序

对一个好的程序来说应该能够不断的读取输入流并存储处理

而对于一个需要学习的人更应该能够不断的接受并经由自己的大脑记忆思考

接受记忆思考 无疑是一直被人们所长期关注的过程

然而还有一项更重要的内容却被忽视了而被忽视的这一点确是最最最重要的

难道一个程序光有输入光能完成数据的处理完整了么

没有输出不算程序

对于一个程序来说显然地输出无疑是必要的

这一点显然到经常被人忽略但是确是实实在在存在在任何一段程序之中

对于一个人来说学习了理解了就应该去传播自己的思想去和他人交流

这一点也经常被人忽略却不是因为过于显然所以有很多人不善于传播不善于交流

人作为有智慧有思想的生物学习可以说是最为重要的技能人因为能够学习而胜于其他生命

不过能够学习和善于学习还是有很大差别的

如果人不去传播自己的思想不去和其他人交流

那每个人都只能被迫从最原始的学习阶段开始每个人都得做很多重复的劳动

从整个人类社会来看效率无疑就十分低下

倘若每个人对自己的思想加以整理并传播人与人之间就有一个良好的互动思想就能共享

这好比是单纯搜索和记忆化搜索效率差别往往是指数级别的

将自己的想法传播出去主动和别人交流

首先会得到很多回应这会是一个完善自我思想的契机

其次会让更多人得到更有益的信息其他人学习也会有一个参考

从整体看这样就能高效形成科学的理论体系 自然能推动人类社会的发展

传播交流能使得能够学习转化为善于学习

当我发现这一点的时候创建了这个blog

本文链接

再解树形数据结构(二)

2011-06-04T11:35:00Z

{

以前在这里介绍过延迟标记的手法

http://www.cnblogs.com/Booble/archive/2010/10/11/1847793.html

阅读这本文之前请先阅读上面一段尤其是对Poj3468的解决

线段树作为一种常用的数据结构通常会被要求支持更复杂的修改

因此就产生了延迟标记来保证线段树的复杂度

这里通过几个简单应用延迟标记的例子更深入的介绍延迟标记

}

========================================================

一.标记问题引例

先看一个例子 HDU3397 这是一个比较水但是比较繁琐的标记题

http://acm.hdu.edu.cn/showproblem.php?pid=3397

其实不需要对线段树标记有什么理解就可以做

但是需要一定的经验即对线段树的标记有个朦胧的印象

不过这个通过这个问题恰好可以印证线段树标记的本质和一些应用的条件

题目意思相当赤果果是一个典型的数据结构维护序列的问题

要求支持如下询问和操作:

-----------------------------------------------------------------------

Change operations:
0 a b change all characters into '0's in [a , b]
1 a b change all characters into '1's in [a , b]
2 a b change all '0's into '1's and change all '1's into '0's in [a, b]
Output operations:
3 a b output the number of '1's in [a, b]
4 a b output the length of the longest continuous '1' string in [a , b]

其中:

0 1 是比较经典的覆盖类操作

2 是一个取反操作

3 是询问区间中1的个数

4 是询问区间中最长的连续的1的长度

-----------------------------------------------------------------------

首先考虑答案域和答案域的附加域

其中3的答案域是一个部分和类型的域单独一个域就可以满足递推结构

即记录当前节点的区间中有多少个1即可不妨记为 SumOne

然后可以从儿子推出父亲的这个域

SumOne[fa]=SumOne[lson]+SumOne[rson]

而4的答案域是一个最大子段和类型的域单独一个答案域还不满足最优子结构

我们还要记录从左端开始和从右端开始的最长连续的1的个数

答案域记为 OptOne 左端记为 LOptOne 右端记为 ROptOne

其中后面两个域就是答案的附加域

这时则从儿子域同样可以推出父亲的域

OptOne[fa]=Max{ OptOne[lson] , OptOne[rson] , ROptOne[lson]+LOptOne[rson] }

LOptOne[fa]=Max{ LOptOne[lson] , SumOne[lson]+LOptOne[rson]|SumOne[lson]=Length(lson) }

ROptOne[fa]=Max{ ROptOne[lson] , SumOne[rson]+ROptOne[lson]|SumOne[rson]=Length(rson) }

接下来考虑标记域

先是控制覆盖操作的覆盖标记域 记为Cover

很显然覆盖标记域应该是一个三值变量 不妨用一个整型变量

-1 代表当前区间不执行覆盖操作

0 代表当前去见执行覆盖为0的操作

+1代表当前去见执行覆盖为1的操作

执行覆盖标记域时可以很方便地直接得到当前节点的各个答案域

不过要利用一下当前节点的区间长度 *1

然后是控制取反操作的取反标记域 记为Inverse

这显然是一个 二值的布尔变量 真代表区间要取反假则代表区间不需要取反

当我们考虑到取反操作时会发现如果一个区间执行了取反标记

那么原来所有答案域都会流失变成相应的关于0的信息而我们就失去了需要的答案域

不过相应的所有关于0的信息又都会变成1的信息所以我们为了保证标记执行之后答案域还能延续

所以还要记录4个与上面关于1的域一致的答案附加域

分别是SumZero OptZero LOptZero ROptZero 递推方程也一致

当执行取反标记的时候就会交换这两组域也能直接得到答案域 *2

不过有过解决这类双标记问题经验的都知道要考虑一个“标记顺序”

我们总是这样设计标记域保证任意时刻都至多只有一个标记域有效

这样就把双标记问题转化为单个标记的问题

下面要考虑标记下传的问题并且在标记下传的时候能够保证单个标记域有效的性质

假设所有节点现在都满足单个标记有效那么如果我们能够在下传之后能仍然有这个性质

就能很完美的解决这个问题下面分类讨论这个问题

如果父亲节点是Cover有效

那么无论儿子是Cover域还是Inverse域有效

都可以将儿子的标记清空然后让儿子的Cover域修改为父亲的Cover域

如果父亲节点是Inverse域有效

那么如果儿子是Cover域有效则把Cover域取反 0变成1 1变成0

而如果是儿子的Inverse域有效则把Inverse域取反 *3

这样就可以将一个双标记的问题转化为一个单标记的问题

再应用上面利用标记域修改答案域的思路就可以完成清空标记并下传的操作了

最后还要考虑一点才能将这个线段树最终实现好

由于线段树是将任意一个查询区间分解为不超过LogN个子区间

而这些子区间都能直接得到答案域所以还要由LogN个答案域得到最终查询区间的答案

这个问题其实很简单由于答案域满足最优子结构 只要依次把答案域从左到右一个一个合并即可

这样就可以得到最终的查询区间的答案域

至此我们已经得到了这个很典型的问题的一个不错的解法

下面给出代码

const maxn=200000;
var dat:array[1..maxn]of longint;
sl,ml,sr,mr,s,m,l,r,ls,rs,c,n:array[1..maxn*2]of longint;
d:array[1..maxn*2]of boolean;
tt,rec,last,p,q,i,ch,x,y:longint;
function max(a,b:longint):longint;
begin
if a>b then max:=a else max:=b;
end;
function swap(var a,b:longint):longint;
var temp:longint;
begin
temp:=a; a:=b; b:=temp;
end;
procedure clean(x:longint);
begin
if c[x]>=0
then begin
n[x]:=(r[x]-l[x])*c[x];
ml[x]:=n[x]; mr[x]:=n[x]; m[x]:=n[x];
s[x]:=r[x]-l[x]-n[x];
sl[x]:=s[x]; sr[x]:=s[x];
if ls[x]<>0
then begin
c[ls[x]]:=c[x]; c[rs[x]]:=c[x];
end;
end
else if d[x]
then begin
n[x]:=r[x]-l[x]-n[x];
swap(sl[x],ml[x]); swap(sr[x],mr[x]); swap(s[x],m[x]);
if ls[x]<>0
then begin
if c[ls[x]]>=0
then c[ls[x]]:=1-c[ls[x]]
else d[ls[x]]:=not d[ls[x]];
if c[rs[x]]>=0
then c[rs[x]]:=1-c[rs[x]]
else d[rs[x]]:=not d[rs[x]];
end;
end;
c[x]:=-1; d[x]:=false;
end;
procedure update(x:longint);
var templ,tempr:longint;
begin
clean(ls[x]); clean(rs[x]);
n[x]:=n[ls[x]]+n[rs[x]]; templ:=r[ls[x]]-l[ls[x]]; tempr:=r[rs[x]]-l[rs[x]];
if ml[ls[x]]=templ then ml[x]:=ml[ls[x]]+ml[rs[x]] else ml[x]:=ml[ls[x]];
if mr[rs[x]]=tempr then mr[x]:=mr[rs[x]]+mr[ls[x]] else mr[x]:=mr[rs[x]];
if sl[ls[x]]=templ then sl[x]:=sl[ls[x]]+sl[rs[x]] else sl[x]:=sl[ls[x]];
if sr[rs[x]]=tempr then sr[x]:=sr[rs[x]]+sr[ls[x]] else
sr[x]:=sr[rs[x]];
m[x]:=max(max(m[ls[x]],m[rs[x]]),mr[ls[x]]+ml[rs[x]]);
s[x]:=max(max(s[ls[x]],s[rs[x]]),sr[ls[x]]+sl[rs[x]]);
end;
procedure build(a,b:longint);
var mid,x:longint;
begin
inc(tt); x:=tt;
l[x]:=a; r[x]:=b;
c[x]:=-1; d[x]:=false;
if b-a=1
then begin
n[x]:=dat[b]; s[x]:=1-n[x];
ml[x]:=n[x]; mr[x]:=n[x]; m[x]:=n[x];
sl[x]:=s[x]; sr[x]:=s[x];
exit end;
mid:=(a+b)>>1;
ls[x]:=tt+1; build(a,mid);
rs[x]:=tt+1; build(mid,b);
update(x);
end;
procedure change(x,a,b,cx:longint);
var mid:longint;
begin
clean(x);
if (a<=l[x])and(r[x]<=b)
then c[x]:=cx
else begin
mid:=(l[x]+r[x])>>1;
if a<mid then change(ls[x],a,b,cx);
if b>mid then change(rs[x],a,b,cx);
update(x);
end;
end;
procedure negate(x,a,b:longint);
var mid:longint;
begin
clean(x);
if (a<=l[x])and(r[x]<=b)
then if c[x]>=0 then c[x]:=1-c[x] else d[x]:=not d[x]
else begin
mid:=(l[x]+r[x])>>1;
if a<mid then negate(ls[x],a,b);
if b>mid then negate(rs[x],a,b);
update(x);
end;
end;
function query(x,a,b:longint):longint;
var mid:longint;
begin
clean(x);
if (a<=l[x])and(r[x]<=b)
then query:=n[x]
else begin
mid:=(l[x]+r[x])>>1; query:=0;
if a<mid then query:=query+query(ls[x],a,b);
if b>mid then query:=query+query(rs[x],a,b);
end;
end;
procedure answer(x,a,b:longint);
var mid:longint;
begin
clean(x);
if (a<=l[x])and(r[x]<=b)
then begin
rec:=max(rec,max(m[x],last+ml[x]));
if mr[x]<>r[x]-l[x] then last:=mr[x] else last:=last+mr[x];
end
else begin
mid:=(l[x]+r[x])>>1;
if a<mid then answer(ls[x],a,b);
if b>mid then answer(rs[x],a,b);
end;
end;
begin
assign(input,'GSS0.in'); reset(input);
assign(output,'GSS0.out'); rewrite(output);
readln(p,q);
for i:=1 to p do
read(dat[i]);
build(0,p);
for i:=1 to q do
begin
readln(ch,x,y);
case ch of
0:change(1,x,y+1,0);
1:change(1,x,y+1,1);
2:negate(1,x,y+1);
3:writeln(query(1,x,y+1));
4:begin last:=0; rec:=0; answer(1,x,y+1); writeln(rec); end;
end;
end;
close(input); close(output);
end.

========================================================

二.标记的本质与应用条件

虽然解决了这一个问题但是这个问题的手法却不是很通用

首先我们是直接根据两个操作得到了直接相关两个标记域在很多问题中标记域通常是自己设计的

其次这是一个双标记的问题我们却把双标记通过处理转化为单标记

实际上很多双标记甚至是多标记问题是不能这样处理的

下面我们还是通过这个例子分析线段树标记的本质和应用条件

首先应用标记的初衷是为了不要对修改区间内的所有线段树节点修改

通过打一个标记的方法来保证每次只有LogN个节点被操作到

而剩余实际上要被执行修改的其他节点会在被访问的时候逐级传递祖先的标记从而可以得到正确的答案域

由于最终打到这个节点的标记是很多祖先的很多标记的综合

所以标记的本质就是概括在这个节点的上一个答案域之后来不及直接执行的操作序列的一个变量或几个变量

注意到上面蓝色粗体字这记录了我们应用标记的几个关键点

*1*2:清空标记 *3:下传标记

由此我们得到应用标记的两个必要条件

1.标记域要能够和答案域快速合并这样保证了清空标记域并得到新的答案域的时间复杂度

2.标记域要能够和标记域快速合并这样保证了下传标记域得到新的儿子标记域的时间复杂度

有了样几个结论我们就能很好的鉴别设计出的标记域是否能够解决问题了

当然分析得到一个适用的标记域并不是一件简单的事

除了一点灵感之外所以还要一个比较好的方法我通常是分类讨论然后整理的

下面通过一个我改编的题目来介绍这个方法

========================================================

三.分类讨论的分析方法

我改编了GSS2这个问题减少了很多离线手法和建模思考

但是我添加了一个操作这使得这个问题的难度变大了不少下面是这个题目

http://www.tyvj.cn:8080/Problem_Show.asp?id=1518

题目要求支持2个询问和2个操作

-----------------------------------------------------------------

Q X Y:询问从X到Y的区间的最大值
A X Y:询问从X到Y的区间的历史最大值
P X Y Z:从X到Y的区间内所有数增加Z
C X Y Z:X到Y的区间内所有数变为Z

-----------------------------------------------------------------

我们逐步分析这个问题注意到问题含有大量部分分

所以不妨根据数据范围提示来慢慢分析这样不但可以分块得到不同的数据也可以帮助得到最终的解

其中前面4个数据是很基本的方法略去不讨论

============

如果只包含C操作 Q询问和A询问我们容易想到给每个节点维护两个标记域Cx和C

C表示当前要把节点覆盖成C Cx表示当前这个操作序列中曾经最大的C值

1.标记域与答案域合并

Ms*=Max{Ms',Cx}

Mc*=C|C<>-oo

2.标记域和标记域合并

Cx*=Max{Cx',Cx}

C*=C|C<>-oo

这样又可以得到24分此时期望分数达到44分

不过代码量要加上前两个方面

============

而如果只包含P操作 Q询问和A询问

这只是GSS2问题的化简做过GSS2的选手应该能很快解决记录两个标记域Ds和Dc

D为把节点加上差值D Ds表示当前操作序列中曾经最大的D值

1.标记域与答案域合并

Ms*=Max{Ms',Mc'+Ds}

Mc*=Mc'+D

2.标记域和标记域合并

Ds*=Max{Ds',Dc'+Ds}

Dc*=Dc'+Dc

这样又可以得到26分此时期望分数达到70分可以只把前面24分的部分的标记部分修改

融入这一部分的标记不过分开处理代码量不会加大很多

============

最后我们分析所有操作俱全的情况

14分部分的思路 诱使我们思考设置C和Cx先处理

如果C和Cx不存在再处理Ds和Dc标记不过很快会发现Ds域是必须维护的

即使有C和Cx域 Ds仍然不会像Dc域一样被清除

我们给每个节点加上4个标记域

Ds表示历史上曾经的最大差量 Dc表示现在的差量如果存在C和Cx 则Dc域不存在

C表示节点被覆盖为C Cx表示历史上最大的覆盖值如果不存在C Cx也不存在

则存在两种标记情况 Ds Cx C并存 或者 Ds Dc并存 分别记为A情况和B情况

1.标记域与答案域合并

Ms*=Max{Ms',Mc'+Ds,Cx}

Mc*=Mc'+Dc|C=-oo 或 Mc=C|C<>-oo

2.标记域和标记域合并

A情况并上B情况变成A情况

Ds*=Ds' ; Cx*=Max{C'+Ds,Cx'} ; C*=C'+Dc

B情况并上A情况变成A情况

Ds*=Max{Ds',Dc'+Ds} ; Cx*=Cx ; C*=C ; DC*=0

A情况并上A情况变成A情况

Ds*=Ds' ; Cx*=Max{Cx',C'+Ds,Cx} ; C*=C

B情况并上B情况变成B情况

和GSS2的方式类似不再赘述

上面就是分类讨论的典型过程很多标记题通过一些经验然后严密的论证就能得到很好的解决

以上4类情况没有配图不过完全可以自己画出来主要的递推式都给出了

其实思考线段树标记和思考DP的方程很类似

具体代码可以化简不用明确分4类总代码长度为180行

本文链接

再解树形数据结构(一)

2011-06-03T06:26:00Z

{

最近做了很多有意思的数据结构问题

在这里小结一下顺便介绍一下数据结构问题的基本解决方法

由于以前零零散散介绍过几部分数据结构

所以标题就是再解数据结构了

由于碰到的问题基本都和树形结构脱不了干系

这几段文章都是围绕树形数据结构的

}

=================吐槽的分割线====================

在这神奇的世界上有个神奇的地方

叫做Online Judge 简称OJ 是ACMER OIER打发寂寞空虚的地方

在众多OJ中有两个神奇的OJ: SPOJ和SGU

SGU是一个卡内存的地方很多题目的内存少的可怜

而SPOJ是一个卡常数的地方很多很多理论复杂度很好的程序经常被判定为TLE

原因就是测评机的速度不是一般的速度

据神牛考证以前可以AC的题现在在SPOJ都面临AC不能的境遇

可见SPOJ测评机的速度不仅慢而且是一种动态的慢越来越慢

一句老话说得好黑发不知勤学早白首方悔读书迟啊

用在神奇的SPOJ上真是一点也不为过

不过和SGU相比 SPOJ倒是不卡内存的

几百M的内存任你开通常SPOJ上不会出现MLE这个错误

取而代之的是TLE 因为开那么多内存

再加上SPOJ测评机的神速足以让测评机判定为TLE了

与国外众多OJ相比中国本土的OJ相对而言很和谐

测评机速度快网页也快社会主义国家的OJ果然不一样

=================吐槽的分割线====================

由于SPOJ的神奇......

在SPOJ上过一些有意思的题也成了神奇的事情

本来很有意思的问题解决的也比较顺利应该算是一件很爽的事

但是SPOJ却常常卡一个正确程序的常数

辛苦了很久换来一个黄色的TLE 实在不是什么好玩的事情

但是值得肯定的是 SPOJ上确实有很多值得一做的题

所以这里介绍一下不被神奇的SPOJ囧到的一个技巧...尽量使用指针!

=============================================

一.指针与数组

一般的树形数据结构都离开不了指针

In computer science, a pointer is a programming language data type whose value refers directly to (or "points to") another value stored elsewhere in the computer memory using its address.

(From: http://en.wikipedia.org/wiki/Pointer_%28computing%29 )

指针变量存储一个内存地址

非常形象地指针变量的作用就好比一个导引方向的指针

利用指针我们可以非常自由地组织内存中的数据

这无疑给我们实现各种数据结构都提供了方便

而数组则是另一种常用的数据类型

In computer science, an array data structure or simply array is a data structure consisting of a collection of elements (values or variables), each identified by at least one index. An array is stored so that the position of each element can be computed from its index tuple by a mathematical formula.

(From: http://en.wikipedia.org/wiki/Array_data_structure )

用数组存储一段数据可以让我们方便地检索第K个数据是什么

另外作为一种几乎所有语言都支持的基本数据类型利用数组的程序也可以很方便地调试

=============================================

二.利用数组和指针实现数据结构

以二叉排序树为例介绍两种基本的实现方式

一种就是最最和谐的指针实现方式通常教材上都是介绍的这种实现

一个二叉排序树的节点通常有三个域即左儿子右儿子键值

而且保证左子树所有节点的键值都小于根节点的键值右子树所有节点的键值都大于根节点的键值

typeBST=^BSTnode;
BSTnode=record
l,r:BST;
n:longint;
end;
varroot:BST;
begin
new(root);
root^.l:=nil; root^.r:=nil;
root^.n:=1;
end.

由于指针变量是一个内存地址所以对于我们调试程序增加了难度

正是由于指针变量的调试不方便在对某些数据结构不熟悉的情况下

我们可以使用一种折中的办法 数组模拟指针

注意到 数组下标可以和内存地址等价我们可以用数组来模拟指针操作

所以上面的代码可以改写成这样

typeBSTnode=record
l,r:longint;
n:longint;
end;
varpool:array[1..100]of BSTnode;
tt:longint;
begin
tt:=0;
inc(tt); root:=tt;
pool[root].l:=0; pool[root].r:=0;
pool[root].n:=1;
end.

为了方便书写我们通常不是用record类型来定义

而是写成下面的样子这样虽然结构松散但是更加方便

varl,r,n:array[1..100]of longint;
begin
tt:=0;
inc(tt); root:=tt;
l[root]:=0; r[root]:=0;
n[root]:=1;
end;

=============================================

三.比较快的写法

上面两种写法其实速度都不是很快下面介绍一种我常用的速度还可以的写法

首先有一个结论 引用一次指针变量比引用一次数组变量要快

这是因为: 数组在内存中是连续的一段通常计算机存储数组都是存储一个数组头部地址

然后引用数组元素是把下标作为偏移量用数组头部地址加偏移量得到元素地址

所以引用一次数组元素比直接引用指针变量 多一次加法

加法是一种不可忽略的基本运算尤其是在多次调用的时候

而实现数据结构通常都会多次的引用节点信息由此带来的就是多出上百万甚至是上千万级别的加法

所以我们要尽量使用指针来代替数组模拟这样可以使程序速度得到明显的提高

然而使用指针也有瓶颈就是每次给节点分配地址的操作New函数

借鉴上面数组模拟指针的实现可以得到一个比较好的解决方法

分配数组的空间是分配一段连续内存通常要比动态分配很多节点要快

只要预先开好一个内存池然后利用尾指针++ 就可以不断得到新的节点

而且速度非常快这样就可以得到一个比较完美的数据结构通用实现方法

基本代码如下:

typeBST=^BSTnode
BSTnode=record
l,r:BST;
n:longint;
end;
varBSTpool:array[0..100]of BSTnode;
tt,root,null:BST;
begin
null:=@BSTpool[0];
null^.l:=null; null^.r:=null;
tt:=null;

inc(tt); root:=tt;
root^.l:=null; root^.r:=null;
root^.n:=1;
end.

其中null是一个哨兵节点 可以减少对于空指针的特殊判断

@就是取变量地址的操作以内存池的第一个节点作为哨兵节点

初始尾指针就是内存池的第一个节点

=============================================

四.指针与数组模拟指针的实践测试

为了更有力地证明指针和数组模拟指针的效率差距

我作了实际测试测试代码是两棵写法一致但是分别使用了指针和数组模拟指针的平衡树

测试结果如下:

其中输入流由程序内部伪随机函数提供输出流省略

所以测试直接针对两种不同实现的平衡二叉树

实测中数组模拟指针实现的平衡二叉树比指针实现的速度要慢1/2左右

作为这一部分的序篇主要介绍一些常数优化的方法

之后介绍一些有意思的数据结构问题

本文链接

[Poj 2187]计算几何之凸包(三) {旋转卡壳初步}

2011-04-03T14:19:00Z

{

上一节介绍了凸包的高效算法

和一个最远点对的应用

这一段将更好的解决最远点对问题

}

(若不做特殊说明下文讨论的问题均是在欧氏空间

若不做特殊说明下文中距离均是指空间中欧氏距离)

==============================

一.简单枚举算法的不足

上一次介绍了一个基本的求平面最远点对的算法

即先求点集的凸包然后枚举凸包上的点来求最远点集

这是利用了凸包上的点相比点集中的点一般是很少的平均情况很好并且我们也能AC这个问题

但是这是有局限性的当凸包上的点达到O(N)的级别时凸包的优化作用就不存在了

不过我们还要考虑到凸包还起了对凸包上点集排序的作用

凸包有很多的优美的性质我们可以加以利用以得到更加高效的算法

旋转卡壳算法就是利用凸包特性的一类解决问题的方法

==============================

二.旋转卡壳算法

旋转卡(qiǎ)壳算法(Rotating Calipers Algorithm):

是解决一些与凸包有关问题的有效算法就像一对卡壳卡住凸包旋转而得名

Every time one blade of the caliper lies flat against an edge of the polygon, it forms an antipodal pair with the point or edge touching the opposite blade. It turns out that the complete "rotation" of the caliper around the polygon detects all antipodal pairs and may be carried out in O(n) time.

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

(图片来自:http://cgm.cs.mcgill.ca/~orm/rotcal.html)

被一对卡壳正好卡住的对应点对称为对踵点(Antipodal point)

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

可以证明对踵点的个数不超过3N/2个也就是说对踵点的个数是O(N)的

对踵点的个数也是我们下面解决问题时间复杂度的保证

上第一个图是卡壳的一般情况卡住两点图二是卡住一条边和一个点

由于实现中卡住两点的情况不好处理我们通常关注第二种情况

在第二种情况中我们可以看到 一个对踵点和对应边之间的距离比其他点要大

也就是一个对踵点和对应边所形成的三角形是最大的下面我们会据此得到对踵点的简化求法

看一下官方的伪代码:

当时我看完了就一个字长... 我最讨厌冗长的程序了...

begin
p0:=pn;
q:=NEXT[p];
while (Area(p,NEXT[p],NEXT[q]) > Area(p,NEXT[p],q)) do
q:=NEXT[q];
q0:=q;
while (q != p0) do
begin
p:=NEXT[p];
Print(p,q);
while (Area(p,NEXT[p],NEXT[q]) > Area(p,NEXT[p],q) do
begin
q:=NEXT[q];
if ((p,q) != (q0,p0)) then Print(p,q)
else return
end;
if (Area(p,NEXT[p],NEXT[q]) = Area(p,NEXT[p],q)) then
if ((p,q) != (q0,p0)) then Print(p,NEXT[q])
else Print(NEXT[p],q)
end
end.

几经折腾终于找到了一个不错的实现:http://www.cnblogs.com/DreamUp/archive/2010/09/16/1828131.html

不过不是很好理解这里作一下说明

1 ch[m+1]:=ch[1]; j:=2;
2 for i:=1 to m do
3 begin
4 while cross(ch[i],ch[j],ch[i+1])<cross(ch[i],ch[j+1],ch[i+1]) do
5 begin inc(j); if j>m then j:=1; end;
6 writeln(ch[i].x,' ',ch[i].y,' ',ch[j].x,' ',ch[j].y);
7 end;

上面就是旋转卡壳寻找对踵点的过程

其中叉积函数Cross(A,B,C:Point):Real 返回AB到AC的二维定义下的叉积

这里主要用到了叉积求三角形面积的功能

我们对于一条对应边<CH i,CH Next[i]>求出距离这条边最远的点CH j

则由上面第二种情况可知 CH i 和 CH j 为一对对踵点这样让 CH i 绕行凸包一周即可得到所有的对踵点

下面面这个图由于本人的gif图制作水平拙劣所以不好看

需要的可以下载几何画板察看原版GSP文件点击这里下载GSP文件

接下来考虑如何得到距离每条对应边的的最远点呢?

稍加分析我们可以发现凸包上的点依次与对应边产生的距离成单峰函数

具体证明可以从凸包定义入手用反证法解决

这样我们再找到一个点 使下一个点的距离小于当前的点时就可以停止了

而且随着对应边的旋转最远点也只会顺着这个方向旋转我们可以从上一次的对踵点开始继续寻找这一次的

由于内层while循环的执行次数取决于j增加次数 j最多增加O(N)次

所以求出所有对踵点的时间复杂度为O(N)

还有有两点需要注意:

1.上面这段代码及代码的分析都是需要凸包上没有三点共线的

2.Next[i] 不需要手动求在原代码中有很好的处理

最后指出网上很多文章的一个错误一个点的对踵点并不是离这个点最远的点!

这样子的点对是根本不满足对踵点的性质的即最为重要的单峰分布性质

下图是一个反例:

==============================

三.旋转卡壳算法的简单应用

至此我们终于可以更高效的解决平面最远点对问题了

有一个很重要的结论是 最远点对必然属于对踵点对集合

那么我们先求出凸包然后求出对踵点对集合然后选出距离最大的即可

用这个算法可以47ms AC这个问题算上凸包的时间总复杂度为O(Nlog2N)

代码如下:

{$inline on}
{$optimization on}
const maxn=50000;
type point=record x,y:longint; end;
var n,i,x,m,ans,j:longint;
ch,p:array[1..maxn+1]of point;
s:array[1..maxn]of longint;
function cross(a,b,c:point):longint; inline;
begin
cross:=(b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x);
end;
function dist(a,b:point):longint; inline;
begin
dist:=sqr(a.x-b.x)+sqr(a.y-b.y);
end;
function cmp(a,b:point):boolean; inline;
begin
cmp:=(a.x<b.x)or(a.x=b.x)and(a.y<b.y);
end;
function max(a,b:longint):longint;
begin
if a>b then max:=a else max:=b;
end;
procedure swap(a,b:longint); inline;
var x:point;
begin
x:=p[a]; p[a]:=p[b]; p[b]:=x;
end;
procedure hull(l,r:longint; a,b:point);
var x,i,j,k:longint;
y:point;
begin
x:=l; y:=p[l];
for k:=l to r do
if (s[x]<s[k])or(s[x]=s[k])and(cmp(y,p[k]))
then begin x:=k; y:=p[k]; end;
i:=l-1; j:=r+1;
for k:=l to r do
begin
inc(i); s[i]:=cross(p[k],a,y);
if s[i]>0 then swap(i,k) else dec(i);
end;
for k:=r downto l do
begin
dec(j); s[j]:=cross(p[k],y,b);
if s[j]>0 then swap(j,k) else inc(j);
end;
if l<=i then hull(l,i,a,y);
inc(m); ch[m]:=y;
if j<=r then hull(j,r,y,b);
end;
begin
assign(input,'Maxd.in'); reset(input);
assign(output,'Maxd.out'); rewrite(output);
readln(n);
for i:=1 to n do
begin
readln(p[i].x,p[i].y);
if (x=0)or cmp(p[i],p[x]) then x:=i;
end;
swap(1,x);
m:=1; ch[1]:=p[1]; hull(2,n,p[1],p[1]);
ch[m+1]:=ch[1]; j:=2; ans:=0;
for i:=1 to m do
begin
while cross(ch[i],ch[j],ch[i+1])<cross(ch[i],ch[j+1],ch[i+1]) do
begin inc(j); if j>m then j:=1; end;
ans:=max(ans,dist(ch[i],ch[j]));
end;
writeln(ans);
close(input); close(output);
end.

下一节介绍旋转卡壳的更多应用

之后开始介绍一点3D凸包

本文链接

[Poj 2187] 计算几何之凸包(二) {更高效的算法}

2011-03-10T13:22:00Z

{

承上一节

继续介绍点集的凸包

(下文中所有凸包若不做特殊说明均指点集的凸包)

这一节介绍相比更高效的算法

}

====================================================================

一.卷包裹算法(Gift Wrapping Algorithm)的特性

前面提到过卷包裹算法的复杂度问题

由于卷包裹算法是两重循环实现的因此很好分析它的复杂度

1 while true do
2 begin
3 k:=0;
4 inc(m); ch[m]:=j;
5 for i:=1 to n do
6 if (i<>j)and((k=0)or
7 cmp(p[j],p[k],p[i]))
8 then k:=i;
9 if k=temp then break;
10 j:=k;
11 end;

内部循环N次外循环的次数决定于凸包上的点数H

所以卷包裹算法复杂度为O(HN) 这个复杂度很有特点

考虑一个随机点集的凸包上的点数往往很少 但是最坏情况下是O(N)级别的

比如所有的点都在一个圆上的时候

这就决定了卷包裹算法很适合随机的点集 但是如果是刻意构造的数据或是比较特殊的数据

就会达到O(N^2)的最坏复杂度 这是我们不愿意看到的

下面介绍最坏情况下复杂度更好的Graham扫描算法(Graham Scan Algorithm)

====================================================================

二.Graham扫描算法(Graham Scan Algorithm)

Graham扫描算法维护一个凸壳通过不断在凸壳中加入新的点和去除影响凸性的点最后形成凸包

The Graham scan is a method of computing the convex hull of a finite set of points in the plane with time complexity O(n log n). It is named after Ronald Graham, who published the original algorithm in 1972.[1] The algorithm finds all vertices of the convex hull ordered along its boundary.

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

算法主体由两部分组成先是排序后是扫描分块讲解一下

----------------------------------------------------------------------------------------------------------

1.点集排序

为了得到加入新点的顺序 Graham扫描法的第一步是对点集排序

排序是对杂乱的点集进行了梳理这也是这种算法能够得到更高效率的根本原因

排序的方法也有两种 极角坐标排序(极角序) 和 直角坐标排序(水平序)

前者好理解一些但是在实现的时候后者更方便

先说极角序为了极角排序我们先得得到一个参考点

一般的我们取最左边(横坐标最小)的点作为参考点 如果有多个这样的点就取最下面的(纵坐标最小)

看这样一个例子这是一个任意给出的平面点集:

参考点的定义:在横坐标最小的情况下取纵坐标最小的点

所以所有的点只能在这个黄色的半平面中而且正上方为闭(可取得) 正下方为开(不可取)

这就决定了参考点的性质:点集中任意两点和参考点所成的到角为锐角

这样我们取得参考点然后再考虑极角排序

极角排序以参考点为极角坐标系原点 各个点的极角为关键字

由于上面我们得到的参考点的性质我们可以设所有点的极角均在(-90,90]之间

排序完成后应该是这样的:

比较极角我们仍然可以利用向量的叉积

叉积在这里已经介绍了 http://www.cnblogs.com/Booble/archive/2011/02/28/1967179.html

同样由于参考点的性质所有向量之间的到角都是在180度以内 不会产生错误

----------------------------------------------------------------------------------------------------------

2.Graham的栈扫描

Graham的扫描是一个很优美的过程用到的数据结构也很简单仅仅是一个栈而已

核心的思想是按照排好的序依次加入新点得到新的边

如果和上一条边成左转关系就压栈继续 如果右转就弹栈直到和栈顶两点的边成左转关系压栈继续

实现的时候我们不用存边只需要含顺序在栈里存点相邻两点就是一条边

由于我们时时刻刻都保证栈内是一个凸壳 所以最后扫描完毕就得到了一个凸包

下面还是继续上面的那个样例演示一下栈扫描的过程

这样Graham扫描算法基本完成

复杂度是排序O(Nlog2N) 扫描O(N) {每个点仅仅出入栈一次}

合起来是一个O(Nlog2N)的算法很优秀

----------------------------------------------------------------------------------------------------------

3.双重共线点难题

和卷包裹算法一样我们同样还要考虑共线点问题

而且Graham扫描算法的共线问题更复杂 所以需要仔细考虑

i).排序时的共线问题

如果极角相同我们应该怎么定先后呢?

我们得加上第二关键字距离 比如极角相同距离参考点近的先

不过不管是近的先还是远的先开始和结束的两条边总是矛盾的

我们必须对其中一条特殊处理除了结束边外距离近的先结束边上距离远的先

这就是为什么极角排序不是很好实现的原因了下面会介绍一下水平序

ii).扫描时的共线问题

这个和卷包裹算法的处理放法如出一辙

如果需要保留共线的点就在到角相同时取距离最近的

如果仅仅需要凸包极点就取距离最远的

----------------------------------------------------------------------------------------------------------

4.直角坐标排序(水平序)

直角坐标排序方法没有了极角排序的不足

以横坐标为第一关键字纵坐标为第二关键字排序点集

然后从第一个点开始分别利用Graham扫描生成左链和右链

需要注意以下两点:

i).左链和右链的旋转方向是相反的

ii).注意生成第二条链要忽略第一条链上的点

由于水平序的CMP函数比较简单代码也更短

还有一件有意思的事 Graham扫描算法是1972年提出的卷包裹算法是1973年提出的

其实不奇怪 这两个算法本来也没有优劣所用的思想不同各自善于处理不同的情况

Graham扫描所用时间在点集随机时还不如卷包裹算法快

正如第一节所说卷包裹算法已经可以处理大部分情况也是一个可取的算法

实际应用中点集更趋向于均匀 而不是集中在凸包上

----------------------------------------------------------------------------------------------------------

最后给一下比较难实现的极角排序代码

{$inline on}
const zero=1e-6; maxn=100000;
type point=record x,y:extended; end;
var p,ch:array[1..maxn]of point;
i,j,n,m,temp:longint;
function sgn(x:extended):longint; inline;
begin
if abs(x)<zero then exit(0);
if x<0 then sgn:=-1 else sgn:=1;
end;
function cross(a,b,c,d:point):extended; inline;
begin
cross:=(b.x-a.x)*(d.y-c.y)-(d.x-c.x)*(b.y-a.y);
end;
function dist(a,b:point):extended; inline;
begin
dist:=sqr(a.x-b.x)+sqr(a.y-b.y);
end;
function cmp1(a,b,c:point):boolean; inline;
var temp:longint;
begin
temp:=sgn(cross(a,b,a,c));
if temp<>0 then exit(temp>0); {*B}
cmp1:=dist(a,b)<dist(a,c);
end;
function cmp2(a,b,c:point):boolean; inline;
var temp:longint;
begin
temp:=sgn(cross(a,b,b,c));
if temp<>0 then exit(temp<0); {*B}
cmp2:=dist(a,b)<dist(a,c); {*A}
end;
procedure swap(var a,b:point); inline;
var temp:point;
begin
temp:=a; a:=b; b:=temp;
end;
procedure sort(l,r:longint);
var i,j:longint;
x:point;
begin
i:=l; j:=r;
x:=p[(l+r)>>1];
repeat
while cmp1(p[1],p[i],x) do inc(i);
while cmp1(p[1],x,p[j]) do dec(j);
if not(i>j)
then begin
swap(p[i],p[j]);
inc(i); dec(j);
end;
until i>j;
if i<r then sort(i,r);
if l<j then sort(l,j);
end;
begin
assign(input,'Hull.in'); reset(input);
assign(output,'Hull2.out'); rewrite(output);
readln(n);
for i:=1 to n do
begin
readln(p[i].x,p[i].y);
if (p[i].x<p[1].x)or
(sgn(p[i].x-p[1].x)=0)and(p[i].y<p[1].y)
then swap(p[1],p[i]);
end;
sort(2,n);
while i>2 do
begin
if sgn(cross(p[1],p[i],p[1],p[i-1]))<>0
then break; dec(i);
end;
temp:=(i+n+1)>>1;
for j:=n downto temp do
swap(p[j],p[i+n-j]);
m:=1; ch[1]:=p[1];
inc(n); p[n]:=p[1];
for i:=2 to n do
begin
while m>1 do
begin
if not cmp2(ch[m-1],ch[m],p[i])
then break; dec(m);
end;
inc(m); ch[m]:=p[i];
end;
for i:=1 to m-1 do
writeln(ch[i].x:0:2,' ',ch[i].y:0:2);
close(input); close(output);
end.

*A Change Direction
*B Remove Colinear Points

====================================================================

三.快速凸包算法(Quickhull Algorithm)

对比Graham扫描算法和卷包裹算法

我们发现 Graham扫描算法在凸包上的点很密集时仍然适用

卷包裹算法在凸包上点集随机分布时是很高效的

那么有没有两个优点都具备的算法呢?

是有的! 快速凸包算法(Quickhull Algorithm)就是这样的一个算法

快速凸包算法是一个和快速排序(Quicksort Algorithm)神似的算法

尽管快速排序的最坏复杂度可以达到O(N^2)

但是有着极小的常数实现方便思路优美绝大多数情况特别高效的快速排序还是赢得了更多人的青睐

快速凸包算法也是这样尽管可以构造一个数据使之达到O(N^2)的复杂度

但这需要刻意针对程序经过分析才能做到是实际应用中根本不会碰到的情况

在点集均匀分布时快速凸包的复杂度更是达到了O(N) 是上面两种算法难以企及的

在绝大多数情况下 平均复杂度是O(Nlog2N) 也很高效

快速凸包继承了快速排序分治的思想这是一个递归的过程

------------------------------------------------------------------------------------

伪代码如下:

1 void 快速凸包(P:点集 , S:向量 /*S.p,S.q:点)*/ ){
2 /* P 在 S 左侧*/
3 选取 P 中距离 S 最远的点 Y ;
4 向量 A <- { S.p , Y } ; 向量 B <- { Y , S.q } ;
5 点集 Q <- 在 P 中且在 A 左侧的点 ;
6 点集 R <- 在 P 中且在 B 左侧的点 ; /* 划分 */
7 快速凸包 ( Q , A ) ; /* 分治 */
8 输出 (点 Y) ; /* 按中序输出保证顺序*/
9 快速凸包 ( P , B ) ; /* 分治 */
10 }

初始化就选取 最左下和最右上的点划分好 然后调用两次快速凸包函数分别求上下凸包

其中选取和划分都需要用到向量的叉乘 注意方向

另外存储点集可以用数组里的连续一段传参的时候就传左右下标

划分的时候就是给数组交换元素 使新的点集变成连续的一段

这里有一个很好的演示

http://www.cs.princeton.edu/courses/archive/spr10/cos226/demo/ah/QuickHull.html

还要补充说明一下

快速凸包在所有点都在圆周上的时候还是O(Nlog2N) 不过会比Graham扫描算法慢一些

可以说这种数据是Graham扫描法的最好情况 一遍走完就行了

构造快速凸包的最坏情况就是使划分不均等 和构造快速排序最坏情况一样

贴以下我很辛苦写出来的代码吧为了好看些还心血来潮用cpp写了...

#include <iostream>
#include <math.h>
#define maxn 100000
#define zero 1e-12
#define sgn(x) (fabs(x)<zero?0:(x>0?1:-1))
#define cross(a,b,c) ((b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x))
#define cmp(a,b) (a.x<b.x || sgn(a.x-b.x)==0 && a.y<b.y)

using namespace std;
struct point{
double x,y;
}p[maxn];
double s[maxn];

void hull(int l,int r,point a,point b){
int x=l,i=l-1,j=r+1,k;
for (k=l;k<=r;k++){
double temp=sgn(s[x]-s[k]);
if (temp<0 || temp==0 && cmp(p[x],p[k])) x=k;
}
point y=p[x];
for (k=l;k<=r;k++){
s[++i]=cross(p[k],a,y);
if (sgn(s[i])>0) swap(p[i],p[k]); else i--;
}
for (k=r;k>=l;k--){
s[--j]=cross(p[k],y,b);
if (sgn(s[j])>0) swap(p[j],p[k]); else j++;
}
if (l<=i) hull(l,i,a,y);
printf("%.4lf %.4lf\n",y.x,y.y);
if (j<=r) hull(j,r,y,b);
}

int main(){
freopen("CH2D.in","r",stdin);
freopen("CH2D1.out","w",stdout);
int n,i,x=0;
scanf("%d",&n);
for (i=1;i<=n;i++){
scanf("%lf %lf",&p[i].x,&p[i].y);
if (x==0 || cmp(p[i],p[x])) x=i;
}
swap(p[1],p[x]);
printf("%.4lf %.4lf\n",p[1].x,p[1].y);
hull(2,n,p[1],p[1]);
return 0;
}

====================================================================

四.凸包算法复杂度下界

(引自<算法艺术与信息学竞赛>)

====================================================================

五.高效算法的应用

这里有一个平面最远点对的问题可以利用凸包解决

Poj 2187 http://poj.org/problem?id=2187

由于最远点对必然在凸包上

我们先求凸包然后枚举凸包上的点不过这个复杂度最坏是O(N^2)的

不过凸包在很多情况下会改善问题的平均复杂度

凸包上的点通常很少所以这个问题也可以过

篇幅关系在下一节会介绍降低最坏复杂度的旋转卡壳算法

====================================================================

文中部分图片来源

http://westhoffswelt.de/blog/0040_quickhull_introduction_and_php_implementation.html

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

本文链接

[Poj 1459] 网络流(一) {基本概念与算法}

2011-03-04T05:37:00Z

{

凸包的内容还欠整理

先来侃侃一个月以前就想写写的网络流

本文介绍网络流 网络流的算法及其应用

这些问题没事想想还是很有意思的

}

==================================================================================

一.网络流:流&网络&割

1.网络流问题(NetWork Flow Problem):

给定指定的一个有向图,其中有两个特殊的点源S(Sources)和汇T(Sinks),每条边有指定的容量(Capacity),求满足条件的从S到T的最大流(MaxFlow).

The network flow problem considers a graph G with a set of sources S and sinks T and for which each edge has an assigned capacity (weight), and then asks to find the maximum flow that can be routed from S to T while respecting the given edge capacities.

http://mathworld.wolfram.com/NetworkFlow.html

下面给出一个通俗点的解释

(下文基本避开形式化的证明 基本都用此类描述叙述)

好比你家是汇自来水厂(有需要的同学可以把自来水厂当成银行之类以下类似)是源

然后自来水厂和你家之间修了很多条水管子接在一起水管子规格不一有的容量大有的容量小

然后问自来水厂开闸放水你家收到水的最大流量是多少

如果自来水厂停水了你家那的流量就是0 当然不是最大的流量

但是你给自来水厂交了100w美金自来水厂拼命水管里通水但是你家的流量也就那么多不变了这时就达到了最大流

-------------------------------------------------------------------------------------------------------------

2.三个基本的性质:

如果 C代表每条边的容量 F代表每条边的流量

一个显然的实事是F小于等于C 不然水管子就爆了

这就是网络流的第一条性质 容量限制(Capacity Constraints):F<x,y> ≤ C<x,y>

再考虑节点任意一个节点流入量总是等于流出的量否则就会蓄水(爆炸危险...)或者平白无故多出水(有地下水涌出?)

这是第二条性质 流量守恒(Flow Conservation):Σ F<v,x> = Σ F<x,u>

当然源和汇不用满足流量守恒我们不用去关心自来水厂的水是河里的还是江里的

(插播广告: 节约水资源人人有责!)

最后一个不是很显然的性质是斜对称性(Skew Symmetry): F<x,y> = - F<y,x>

这其实是完善的网络流理论不可缺少的就好比中学物理里用正负数来定义一维的位移一样

百米起点到百米终点的位移是100m的话那么终点到起点的位移就是-100m

同样的 x向y流了F的流 y就向x流了-F的流

-------------------------------------------------------------------------------------------------------------

3.容量网络&流量网络&残留网络:

网络就是有源汇的有向图关于什么就是指边权的含义是什么

容量网络就是关于容量的网络基本是不改变的(极少数问题需要变动)

流量网络就是关于流量的网络在求解问题的过程中

通常在不断的改变但是总是满足上述三个性质

调整到最后就是最大流网络 同时也可以得到最大流值

残留网络往往概括了容量网络和流量网络是最为常用的

残留网络=容量网络-流量网络

这个等式是始终成立的残留值当流量值为负时甚至会大于容量值

流量值为什么会为负?有正必有负,记住斜对称性!

-------------------------------------------------------------------------------------------------------------

4.割&割集:

无向图的割集(Cut Set):C[A,B]是将图G分为A和B两个点集 A和B之间的边的全集

A set of edges of a graph which, if removed (or "cut"), disconnects the graph (i.e., forms a disconnected graph).

http://mathworld.wolfram.com/CutSet.html

网络的割集:C[S,T]是将网络G分为s和t两部分点集 S属于s且T属于t 从S到T的边的全集

带权图的割(Cut)就是割集中边或者有向边的权和

Given a weighted, undirected graph G=(V,E) and a graphical partition of V into two sets A and B, the cut of G with respect to A and B is defined as cut(A,B)=sum_(i in A,j in B)W(i,j),where W(i,j) denotes the weight for the edge connecting vertices i and j. The weight of the cut is the sum of weights of edges crossing the cut.

http://mathworld.wolfram.com/Cut.html

通俗的理解一下:

割集好比是一个恐怖分子把你家和自来水厂之间的水管网络砍断了一些

然后自来水厂无论怎么放水水都只能从水管断口哗哗流走了你家就停水了

(插播广告: 节约水资源人人有责!)

割的大小应该是恐怖分子应该关心的事毕竟细管子好割一些

而最小割花的力气最小

==================================================================================

二.计算最大流的基本算法

那么怎么求出一个网络的最大流呢?

这里介绍一个最简单的算法:Edmonds-Karp算法 即最短路径增广算法 简称EK算法

EK算法基于一个基本的方法:Ford-Fulkerson方法 即增广路方法 简称FF方法

增广路方法是很多网络流算法的基础一般都在残留网络中实现

其思路是每次找出一条从源到汇的能够增加流的路径 调整流值和残留网络不断调整直到没有增广路为止

FF方法的基础是增广路定理(Augmenting Path Theorem):网络达到最大流当且仅当残留网络中没有增广路

证明略这个定理应该能够接受的吧

EK算法就是不断的找最短路找的方法就是每次找一条边数最少的增广也就是最短路径增广

这样就产生了三个问题:

-------------------------------------------------------------------------------------------------------------

1.最多要增广多少次?

可以证明最多O(VE)次增广可以达到最大流证明略

2.如何找到一条增广路?

先明确什么是增广路增广路是这样一条从s到t的路径路径上每条边残留容量都为正

把残留容量为正的边设为可行的边那么我们就可以用简单的BFS得到边数最少的增广路

3.如何增广?

BFS得到增广路之后这条增广路能够增广的流值是路径上最小残留容量边决定的

把这个最小残留容量MinCap值加到最大流值Flow上同时路径上每条边的残留容量值减去MinCap

最后路径上每条边的反向边残留容量值要加上MinCap 为什么? 下面会具体解释

-------------------------------------------------------------------------------------------------------------

这样每次增广的复杂度为O(E) EK算法的总复杂度就是O(VE^2)

事实上大多数网络的增广次数很少 EK算法能处理绝大多数问题

平均意义下增广路算法都是很快的

增广路算法好比是自来水公司不断的往水管网里一条一条的通水

上面还遗留了一个反向边的问题: 为什么增广路径上每条边的反向边残留容量值要加上MinCap?

因为斜对称性! 由于残留网络=容量网络-流量网络

容量网络不改变的情况下

由于增广好比给增广路上通了一条流路径说所有边流量加MinCap

流量网络中路径上边的流量加MinCap 反向边流量减去MinCap

相对应的残留网络就发生相反的改变

这样我们就完成了EK算法具体实现可以用邻接表存图也可以用邻接矩阵存图

邻接表存图由于流量同时存在于边与反向边 为了方便求取反向边建图把一对互为反向边的边建在一起

代码很简单最好自己实现一下

const maxn=1000;
oo=maxlongint;
var a,b,c,n,m,h,t,i,min,ans:longint;
g:array[1..maxn,1..maxn]of longint;
q,p,prev:array[1..maxn]of longint;
flag:boolean;
begin
assign(input,'Ditch.in'); reset(input);
assign(output,'Ditch.out'); rewrite(output);
while not eof do
begin
readln(m,n);
fillchar(g,sizeof(g),0);
for i:=1 to m do
begin
readln(a,b,c);
g[a,b]:=g[a,b]+c;
end;
ans:=0;
while true do
begin
h:=1; t:=1;
fillchar(p,sizeof(p),0);
q[1]:=1; p[1]:=1;
flag:=false;
while h<=t do
begin
for i:=1 to n do
if (p[i]=0)and(g[q[h],i]>0)
then begin
inc(t); q[t]:=i;
p[i]:=1; prev[t]:=h;
if q[t]=n
then begin
flag:=true;
break;
end;
end;
if flag then break;
inc(h);
end;
if not flag
then break;
i:=t; min:=oo;
while q[i]<>1 do
begin
if g[q[prev[i]],q[i]]<min
then min:=g[q[prev[i]],q[i]];
i:=prev[i];
end;
i:=t;
while q[i]<>1 do
begin
g[q[prev[i]],q[i]]:=g[q[prev[i]],q[i]]-min;
g[q[i],q[prev[i]]]:=g[q[i],q[prev[i]]]+min;
i:=prev[i];
end;
ans:=ans+min;
end;
writeln(ans);
end;
close(input); close(output);
end.

看一个具体的增广路算法的例子吧

==================================================================================

三.最大流最小割定理

下面介绍网络流理论中一个最为重要的定理

最大流最小割定理(Maximum Flow, Minimum Cut Theorem):网络的最大流等于最小割

The maximum flow between vertices v_i and v_j in a graph G is exactly the weight of the smallest set of edges to disconnect G with v_i and v_j in different components.

http://mathworld.wolfram.com/MaximumFlowMinimumCutTheorem.html

具体的证明分三部分

1.任意一个流都小于等于任意一个割

这个很好理解自来水公司随便给你家通点水构成一个流

恐怖分子随便砍几刀砍出一个割

由于容量限制每一根的被砍的水管子流出的水流量都小于管子的容量

每一根被砍的水管的水本来都要到你家的现在流到外面加起来得到的流量还是等于原来的流

管子的容量加起来就是割所以流小于等于割

由于上面的流和割都是任意构造的所以任意一个流小于任意一个割

2.构造出一个流等于一个割

当达到最大流时根据增广路定理

残留网络中s到t已经没有通路了否则还能继续增广

我们把s能到的的点集设为S 不能到的点集为T

构造出一个割集C[S,T] S到T的边必然满流否则就能继续增广

这些满流边的流量和就是当前的流即最大流

把这些满流边作为割就构造出了一个和最大流相等的割

3.最大流等于最小割

设相等的流和割分别为Fm和Cm

则因为任意一个流小于等于任意一个割

任意F≤Fm=Cm≤任意C

定理说明完成

==================================================================================

四.简单的应用

Poj 1459是一个很典型的网络流应用

把电流想象成水流

http://poj.org/problem?id=1459

注意把多源多汇转化为单源单汇即可利用EK算法解决问题

网络流的应用还有很多化归的思想是网络流最具魅力的地方

代码如下:

1 const maxh=10;
2 maxn=100; maxq=110;
3 num:set of char=['0'..'9'];
4 oo=1000000;
5 var c,f:array[0..maxn+1,0..maxn+1]of longint;
6 n,m,k1,k2,tx,hx,head,tail,s,t,x,y,z,i:longint;
7 pre,h:array[0..maxn+1]of longint;
8 p:array[0..maxn+1]of boolean;
9 q:array[1..maxq]of longint;
10 procedure getc(var x:longint);
11 var ch:char;
12 begin
13 x:=0;
14 read(ch);
15 while not(ch in num) do
16 read(ch);
17 while ch in num do
18 begin
19 x:=x*10+ord(ch)-48;
20 read(ch);
21 end;
22 end;
23 procedure pop;
24 begin
25 p[q[head]]:=false;
26 inc(head); inc(hx);
27 if head>maxq then head:=1;
28 end;
29 procedure push(x:longint);
30 begin
31 inc(tail); inc(tx);
32 if tail>maxq then tail:=1;
33 q[tail]:=x; p[x]:=true;
34 end;
35 function min(x,y:longint):longint;
36 begin
37 min:=x;
38 if y<x then min:=y;
39 end;
40 begin
41 assign(input,'PowerNet.in'); reset(input);
42 assign(output,'PowerNet.out'); rewrite(output);
43 while not seekeof do
44 begin
45 read(n,k1,k2,m);
46 s:=n; t:=n+1;
47 fillchar(c,sizeof(c),0);
48 for i:=1 to m do
49 begin
50 getc(x); getc(y); getc(z);
51 c[x,y]:=c[x,y]+z;
52 end;
53 for i:=1 to k1 do
54 begin
55 getc(x); getc(y);
56 c[s,x]:=y;
57 end;
58 for i:=1 to k2 do
59 begin
60 getc(x); getc(y);
61 c[x,t]:=y;
62 end;
63 hx:=1; tx:=0;
64 head:=1; tail:=0;
65 fillchar(p,sizeof(p),false);
66 p[s]:=true; p[t]:=true;
67 fillchar(f,sizeof(f),0);
68 fillchar(pre,sizeof(pre),0);
69 fillchar(h,sizeof(h),0);
70 h[s]:=maxh; dec(n);
71 for i:=0 to n do
72 if c[s,i]>0
73 then begin
74 h[i]:=1; pre[i]:=c[s,i];
75 f[s,i]:=c[s,i]; f[i,s]:=-c[s,i];
76 push(i);
77 end;
78 while hx<=tx do
79 begin
80 x:=q[head];
81 for i:=0 to t do
82 begin
83 y:=c[x,i]-f[x,i];
84 if (h[x]=h[i]+1)and(y>0)
85 then begin
86 if not p[i] then push(i);
87 z:=min(pre[x],y);
88 f[x,i]:=f[x,i]+z;
89 f[i,x]:=f[i,x]-z;
90 pre[x]:=pre[x]-z;
91 pre[i]:=pre[i]+z;
92 end;
93 if pre[x]=0 then break;
94 end;
95 pop;
96 if pre[x]>0
97 then begin
98 y:=oo;
99 for i:=0 to t do
100 if c[x,i]>f[x,i]
101 then y:=min(y,h[i]);
102 h[x]:=y+1;
103 push(x);
104 end;
105 end;
106 writeln(pre[t]);
107 end;
108 close(input); close(output);
109 end.

==================================================================================

本文部分图片来源:

http://wenku.baidu.com/view/65a8290d4a7302768e99395a.html

http://wenku.baidu.com/view/6b4baf1ffc4ffe473368ab25.html

http://www.cppblog.com/mythit/archive/2009/04/19/80470.aspx

本文链接

[Poj 1113] 计算几何之凸包(一) {卷包裹算法}

2011-02-28T10:52:00Z

{

半个寒假都在写凸包

这几篇文章整理一下

主要介绍 二维凸包的求解算法

以及一个简单的应用

｝

====================================================================

一.凸集&凸包

(下文中所有的集合若不作特殊说明都是指欧氏空间上的集合)

凸集(Convex Set):任意两点的连线都在这个集合内的集合就是一个凸集.

A set in Euclidean space is convex set if it contains all the line segments connecting any pair of its points.

http://mathworld.wolfram.com/Convex.html

凸包(Convex Hull):包含集合S的所有凸集的交集就是集合S的凸包.

The convex hull of a set of points S in N dimensions is the intersection of all convex sets containing S.

我们经常关注一个点集的凸包这也是计算几何学的一个基本问题

我们现在已经有成熟的算法可以求出平面点集的凸包和空间点集的凸包

甚至有的算法可以方便的求出任意维度欧氏空间内的一个点集的凸包

凸包有着优美而实用的性质我们可以利用凸包把一个杂乱的点集所包含的信息进行有效的概括梳理

====================================================================

二.平面点集的凸包的算法

(下文中所有凸包若不作特殊说明都是指平面点集的凸包)

有两种直观的理解凸包的方式

在木板上钉钉子用一个有弹性的橡皮筋去框住所有钉子

橡皮筋形成的图形就是这个钉子所构成的点集的凸包

还有一种理解我们用一根麻绳绑住一个外面的钉子然后拉着麻绳绕所有钉子一圈

这个麻绳最后也构成了点集的凸包

其中第二种理解是我们一个经典算法 卷包裹法(Gift Wrapping)的思路

卷包裹算法从一个必然在凸包上的点开始向着一个方向依次选择最外侧的点

当回到最初的点时所选出的点集就是所要求的凸包

这里还有两个问题不是很清楚:

1.怎么确定一个肯定在凸包上的点?

这个问题很好解决取一个最左边的也就是横坐标最小的点

如果有多个这样的点就取这些点里纵坐标最小的

这样可以很好的处理共线的情况

2.如何确定下一个点(即最外侧的点)?

我们需要利用向量的叉积来解决这个问题

-----------------------------------------------------------------------

向量的叉积(Cross Product)原本是三维空间中的问题在二维中也有巧妙的应用

http://mathworld.wolfram.com/CrossProduct.html

(下文中所有的叉积若不作特殊说明都是指二维中新定义的叉积

下文中所有的向量乘法若不作特殊说明都是指向量的叉积)

我们定义二维向量<x1,y1>和<x2,y2>的叉积为一个实数Cp=x1*y2-x2*y1

叉积有两条性质很常用也很好用

1.叉积的一半是一个三角形的有向面积

这个公式可以避免面积计算的误差如果点是整点那么所有运算都是整数

2.向量的叉积的符号代表着向量旋转的方向

向量的叉积是不满足交换律的

向量A乘以向量B 如果为正则为A逆时针旋转向B 否则为顺时针

当然这里A转向B的角总是考虑一个小于180度以内的角否则就会出错

-----------------------------------------------------------------------

有了向量我们就可以选取一个最外侧的点了

比如现在我们卷包裹卷到J点我们要选取一个最外侧的点

当然比较红色的到角可以直接得到最外侧的点不过不方便

我们可以考虑那个蓝色的到角

利用向量我们可以比较哪个点"更外侧"

比如点K和点I 我们利用向量JK乘以向量JI得到一个数这个数应该是负数说明I比K更外侧

两个向量的比较具有传递性 所以我们可以像N个数里取最大的数一样取出最外侧的

遍历所有点每个点都和现有最外侧的点比较得到新的最外侧的点

至此两个问题都得以解决我们可以写出满足一般要求的卷包裹算法了

不过还遗留有一个问题就是处理共线的问题

有时候我们需要凸包边上的点也考虑到有时候却需要去掉这些点

我们通常称在凸包顶点处的点为极点

如果我们只要求保留极点而去除在边上的点

我们只需在取外侧的点的时候碰到共线的点取最远的

相反如果我们要保留所有在边上的点我们只需要在共线的点中取最近的

这样整个卷包裹法终于完成了

给出完整的代码:

{$inline on}
const zero=1e-6; maxn=100000;
type point=record x,y:extended; end;
var p:array[1..maxn]of point;
ch:array[1..maxn]of longint;
temp,n,m,i,j,k:longint;
function sgn(x:extended):longint; inline;
begin
if abs(x)<zero then exit(0);
if x<0 then sgn:=-1 else sgn:=1;
end;
function cross(a,b,c:point):extended; inline;
begin
cross:=(b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x);
end;
function dist(a,b:point):extended; inline;
begin
dist:=sqr(a.x-b.x)+sqr(a.y-b.y);
end;
function cmp(a,b,c:point):boolean; inline;
var temp:longint;
begin
temp:=sgn(cross(a,b,c));
if temp<>0 then exit(temp<0); {*B}
cmp:=dist(a,b)<dist(a,c); {*A}
end;
begin
assign(input,'Hull.in'); reset(input);
assign(output,'Hull1.out'); rewrite(output);
readln(n);
for i:=1 to n do
begin
readln(p[i].x,p[i].y);
if (j=0)or(p[i].x<p[j].x)or
(sgn(p[i].x-p[j].x)=0)and(p[i].y<p[j].y)
then j:=i;
end;
temp:=j;
while true do
begin
k:=0;
inc(m); ch[m]:=j;
for i:=1 to n do
if (i<>j)and((k=0)or
cmp(p[j],p[k],p[i]))
then k:=i;
if k=temp then break;
j:=k;
end;
for i:=1 to m do
writeln(p[ch[i]].x:0:2,' ',p[ch[i]].y:0:2);
close(input); close(output);
end.

*A Change Direction
*B Remove Colinear Points

还有两点要补充说明一下:

1.卷包裹算法的复杂度是O(NH)

N是全部的点数 H是最终在凸包上的点数

所以卷包裹算法很适合凸包上的点很少的时候通常随机数据很快

但是构造出的凸包上的点很多的数据这个算法就会很慢

比如所有的点都在一个圆周上

2.卷包裹算法输出的点是有序的

这也是对二维凸包算法的一个基本要求

通常只有保证有序才能进行进一步的计算

通过改变CMP函数可以改变上文中提到的共线(取/不取)以及这里的序(顺时针/逆时针)的问题

====================================================================

三.凸包的面积和周长

凸包的一个简单算法介绍完了

来看一个具体的问题 Poj 1113 http://poj.org/problem?id=1113

问题是求到一个简单多边形距离最少为L的点的轨迹的周长

我们可以先求凸包然后得到计算公式

实际上圆的部分可以拼接起来变成一个整圆

这样就好算多了注意把共线的都去掉不然误差会很大的

代码就不贴了很简单的

下一篇介绍更快速的平面凸包算法

Graham Scan 和 QuickHull

强烈推荐QuickHull

本文链接

写程序需要做的几件事

2011-02-01T06:21:00Z

兔年到啦大家新年快乐！

以下几条摘自http://old.blog.edu.cn/user3/Hailer/archives/2007/1752875.shtml

有几句话看了很有同感灰字标注

这些不止是写给在校大学生的每个写程序的人都应做到

4.C语言是基础,很重要,如果你不学好C语言,那么什么高级语言你都学不好.

5.C语言与C++语言是两回事.就像大熊猫和小熊猫一样,只是名字很像.

6.请先学习专业课《数据结构》《计算机组成原理》,不要刚开始就拿着一本VC在看,你连面向对象都搞不清楚,看VC没有任何用处.

7.对编程有一定的认识后,就可以学习C++了.(是C++而不是VC,这两个也是两码事.C++是一门语言,而VC教程则是讲解如何使用MFC类库,学习VC应建立在充分了解C++的基础之上.看VC的书,是学不了C++语言的.)

以上几条都是关于C语言的个人觉得ANSI C是每个学习与C相关语言的人都要特别理解的

8.学习编程的秘诀是:编程,编程,再编程;

实践出真知停留在YY的思考永远不完备

10.在学校的实验室就算你做错一万次程序都不会有人骂你,如果在公司你试试看!所以多去实验室上机,现在错得多了,毕业后就错得少了.

犯错意味着要失去很多但是不要忘记 失去的都是谬误

14.VC C#. NET这些东西都会过时,不会过时的是数据结构和优秀的算法!

后者才是真金前者只不过是工具

16.我还是强调认真听专业课,因为有些课像《数据结构》《编译原理》《操作系统》等等,这种课老师讲一分钟能让你明白的内容,你自己看要看好几个月,有的甚至看了好几年都看不明白.]

学会找一个好老师学会与别人交流 写程序的人和程序一样需要输入&输出

19.编程不是技术活,而是体力活.

身心健康是革命的本钱

20.如果你决定了要当一个好的程序员,那么请你放弃游戏,除非你是那种每天只要玩游戏就能写出好程序的天才!

主业一定要让你放不下副业一定要能够放得下

21.你要有足够的韧性和毅力!有个高手出一道题测试你的韧性和毅力:找个10000以内的素数表,把它们全都抄下来,然后再检查三遍,如果能够不间断地完成这一工作,你就可以满足这一条.

有没有发现过自己在写程序的时候走神了? 很多错误由此而来

22.找到只属于你自己的学习方法.不要盲目的追随别人的方法,适合自己的才是最好的!

任何东西都是这样当找到了适合自己的 一定会觉得那是最好的

以上只是我特别有同感的话和我自己的感受欢迎评论交流

本文链接

[Pku 2777] 线段树(六) {总结}

2011-01-02T07:46:00Z

{

很久以前就说过线段树的内容要写6篇了

没想到跨年了都现在是总结的时候了

这里是以前的5篇

}

线段树总结 关键字

二分将父亲区间均分设为儿子区间

切割将查询区间切割为Log级别个的树上区间

概括高效概括每个区间上的状况

合并将不同的区间情况合并起来得到总区间的情况

二分来源于线段树的定义

了解更多关于线段树的定义和基本性质请移步这里

这是线段树之所以能够达到Log级别的本质原因

也是二进制思想的一个应用

还记得这一个问题吧

Pku 2777 http://poj.org/problem?id=2777

我在这里也就是介绍线段树的第一篇里把它做为例子

不知有没有发现这个做法的最坏情况是O(Q*L)的

这一篇以讨论这个问题为主线总结线段树的思想

我们通过切割的思想来分析问题

我们引入一个东西叫混合颜色 查询到混合颜色就继续递归

那么很容易想出一个数据即所有的分支节点都是混合颜色叶子染上黑白相间的颜色

那么查询就变成O(L)的了——必须遍历所有叶子节点

可以看到这里线段树把查询区间切割成了L个区间其实不如用一个线性表模拟

而实际上我们发现树上的区间被查询区间完全包含了之后——

就不应当向下递归了 这样才是货真价实的Log2L个区间

关于线段树切割区间与保证切割性质的Lazy-Tag的内容请移步这里

那么我们为什么要记录混合颜色这种东西呢?

是因为我们不清楚这个区间是什么情况这就牵涉到概括的问题了

高效概括出每个区间的情况并且支持高效的合并运算

是我们最终完全解决这个问题的保障

我们讨论过树套树和树状数组

为什么区间排名问题必须要在线段树的节点内加入一个平衡树?

因为我们非得知道这个区间里所有的数才能查询到某个数在这个区间的排名

为了高效维护这些数我们就得用平衡树来组织

也就是用平衡树来概括区间信息

树状数组的本质是去除一部分节点的线段树 利用了某些合并运算的可减性

精简了某些区间所以能够更高效的概括区间信息

回到这个问题我们要概括包含某些颜色的区间的信息

并且支持高效的合并运算 我们可以看到颜色最多才30种

利用一个32位长整形概括区间包含不包含各种颜色

合并运算就是Or运算问题就可以解决了

比如一个区间含有1 2 3 5 号颜色就存为10111=23

另一个区间含有1 3 4号颜色就存为1101=11

合并两个区间就是含有1 2 3 4 5号颜色即11 Or 23=10111 Or 1101=11111=31

就可以得到31这个结果只要统计二进制中含有几个1就可以得到答案了

代码不难写直接给出

const max=200000;
var tt,n,t,q,x,y,z,i:longint;
l,r,c,d,ls,rs:array[1..max]of longint;
ch:char;
procedure down(x:longint);
begin
if d[x]>0
then begin
c[x]:=d[x];
if ls[x]<>0 then d[ls[x]]:=d[x];
if rs[x]<>0 then d[rs[x]]:=d[x];
d[x]:=0;
end;
end;
procedure update(x:longint);
begin
down(ls[x]); down(rs[x]);
c[x]:=c[ls[x]] or c[rs[x]];
end;
procedure build(a,b:longint);
var x,mid:longint;
begin
inc(tt); x:=tt;
c[x]:=1; d[x]:=0;
l[x]:=a; r[x]:=b;
if b-a>1
then begin
mid:=(a+b)shr 1;
ls[x]:=tt+1; build(a,mid);
rs[x]:=tt+1; build(mid,b);
end;
end;
procedure cover(x,a,b,c:longint);
var mid:longint;
begin
down(x);
if (a<=l[x])and(r[x]<=b)
then d[x]:=c
else begin
mid:=(l[x]+r[x])shr 1;
if a<mid then cover(ls[x],a,b,c);
if b>mid then cover(rs[x],a,b,c);
update(x);
end;
end;
function count(x,a,b:longint):longint;
var mid:longint;
begin
down(x);
if (a<=l[x])and(r[x]<=b)
then count:=c[x]
else begin
count:=0;
mid:=(l[x]+r[x])shr 1;
if a<mid then count:=count or count(ls[x],a,b);
if b>mid then count:=count or count(rs[x],a,b);
end;
end;
function calcu(x:longint):longint;
begin
calcu:=0;
while x>0 do
begin
calcu:=calcu+x and 1;
x:=x shr 1;
end;
end;
begin
assign(input,'Count.in'); reset(input);
assign(output,'Count.out'); rewrite(output);
readln(n,t,q);
build(0,n);
for i:=1 to q do
begin
read(ch,x,y);
if x>y
then begin
z:=x; x:=y; y:=z;
end;
if ch='P'
then writeln(calcu(count(1,x-1,y)))
else begin
read(z);
cover(1,x-1,y,1 shl (z-1));
end;
readln;
end;
close(input); close(output);
end.

关于线段树的介绍到此告一段落

以后如果还有好玩的经典的线段树问题还会新写

谢谢阅读如有不足欢迎指正!

本文链接

[字符串统计] 字符串(八) {后缀数组的应用(下)}

2010-12-14T15:51:00Z

{

承上半部分

继续讨论后缀数组的应用

这一部分难度较大

需要对后缀数组有一个综合的了解

主要内容是借助Height数组解决问题

即Height分析

}

重贴一下关于Height数组的内容:

Height[]纪录了两个相邻排名的后缀的最长公共前缀

最基本的一个性质是:任意两个后缀suffix(j)和suffix(k)的最长公共前缀为

height[rank[j]+1] height[rank[j]+2] …height[rank[k]]中的最小值

根据这个性质关于字符串的最优化问题

我们通常可以运用贪心法或二分答案

而关于字符串的统计问题 为了设计出高效的算法

我们还需要对这个性质进行更深入的分析

提出一个具体问题

统计字符串的不同子串个数 Spoj 694 Spoj 705

我们尝试利用后缀数组求解

看一个样例 A=aabaaaab

构造后缀数组:

N/A $
0   aaaab$
3   aaab$
2   aab$
3   aabaaaab$
1 ab$
2   abaaaab$
0   b$
1   baaaab$

每个后缀前面就是Height数组的值

由于子串是后缀的前缀 我们考虑这些后缀有多少不同的前缀

如果不考虑重复每个后缀产生的前缀个数就是它的长度

但是有重复产生我们利用Height数组完成去重的工作

为了考虑方便我们只需统计每个后缀产生的不是前一个后缀的前缀的前缀

就举样例的例子

第一个后缀产生了5个子串(前缀) aaaab aaaa aaa aa a

第二个后缀本来产生了4个子串但是 aaa aa a 都是前一个后缀统计过的最后只产生了1个即aaab

第三个后缀也是如此产生了3个子串 aa a 和第二个后缀重复一共产生了1个即aab

...(不断累加直到最后一个后缀为止)

总结一下就是每次累加 Length(Suffix[Rank[i]])-Height[i]

为什么只要考虑和前面一个后缀的重复呢?

我们可以这样看:

如果某个前缀和前面一个后缀发生重复那么这个前缀肯定不能再统计了

另外一方面如果这个前缀不是前面一个后缀的前缀

那么根据Height基本性质 这个后缀更不会是更前面后缀的前缀了* 也就是这个前缀前面肯定没统计过

由于只考虑和前面的关系统计过的前缀就不会再统计了

所以这个扫描算法是正确的复杂度很完美是O(N)

贴一下核心的代码

j:=0;
fillchar(h,sizeof(h),0);
for i:=1 to n do
if r[i]<>1
then begin
k:=s[r[i]-1];
while a[i+j]=a[k+j] do
inc(j);
h[r[i]]:=j;
if j>0 then dec(j);
end;
ans:=0;
for i:=1 to n do
ans:=ans+n-s[i]+1-h[i];
writeln(ans-n);

通过以上一个问题的分析[主要是标记*处]

我们似乎看到Height数组的性质有这样一个特点

任意两点间的最小值起着隔断的作用 最小值前面的值不会在起作用了

针对这个特点我们有时在扫描的时候利用一个单调递增的栈来维护Height数组

单调栈引例最大矩形面积问题

在x轴上水平放置着n个矩形每个矩形的宽度均为1 但的高度并不相同

求这个面积并中最大的子矩形面积

显然一个有机会成为最大矩形的矩形都满足这样一个条件

设此矩形范围为[A,B] 高度为C 则A-1 B+1处的高度必然小于C

而且[A,B]之间的高度都大于等于C

所以一个矩形被两边高度小于它的条形隔断了

我们考虑扫描的过程

扫描到一个新的位置就把被当前位置隔断的矩形统计并剔出

并把没有被隔断的矩形继续存储下去

为了做到这一点我们维护一个关于高度递增的存储矩形的单调的栈

每次扫描到新的条形时就把栈内高度大于这个条形的矩形全部弹出并统计

然后继续扫描下一个扫完最后一个时 清空所有即可

存储矩形我们只要存两个量 矩形高度和开始位置

而结束位置是不定的直到弹栈才会确定下来

由于每个高度只会入栈一次复杂度达到了O(N)

下面是对于样例 2 1 4 5 1 3 3 的模拟

看完了这个例子我们继续讨论单调栈在Height分析时的应用

Pku 3415 统计两个串的公共子串的个数(位置不同即是不同)

依然用后缀数组解决这个问题

先把两个串拼接然后生成后缀数组

比如两个串A=aababaa B=abaabaa

0 #
0 $abaabaa#
0 a#
1 a$abaabaa#
1 aa#
2 aa$abaabaa#
2 aabaa#
4 aababaa$abaabaa#
1 abaa#
4 abaa$abaabaa#
4 abaabaa#
3 ababaa$abaabaa#
0 baa#
3 baa$abaabaa#
3 baabaa#
2 babaa$abaabaa#

为了统计方便我们分两次考虑

第一次扫描得到A串的后缀和排在前面的B串的后缀产生的公共子串的个数

第二次扫描得到B串的后缀和排在前面的A串的后缀产生的公共子串的个数

这里每次扫描的思路和讨论单个串的不同子串个数类似做到了不重复不遗漏

由于两次扫描是类似的单看第一次

那么如何得到每个A串后缀和前面的B串后缀产生的公共子串个数呢?

举个具体的例子比如扫描到下图的位置

0 #
0 $abaabaa#
0 a#                            <-B串后缀 (0个)
1 a$abaabaa#
1 aa#                          <-B串后缀 (1个)
2 aa$abaabaa#
2 aabaa#                    <-B串后缀 (1个)
4 aababaa$abaabaa#
1 abaa#                      <-B串后缀 (3个)
4 abaa$abaabaa#
4 abaabaa#                <-B串后缀 (3个)
3 ababaa$abaabaa# <-当前A串后缀
0 baa#
3 baa$abaabaa#
3 baabaa#
2 babaa$abaabaa#

这个后缀X和前面每个B串后缀Y产生的公共子串个数(不计重复)为

Num=∑ LCP(Suffix(X),Suffix(Y))

LCP就是X到Y的区间最小值

上面例子的数值已经标出

的每次都去回头扫描求X和每个Y的RMQ 即使预处理出ST O(1)回答

也是O(N^2)的算法不可取

回到上面我们发现的Height数组的特点

任意Y和X产生的LCP由他们间的RMQ决定又好像是被这个值隔断了

也就是这个值以上的所有Y和X产生的LCP都小于等于这个值

上面的五个图分别代表了当前A和前面每个B产生的公共前缀的大小

和上面的最大矩形面积类似用关于Height单调递增的存储Height值相等的区间的栈维护

这里操作比较繁琐就列举几个注意点具体可以看代码

每次扫描到一个新的Height就执行维护单调性的弹栈操作

然后把新的Height压入栈中注意要同时记录区间范围

区间内B串的个数用部分和统计

注意每个栈内节点都保存一下它以下所有节点的答案和 这样每次统计就不用扫描整个栈了

每次扫描到一个A就统计一下即可具体看下图

给一下核心的代码

d[2]:=0;
for i:=3 to n do
if s[i]<m
then d[i]:=d[i-1]
else d[i]:=d[i-1]+1;
ans:=0;
for i:=3 to n do
begin
if h[i]<l
then begin
st[0].h:=-1;
st[0].x:=i-1; st[0].y:=i-1;
st[0].ans:=0;
top:=0;
now:=0;
end
else begin
while st[top].h>=h[i] do
begin
now:=now-st[top].ans;
dec(top);
end;
next:=top; inc(top);
st[top].h:=h[i];
st[top].y:=i-1; st[top].x:=st[next].y+1;
st[top].ans:=(st[top].h-l+1)*(d[st[top].y]-d[st[top].x-1]);
now:=now+st[top].ans;
if s[i]<m then ans:=ans+now;
end;
end;
for i:=3 to n do
if s[i]>m
then d[i]:=d[i-1]
else d[i]:=d[i-1]+1;
for i:=3 to n do
begin
if h[i]<l
then begin
st[0].h:=-1;
st[0].x:=i-1; st[0].y:=i-1;
st[0].ans:=0;
top:=0;
now:=0;
end
else begin
while st[top].h>=h[i] do
begin
now:=now-st[top].ans;
dec(top);
end;
next:=top; inc(top);
st[top].h:=h[i];
st[top].y:=i-1; st[top].x:=st[next].y+1;
st[top].ans:=(st[top].h-l+1)*(d[st[top].y]-d[st[top].x-1]);
now:=now+st[top].ans;
if s[i]>m then ans:=ans+now;
end;
end;
writeln(ans);

写了一共8篇文章简要介绍了一下字符串的相关算法和数据结构

到此告一段落当然还有很多没写到的比如后缀树扩展的KMP算法等

谢谢阅读如有不足欢迎指正!

BOB HAN 原创转载请注明出处 http://www.cnblogs.com/Booble/

本文链接