C++博客-ACM___________________________-随笔分类-ACM_资料

Splay Tree 介绍

MiYu — Fri, 12 Nov 2010 03:13:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

伸展树（Splay Tree）是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
查找树的相关知识
　　各种查找树存在不足。比如：对于一个有n个节点的平衡树，虽然最坏情况下每次查找的时间复杂度不会超过O(logn)，但是如果访问模式不均匀，平衡树的效率就会受到影响。此外，它们还需要额外的空间来存储平衡信息。 
　　这些查找树的设计目标都是减少最坏情况下单次操作时间，但是查找树的典型应用经常需要执行一系列的查找操作，此时更关心的性能指标是所有这些操作总共需要多少时间。对于此类应用，更好的目标就是降低操作的摊平时间，此处的摊平时间是指在一系列最坏情况的操作序列中单次操作的平均时间。获得摊平效率的一种方法 就是使用“自调整”的数据结构。 
　　和平衡的或是其它对结构有明确限制的数据结构比起来，自调整数据结构有以下几个优点： 
　　1、从摊平角度而言，它们忽略常量因子，因此绝对不会比有明确限制的数据结构差。而且由于它们可以根据使用情况进行调整，于是在使用模式不均匀的情况下更加有效。 
　　2、由于无需存储平衡或者其它的限制信息，它们所需的空间更小。 
　　3、它们的查找和更新算法概念简单，易于实现。 
　　当然，自调整结构也有潜在的缺点： 
　　1、它们需要更多的局部调整，尤其是在查找期间。（那些有明确限制的数据结构仅需在更新期间进行调整，查找期间则不用） 
　　2、一系列查找操作中的某一个可能会耗时较长，这在实时应用程序中可能是个不足之处。
伸展树存在的意义
　　假设想要对一个二叉查找树执行一系列的查找操作。为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树根的位置。于是想到设计一个简单方法， 在每次查找之后对树进行重构，把被查找的条目搬移到离树根近一些的地方。splay tree应运而生。splay tree是一种自调整形式的二叉查找树，它会沿着从某个节点到树根之间的路径，通过一系列的旋转把这个节点搬移到树根去。
已知重构方法与伸展树的重构方法
　　先前，已经存在两种重构方法： 
　　1、单旋：在查找完位于节点x中的条目i之后，旋转链接x和其父节点的边。（除非x就是树根） 
　　2、搬移至树根：在查找完位于节点x中的条目i之后，旋转链接x和其父节点的边，然后重复这个操作直至x成为树根。 
　　splay tree的重构方法和搬移至树根的方法相似，它也会沿着查找路径做自底向上的旋转，将被查找条目移至树根。但不同的是，它的旋转是成对进行的，顺序取决于查找路径的结构。为了在节点x处对树进行splay操作，我们需要重复下面的步骤，直至x成为树根为止： 
　　1、第一种情况：如果x的父节点p(x)是树根，则旋转连接x和p(x)的边。（这种情况是最后一步） 
　　2、第二种情况：如果p(x)不是树根，而且x和p(x)本身都是左孩子或者都是右孩子，则先旋转连接p(x)和x的祖父节点g(x)的边，然后再旋转连接x和p(x)的边。 
　　3、第三种情况：如果p(x)不是树根，而且x是左孩子，p(x)是右孩子，或者相反，则先旋转连接x和p(x)的边，再旋转连接x和新的p(x)的边。 
　　在节点x处进行splay操作的时间是和查找x所需的时间成比例的。splay操作不单是把x搬移到了树根，而且还把查找路径上的每个节点的深度都大致减掉了一半。
伸展树（Splay Tree）支持的操作
　　具体操作包括： 
　　1、access(i,t):如果i在树t中，则返回指向它的指针，否则返回空指针。为了实现access(i,t)，可以从树t的根部向下查找i。如果 查找操作遇到了一个含有i的节点x，就在x处进行splay操作，并返回指向x的指针，访问结束。如果遇到了空指针，表示i不在树中，此时就在最后一个非 空节点处进行splay操作，然后返回空指针。如果树是空的，将忽略掉splay操作。 
　　2、insert(i,t):将条目i插入树t中（假设其尚不存在）。为了实现insert(i,t)，首先执行split(i,t)，然后把t换成一个由新的包含有i的根节点组成的树，这个根节点的左右子树分别是split返回的树t1和t2。 
　　3、delete(i,t):从树t中删除条目i（假设其已经存在）。为了实现delete(i,t)，首先执行access(i,t)，然后把t换成其左子树和右子树join之后的新树。 
　　4、join(t1,t2):将树t1和t2合并成一棵树，其中包含之前两棵树的所有条目，并返回合并之后的树。这个操作假设t1中的所有条目都小于t2 中的条目，操作完成之后会销毁t1和t2。为了实现join(t1,t2)，首先访问t1中最大的条目i。访问结束之后，t1的根节点中包含的就是i，它 的右孩子显然为空。于是把t2作为这个根节点的右子树并返回完成之后的新树即可实现join操作。 
　　5、split(i,t):构建并返回两棵树t1和t2，其中t1包含t中所有小于等于i的条目，t2包含t中所有大于i的条目。操作完成之后销毁t。为 了实现split(i,t)，首先执行access(i,t)，然后根据新根节点中的值是大于还是小于等于i来切断这个根节点的左链接或右链接，并返回形 成的两棵树。 
　　另外insert和delete方法有更好的实现，时间复杂度更小： 
　　1、insert(i, t):查找i，把遇到的空指针替换成一个含有i的新节点，然后再在新节点处对树进行splay操作。 
　　2、delete(i, t):查找含有i的节点，设此节点为x，其父节点为y。把x的左右子树合并之后替换掉x，然后再从y处进行splay操作。
伸展树的优势
　　由于Splay Tree仅仅是不断调整，并没有引入额外的标记，因而树结构与标准BST没有任何不同，从空间角度来看，它比Treap、Red-Black Tree、AVL要高效得多。因为结构不变，因此只要是通过左旋和右旋进行的操作对Splay Tree性质都没有丝毫影响，因而它也提供了BST中最丰富的功能，包括快速的拆分和合并（这里指的是将原树拆分成两棵子树，其中一棵子树所有节点都比另一子树小，以及它的逆过程），并且实现极为便捷。这一点是其它结构较难实现的。其时间效率也相当稳定，和Treap基本相当

MiYu 2010-11-12 11:13 发表评论

(转)伸展树 ( Splay tree )

MiYu — Fri, 12 Nov 2010 03:13:00 GMT

摘要: MiYu原创, 转帖请注明 : 转载自 ______________白白の屋伸展树(Splay Tree)是AVL树不错的替代，它有以下几个特点：(1)它是二叉查找树的改进，所以具有二叉查找树的有序性。(2)对伸展树的操作的平摊复杂度是O(log2n)。(3)伸展树的空间要求、编程难度非常低。提到伸展树，就不得不提到AVL树和R... 阅读全文

MiYu 2010-11-12 11:13 发表评论

树状数组（Binary Indexed Trees ）论文解析

MiYu — Fri, 29 Oct 2010 01:47:00 GMT

摘要: By boba5551TopCoder MemberIntroductionWe often need some sort of data structure to make our algorithms faster. In this article we willdiscuss the Binary Indexed Trees structure. Accordi... 阅读全文

MiYu 2010-10-29 09:47 发表评论

HDU 1512 HDOJ 1512 Monkey King ( 左偏树 ) ACM 1512 IN HDU

MiYu — Sun, 24 Oct 2010 03:43:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:

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

题目描述 :

代码

Monkey King

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 914 Accepted Submission(s): 426

Problem Description
Once in a forest, there lived N aggressive monkeys. At the beginning, they each does things in its own way and none of them knows each other. But monkeys can't avoid quarrelling, and it only happens between two monkeys who does not know each other. And when it happens, both the two monkeys will invite the strongest friend of them, and duel. Of course, after the duel, the two monkeys and all of there friends knows each other, and the quarrel above will no longer happens between these monkeys even if they have ever conflicted.

Assume that every money has a strongness value, which will be reduced to only half of the original after a duel(that is, 10 will be reduced to 5 and 5 will be reduced to 2).

And we also assume that every monkey knows himself. That is, when he is the strongest one in all of his friends, he himself will go to duel.

Input
There are several test cases, and each case consists of two parts.

First part: The first line contains an integer N(N<=100,000), which indicates the number of monkeys. And then N lines follows. There is one number on each line, indicating the strongness value of ith monkey(<=32768).

Second part: The first line contains an integer M(M<=100,000), which indicates there are M conflicts happened. And then M lines follows, each line of which contains two integers x and y, indicating that there is a conflict between the Xth monkey and Yth.

Output
For each of the conflict, output -1 if the two monkeys know each other, otherwise output the strongness value of the strongest monkey in all friends of them after the duel.

Sample Input
5
20
16
10
10
4
5
2 3
3 4
3 5
4 5
1 5

Sample Output
8
5
5
-1
10

题目分析:

Mail to : miyubai@gamil.com

My Blog : www.baiyun.me

Link : http://www.cnblogs.com/MiYu || http://www.cppblog.com/MiYu

Author By : MiYu

Test : 1

Complier : g++ mingw32-3.4.2

Program : HDU_1512

Doc Name : Monkey King

题目意思:

有N只猴子, 每只都有一个力量值. 开始的时候互不认识, 它们之间会发生M次斗争. 每次发生a, b的斗争时, a, b都会从各自的朋友圈里拉出一个最强的, 之后两只猴子打, 打完后这两只猴子的力量值各减半. 并且打完后, 两只猴子的朋友圈的所有人都互相认识(也就是不会再打).

你的任务就是对于每个斗争, 若a, b是朋友, 那么输出-1, 否则输出打完后它们的朋友圈的最强猴子的力量值.

使用普通优先队列的话估计会超时, 因为数据量很大 100000 ! !, 等下有空试试看.

对于每一个节点, 定义dis 表示X节点到最右边的空节点的距离的最小值

对于每个节点X, 要求X的左儿子的dis >= 右儿子的dis, 那么容易发现, 对于N个节点的左偏树, 其右儿子最多只有logN个节点.

合并操作就是让复杂度落在右儿子上, 从而达到logN的合并复杂度.

首先对于两个堆, 若其中一个为空, 返回另一个.

否则(这里以大根堆为例), a指向堆顶较大的堆, b指向另一个. 让a的右儿子和b合并, 合并后的子树作为a的右儿子.

接下来, 检查a的两个儿子是否满足dis, 不满足就交换两个儿子.

最后, 更新a的dis.

这样就容易实现堆的其他操作 ( 比如插入, 删除顶等 ).

另外还需要用到并查集.

//#pragma warning( disable:4789 )

#include

using namespace std;

const int MM = 100010;

struct left {

int l,r,dis,val,dad;

} heap[MM];

int N, M;

inline int max ( const int &a, const int &b) {

return a > b ? a : b;

}

inline int find ( int &x ) {

return heap[x].dad == x ? x : heap[x].dad = find ( heap[x].dad );

}

inline void swap(int &a, int &b) {

a ^= b ^= a ^= b;

}

inline int merge ( int x, int y ) {

if ( x == 0 ) return y;

if ( y == 0 ) return x;

if ( heap[y].val > heap[x].val ) swap ( x, y );

heap[x].r = merge ( heap[x].r, y );

heap[heap[x].r].dad = x;

if ( heap[ heap[x].l ].dis < heap[ heap[x].r ].dis )

swap ( heap[x].l, heap[x].r );

if ( heap[x].r == 0 ) heap[x].dis = 0;

else heap[x].dis = heap[ heap[x].r ].dis + 1;

return x;

}

inline int push ( int x, int y ) {

return merge ( x, y );

}

inline int pop ( int &x ) {

int l = heap[x].l;

int r = heap[x].r;

heap[l].dad = l;

heap[r].dad = r;

heap[x].l = heap[x].r = heap[x].dis = 0;

return merge ( l, r );

}

inline bool scan_d(int &num) {

char in;bool IsN=false;

in=getchar();

if(in==EOF) return false;

while(in!='-'&&(in<'0'||in>'9')) in=getchar();

if(in=='-'){ IsN=true;num=0;}

else num=in-'0';

while(in=getchar(),in>='0'&&in<='9'){

num*=10,num+=in-'0';

}

if(IsN) num=-num;

return true;

}

int main() {

while ( scan_d ( N ) ) {

for ( int i = 1; i <= N; ++ i ) {

scan_d ( heap[i].val );

heap[i].l = heap[i].r = heap[i].dis = 0;

heap[i].dad = i;

}

scan_d ( M );

int a, b, x, y;

while ( M -- ) {

scan_d (a); scan_d (b);

x = find ( a );

y = find ( b );

if ( x == y ) {

puts ( "-1" );

} else {

heap[x].val /= 2;

int xx = push ( pop ( x ), x );

heap[y].val /= 2;

int yy = push ( pop ( y ), y );

printf ( "%d\n", heap[ merge ( xx, yy ) ].val );

}

return 0;

}

MiYu 2010-10-24 11:43 发表评论

左偏树详解 ( 转载 )

MiYu — Sun, 24 Oct 2010 02:53:00 GMT

摘要: MiYu原创, 转帖请注明 : 转载自 ______________白白の屋 2.1.2 可并堆的定义可并堆(Mergeable Heap)也是一种抽象数据类型，它除了支持优先队列的三个基本操作(Insert, Minimum, Delete-Min)，还支持一个额外的操作——合并操作：H ← Merge(H... 阅读全文

MiYu 2010-10-24 10:53 发表评论

Bellman-Ford && SPFA 算法

MiYu — Sat, 23 Oct 2010 14:09:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

 B-F 适用条件&范围
单源最短路径(从源点s到其它所有顶点v);
有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图);
边权可正可负(如有负权回路输出错误提示);
差分约束系统;
算法描述对每条边进行|V|-1次Relax ( 就是松弛操作 )操作;
如果存在(u,v)∈E使得dis[u]+w
For i:=1 to |V|-1 do //v为顶点数
For 每条边(u,v)∈E do  //对每条边进行遍历
  Relax(u,v,w);
For每条边(u,v)∈E do
  If dis[u]+w时空复杂度算法时间复杂度O(VE)。因为算法简单，适用范围又广，虽然复杂度稍高，仍不失为一个很实用的算法。
 
算法的改进---> SPFA 
 
算法简介SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。也有人说SPFA本来就是Bellman-Ford算法，现在广为流传的Bellman-Ford算法实际上是山寨版。
算法流程算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。
这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法
SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：
设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。
维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。
每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数超过n，则有负权环。
SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右
算法代码Procedure SPFA;
 
Begin
  initialize-single-source(G,s);
  initialize-queue(Q);
  enqueue(Q,s);
  while not empty(Q) do 
    begin
      u:=dequeue(Q);
      for each v∈adj[u] do 
        begin
          tmp:=d[v];
          relax(u,v);
          if (tmp<>d[v]) and (not v in Q) then
            enqueue(Q,v);
        end;
    end;
End;
procedure spfa;
begin
  fillchar(q,sizeof(q),0); h:=0; t:=0;//队列
  fillchar(v,sizeof(v),false);//v[i]判断i是否在队列中
  for i:=1 to n do 
    dist[i]:=maxint;//初始化最小值
 
  inc(t);
  q[t]:=1;
  v[1]:=true;
  dist[1]:=0;//这里把1作为源点
 
  while h<>t do
    begin
      h:=(h mod n)+1;
      x:=q[h];
      v[x]:=false;
      for i:=1 to n do
        if (cost[x,i]>0) and (dist[x]+cost[x,i][i]) then
          begin
            dist[i]:=dist[x]+cost[x,i];
            if not(v[i]) then
              begin
                t:=(t mod n)+1;
                q[t]:=i;
                v[i]:=true;
              end;
          end;
    end;
end;void SPFA(void)//好久以前写的……今天丢上来……话说我都不记得SPFA怎么写了……囧……ms存图是矩阵……嗯嗯
{
 int i;
 queue list;
 list.insert(s);
 for(i=1;i<=n;i++)
  {
   if(s==i)
    continue;
   dist[i]=map[s][i];
   way[i]=s;
   if(dist[i])
   list.insert(i);
  }
 int p;
 while(!list.empty())
 {
  p=list.fire();
  for(i=1;i<=n;i++)
   if(map[p][i]&&(dist[i]>dist[p]+map[p][i]||!dist[i])&&i!=s)
    {
     dist[i]=dist[p]+map[p][i];
     way[i]=p;
     if(!list.in(i))
      list.insert(i);
    }
 }
} 

MiYu 2010-10-23 22:09 发表评论

trie树--详解

MiYu — Sat, 23 Oct 2010 14:05:00 GMT

摘要: MiYu原创, 转帖请注明 : 转载自 ______________白白の屋文章作者：yx_th000 文章来源：Cherish_yimi (http://www.cnblogs.com/cherish_yimi/) 转载请注明，谢谢合作。关键词：trie trie树数据结构 &nb... 阅读全文

MiYu 2010-10-23 22:05 发表评论

前向星+SPFA(转载)

MiYu — Sat, 23 Oct 2010 14:02:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

代码前向星+SPFA
我是在做USACO的sweet butter时偶然发现这个东西的。。。
这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法（仅为个人理解=.=）
SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：
设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。
维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。
每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist，若小于则改进Dist，将Fa记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。
SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右
前向星优化：
不要把前向星想成什么高深莫测的东西……它其实就是一种邻接表的紧缩存储形式。
为什么叫前向星？因为它是将边按照前端点排序，并用一个数组k[i]记录端点i第一次以左端点出现的位置。这样，我们就能用O(E)的空间复杂度存储下一个邻接表，而避免了链表或N^2的庞大空间消耗。
当然，实际上我们并不需要排序：因为我们只需要知道某一条边应该放到什么位置即可。因而我们还需要一个数组t[i]存储从i出发的边的条数。则需要存储在的位置就可以很轻易地求得。（详见代码）
Butter题目代码如下：
Program butter(input,output);
Type
   edge=record
            x,y,d:longint;
        end;
Var
   min,res,n,p,c,x,y,i,j,l,r:longint;
   te,e:array[0..3000] of edge;
   tk,t,k,num,d:array[1..800] of longint;
   q:array[1..100000] of longint;
   use:array[1..800] of boolean;
Procedure swap(var n1,n2:longint);
Var
   tmp:longint;
Begin
   tmp:=n1;n1:=n2;n2:=tmp;
End;
Begin
   assign(input,'butter.in');reset(input);
   readln(n,p,c);
   for i:=1 to n do
   begin
      read(x);
      inc(num[x]);
   end;
   for i:=1 to c do
   begin
      with e[i*2-1] do readln(x,y,d);
      e[i*2]:=e[i*2-1];
      swap(e[i*2].x,e[i*2].y);
   end;
   c:=c*2;
   for i:=1 to c do inc(t[e[i].x]);
   j:=0;k[1]:=1;
   for i:=2 to p do
      k[i]:=k[i-1]+t[i-1];
   tk:=k;te:=e;
   for i:=1 to c do
   begin
      e[tk[te[i].x]]:=te[i];
      inc(tk[te[i].x]);
   end;
   min:=maxlongint;
   for i:=1 to p do
   begin
      fillchar(q,sizeof(q),0);
      fillchar(d,sizeof(d),127);
      fillchar(use,sizeof(use),false);
      q[1]:=i;l:=1;r:=1;d[i]:=0;use[i]:=true;
      repeat
            for j:=k[q[l]] to k[q[l]]+t[q[l]]-1 do
               if d[q[l]]+e[j].d<d[e[j].y] then
               begin
                  d[e[j].y]:=d[q[l]]+e[j].d;
                  if not use[e[j].y] then
                  begin
                     use[e[j].y]:=true;
                     inc(r);
                     q[r]:=e[j].y;
                  end;
               end;
            use[q[l]]:=false;
            inc(l);
      until l>r;
      res:=0;
      for j:=1 to p do
         res:=res+d[j]*num[j];
      if res<min then min:=res;
   end;
   assign(output,'butter.out');rewrite(output);
   writeln(min);close(output);
End.

MiYu 2010-10-23 22:02 发表评论

松弛操作

MiYu — Sat, 23 Oct 2010 14:01:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

(重定向自松弛技术)
　　单源最短路径算法中使用了松弛（relaxation）操作。对于每个顶点v∈V，都设置一个属性d[v]，用来描述从源点s到v的最短路径上权值的上界，称为最短路径估计（shortest-path estimate）。π[v]代表S到v的当前最短路径中v点之前的一个点的编号,我们用下面的Θ(V)时间的过程来对最短路径估计和前趋进行初始化。
　　INITIALIZE-SINGLE-SOURCE(G,s)
　　1 for each vertex v∈V[G]
　　2 do d[v]←∞
　　3 π[v]←NIL
　　4 d[s]←0
　　经过初始化以后，对所有v∈V，π[v]=NIL，对v∈V-{s}，有d[s]=0以及d[v]=∞。
　　在松弛一条边(u,v)的过程中，要测试是否可以通过u，对迄今找到的v的最短路径进行改进；如果可以改进的话，则更新d[v]和π[v]。一次松弛操作可以减小最短路径估计的值d[v]，并更新v的前趋域π[v](S到v的当前最短路径中v点之前的一个点的编号)。下面的伪代码对边(u,v)进行了一步松弛操作。
　　RELAX(u, v, w)
　　1 if(d[v]>d[u]+w(u,v))
　　2 then d[v]←d[u]+w(u,v)
　　3 π[v]←u
　　每个单源最短路径算法中都会调用INITIALIZE-SINGLE-SOURCE，然后重复对边进行松弛的过程。另外，松弛是改变最短路径和前趋的唯一方式。各个单源最短路径算法间区别在于对每条边进行松弛操作的次数，以及对边执行松弛操作的次序有所不同。在Dijkstra算法以及关于有向无回路图的最短路径算法中，对每条边执行一次松弛操作。在Bellman-Ford算法中，每条边要执行多次松弛操作。
　　procedure relax(u,v,w:integer);//多数情况下不需要单独写成procedure。
　　begin
　　if dis+w
　　begin
　　dis[v]:=dis+w;
　　pre[v]:=u;
　　end
　　end;

MiYu 2010-10-23 22:01 发表评论

什么是离散化?

MiYu — Fri, 15 Oct 2010 03:15:00 GMT

Matrix67原创 Trackback: http://www.matrix67.com/blog/archives/108

如果说今年这时候OIBH问得最多的问题是二分图，那么去年这时候问得最多的算是离散化了。对于“什么是离散化”，搜索帖子你会发现有各种说法，比如“排序后处理”、“对坐标的近似处理”等等。哪个是对的呢？哪个都对。关键在于，这需要一些例子和不少的讲解才能完全解释清楚。

    离散化是程序设计中一个非常常用的技巧，它可以有效的降低时间复杂度。其基本思想就是在众多可能的情况中“只考虑我需要用的值”。下面我将用三个例子说明，如何运用离散化改进一个低效的，甚至根本不可能实现的算法。

    《算法艺术与信息学竞赛》中的计算几何部分，黄亮举了一个经典的例子，我认为很适合用来介绍离散化思想。这个问题是UVA10173(http://acm.uva.es/p/v101/10173.html)，题目意思很简单，给定平面上n个点的坐标，求能够覆盖所有这些点的最小矩形面积。这个问题难就难在，这个矩形可以倾斜放置（边不必平行于坐标轴）。

    这里的倾斜放置很不好处理，因为我们不知道这个矩形最终会倾斜多少度。假设我们知道这个矩形的倾角是α，那么答案就很简单了：矩形面积最小时四条边一定都挨着某个点。也就是说，四条边的斜率已经都知道了的话，只需要让这些边从外面不断逼近这个点集直到碰到了某个点。你不必知道这个具体应该怎么实现，只需要理解这可以通过某种方法计算出来，毕竟我们的重点在下面的过程。
    我们的算法很显然了：枚举矩形的倾角，对于每一个倾角，我们都能计算出最小的矩形面积，最后取一个最小值。
    这个算法是否是正确的呢？我们不能说它是否正确，因为它根本不可能实现。矩形的倾角是一个实数，它有无数种可能，你永远不可能枚举每一种情况。我们说，矩形的倾角是一个“连续的”变量，它是我们无法枚举这个倾角的根本原因。我们需要一种方法，把这个“连续的”变量变成一个一个的值，变成一个“离散的”变量。这个过程也就是所谓的离散化。
    我们可以证明，最小面积的矩形不但要求四条边上都有一个点，而且还要求至少一条边上有两个或两个以上的点。试想，如果每条边上都只有一个点，则我们总可以把这个矩形旋转一点使得这个矩形变“松”，从而有余地得到更小的矩形。于是我们发现，矩形的某条边的斜率必然与某两点的连线相同。如果我们计算出了所有过两点的直线的倾角，那么α的取值只有可能是这些倾角或它减去90度后的角（直线按“\”方向倾斜时）这么C(n,2)种。我们说，这个“倾角”已经被我们 “离散化”了。虽然这个算法仍然有优化的余地，但此时我们已经达到了本文开头所说的目的。

    对于某些坐标虽然已经是整数（已经是离散的了）但范围极大的问题，我们也可以用离散化的思想缩小这个规模。最近搞模拟赛Vijos似乎火了一把，我就拿两道Vijos的题开刀。
    VOJ1056(http://www.vijos.cn/Problem_Show.asp?id=1056) 永远是离散化的经典问题。大意是给定平面上的n个矩形（坐标为整数，矩形与矩形之间可能有重叠的部分），求其覆盖的总面积。平常的想法就是开一个与二维坐标规模相当的二维Boolean数组模拟矩形的“覆盖”（把矩形所在的位置填上True）。可惜这个想法在这里有些问题，因为这个题目中坐标范围相当大（坐标范围为-10^8到10^8之间的整数）。但我们发现，矩形的数量n<=100远远小于坐标范围。每个矩形会在横纵坐标上各“使用”两个值， 100个矩形的坐标也不过用了-10^8到10^8之间的200个值。也就是说，实际有用的值其实只有这么几个。这些值将作为新的坐标值重新划分整个平面，省去中间的若干坐标值没有影响。我们可以将坐标范围“离散化”到1到200之间的数，于是一个200*200的二维数组就足够了。实现方法正如本文开头所说的“排序后处理”。对横坐标（或纵坐标）进行一次排序并映射为1到2n的整数，同时记录新坐标的每两个相邻坐标之间在离散化前实际的距离是多少。这道题同样有优化的余地。
    最后简单讲一下计算几何以外的一个运用实例（实质仍然是坐标的离散）。才考的VOJ1238(http://www.vijos.cn/Problem_Show.asp?id=1238)中，标程开了一个与时间范围一样大的数组来储存时间段的位置。这种方法在空间上来看十分危险。一旦时间取值范围再大一点，盲目的空间开销将导致Memory Limit Exceeded。我们完全可以采用离散化避免这种情况。我们对所有给出的时间坐标进行一次排序，然后同样用时间段的开始点和结束点来计算每个时刻的游戏数，只是一次性加的经验值数将乘以排序后这两个相邻时间点的实际差。这样，一个1..n的数组就足够了。

    离散化的应用相当广泛，以后你会看到还有很多其它的用途。

2007.04.05补充：
VOJ1056那个例子看来还是有人不明白。
我发一张示意图，注意左边的10*7的数组是如何等价地转化为右边两个4*4的数组的

MiYu 2010-10-15 11:15 发表评论

[翻译]Wine完全使用指南——从基本到高级[转]

MiYu — Tue, 05 Oct 2010 02:28:00 GMT

摘要: 转载自 : http://forum.ubuntu.org.cn/viewtopic.php?t=72933 为了回应最近网友的一些普遍问题，特此作以下说明： 1、如果发现wine的注册表没有相应的键值，要自己创建。有时候用命令不行的话，只能手动一个个添加。 2、wine还是一个不成熟的软件，经常出现bug，一切使用的问题和风险都只能自己承担。 ... 阅读全文

MiYu 2010-10-05 10:28 发表评论

线段树的一种简化实现[转] by 踏雪赤兔

MiYu — Mon, 04 Oct 2010 08:11:00 GMT

转载自 http://www.cnitblog.com/cockerel/archive/2006/09/13/16806.html

相信对算法设计或者数据结构有一定了解的人对线段树都不会太陌生。它是能够在log(MaxLen)时间内完成线段的添加、删除、查询等操作。但一般的实现都有点复杂（我自写的是要递归的，比较多行）。而线段树应用中有一种是专门针对点的。（点树？）它的实现却非常简单。
　　这种数据结构有什么用？我们先来考虑一下下面的需求（全部要求在LogN时间内完成）：如何知道一个点在一个点集里的大小“排名”？很简单，开一个点数组，排个序，再二分查找就行了；如何在一个点集内动态增删点？也很简单，弄个平衡树就行了（本来平衡树比线段树复杂得多，但自从世界上有了STL set这么个好东东，就……^_^）那如果我既要动态增删点，也要随时查询到一个点的排名呢？那对不起，可能就要出动到我们的“点树”了。
　　其实现原理很简单：每当增加（或删除）一个大小为X的点时，就在树上添加（或删除）一条(X,MaxLen)的线段（不含端点），当要查询一个点的排名时，只要看看其上有多少条线段就可以了。针对这一需求，这里有个非常简单的实现（见以下代码，十多行，够短了吧？）其中clear()用于清空点集；add()用于添加一个点；cntLs()返回小于n的点的个数，也就是n的升序排名，类似地cntGt是降序排名。
　　这个点树有什么用呢？其中一个应用时在O(NlogN)时间内求出一个排列的逆序数（http://acm.zju.edu.cn/show_problem.php?pid=1484，你有更好的算法吗？欢迎交流）方法是每读到一个数x，就让逆序数+=cntGt(x);然后再add(x)。
　　这个实现还可以进行一些扩展。比如删除del(int n)，只要把add(int n)中的++size换成--size，把a[i/2]++改成a[i/2]--即可。另外还可以通过二分查找功能在O(logN)时间内查到排名第n的点的大小。应该也可以三四行内搞定。

template < int  N > // 表示可用区间为[0,N)，其中N必须是2的幂数;
class  PointTree {
     int  a[ 2 * N];
     int  size;
     void  clear() { memset( this , 0 , sizeof ( * this ));}
     void  add( int  n) {
         int  i = N + n;  ++ size;
         for ( ++ a[i]; i > 1 ; i /= 2 )
             if ( ~ i & 1 ) a[i / 2 ] ++ ;
    }
     int  cntLs( int  n) { // 统计小于
          int  i = N + n,c = 0 ;  // 若统计小于等于则c=a[i];
          for (; i > 1 ; i /= 2 )
             if (i & 1 ) c += a[i / 2 ];
          return  c;
    }
      int  cntGt( int  n) {  return  size - a[N + n] - cntLs(n); }
} ;

　　嗯~~~为了解http://acm.zju.edu.cn/show_problem.php?pid=2425这一题，还是把上述两个扩展给实现了啦，果然不难：

（接上）
    void del(int n){
        if(!a[n+=N])return;
        --size;
        for(--a[n]; n>1; n/=2)
            if(~n&1)--a[n/2];
    }
    /*  解决：求点集中第i小的数(由0数起)
     *    注意：如果i>=size 返回N-1
     */
    int operator[](int n){
        int i=1;
        while(i<N){
            if(n<a[i]) i*=2;
            else n-=a[i], i=i*2+1;
        }
        return i-N;
    }
};
//附一个测试程序
#include<iostream.h>
T<8192> t;
int main(){
    char c; int n;
    while(cin>>c){
           if(c=='c') t.clear();
           else{
               cin>>n;
               if(c=='a') t.add(n);
               if(c=='d') t.del(n);
               if(c=='q') cout<<t[n]<<endl;
           }
    }

    return 0;
}

求点集里n的个数了!

int cntEQ(int n){
return a[N+n];
}

P.S.：
　　在写完这篇文章一段时间后，我认识了另一种功能上比较类似的数据结构，叫做“树状数组”。它们有不少相似之处：

针对点集的处理（添加、删除、查找）；
相似的时空复杂度（logN时间，2N空间）；
相似的编程复杂度（都比线段树简短得多）；

因此，所有可以用树状数组解决的问题都可以用这个“点树”来解决，另外它还有以下好处：

更直观的转移（个人感受，不一定要同意）；
同时支持自下而上和自上而下两种方向的查找和更新，而后者树状数组不支持，所以树状数组不提供某些功能，比如说O(logN)求点集中第k小数。

posted on 2006-09-13 19:54 踏雪赤兔

MiYu 2010-10-04 16:11 发表评论

Floyd-Warshall算法详解（转）

MiYu — Sat, 25 Sep 2010 12:03:00 GMT

Floyd-Warshall算法，简称Floyd算法，用于求解任意两点间的最短距离，时间复杂度为O(n^3)。我们平时所见的Floyd算法的一般形式如下：

1 void Floyd(){
2     int i,j,k;
3     for(k=1;k<=n;k++)
4         for(i=1;i<=n;i++)
5             for(j=1;j<=n;j++)
6                 if(dist[i][k]+dist[k][j]<dist[i][j])
7                     dist[i][j]=dist[i][k]+dist[k][j];
8 }

注意下第6行这个地方，如果dist[i][k]或者dist[k][j]不存在，程序中用一个很大的数代替。最好写成if(dist[i][k]!=INF && dist[k][j]!=INF && dist[i][k]+dist[k][j] 上面这个形式的算法其实是Floyd算法的精简版，而真正的Floyd算法是一种基于DP(Dynamic Programming)的最短路径算法。
设图G中n 个顶点的编号为1到n。令c [i, j, k]表示从i 到j 的最短路径的长度，其中k 表示该路径中的最大顶点，也就是说c[i,j,k]这条最短路径所通过的中间顶点最大不超过k。因此，如果G中包含边，则c[i, j, 0] =边的长度；若i= j ，则c[i,j,0]=0；如果G中不包含边，则c (i, j, 0)= +∞。c[i, j, n] 则是从i 到j 的最短路径的长度。
对于任意的k>0，通过分析可以得到：中间顶点不超过k 的i 到j 的最短路径有两种可能：该路径含或不含中间顶点k。若不含，则该路径长度应为c[i, j, k-1]，否则长度为 c[i, k, k-1] +c [k, j, k-1]。c[i, j, k]可取两者中的最小值。
状态转移方程：c[i, j, k]=min{c[i, j, k-1], c [i, k, k-1]+c [k, j, k-1]}，k＞0。
这样，问题便具有了最优子结构性质，可以用动态规划方法来求解。

为了进一步理解，观察上面这个有向图：若k=0, 1, 2, 3，则c[1,3,k]= +∞；c[1,3,4]= 28；若k = 5, 6, 7，则c [1,3,k] = 10；若k=8, 9, 10，则c[1,3,k] = 9。因此1到3的最短路径长度为9。
下面通过程序来分析这一DP过程，对应上面给出的有向图：

1 #include <iostream>
2 using namespace std;
3
4 const int INF = 100000;
5 int n=10,map[11][11],dist[11][11][11];
6 void init(){
7     int i,j;
8     for(i=1;i<=n;i++)
9         for(j=1;j<=n;j++)
10             map[i][j]=(i==j)?0:INF;
11     map[1][2]=2,map[1][4]=20,map[2][5]=1;
12     map[3][1]=3,map[4][3]=8,map[4][6]=6;
13     map[4][7]=4,map[5][3]=7,map[5][8]=3;
14     map[6][3]=1,map[7][8]=1,map[8][6]=2;
15     map[8][10]=2,map[9][7]=2,map[10][9]=1;
16 }
17 void floyd_dp(){
18     int i,j,k;
19     for(i=1;i<=n;i++)
20         for(j=1;j<=n;j++)
21             dist[i][j][0]=map[i][j];
22     for(k=1;k<=n;k++)
23         for(i=1;i<=n;i++)
24             for(j=1;j<=n;j++){
25                 dist[i][j][k]=dist[i][j][k-1];
26                 if(dist[i][k][k-1]+dist[k][j][k-1]<dist[i][j][k])
27                     dist[i][j][k]=dist[i][k][k-1]+dist[k][j][k-1];
28             }
29 }
30 int main(){
31     int k,u,v;
32     init();
33     floyd_dp();
34     while(cin>>u>>v,u||v){
35         for(k=0;k<=n;k++){
36             if(dist[u][v][k]==INF) cout<<"+∞"<<endl;
37             else cout<<dist[u][v][k]<<endl;
38         }
39     }
40     return 0;
41 }

输入 1 3
输出 +∞
            +∞
            +∞
            +∞
            28
            10
            10
            10
            9
            9
            9

Floyd-Warshall算法不仅能求出任意2点间的最短路径，还可以保存最短路径上经过的节点。下面用精简版的Floyd算法实现这一过程，程序中的图依然对应上面的有向图。

1 #include <iostream>
2 using namespace std;
3
4 const int INF = 100000;
5 int n=10,path[11][11],dist[11][11],map[11][11];
6 void init(){
7     int i,j;
8     for(i=1;i<=n;i++)
9         for(j=1;j<=n;j++)
10             map[i][j]=(i==j)?0:INF;
11     map[1][2]=2,map[1][4]=20,map[2][5]=1;
12     map[3][1]=3,map[4][3]=8,map[4][6]=6;
13     map[4][7]=4,map[5][3]=7,map[5][8]=3;
14     map[6][3]=1,map[7][8]=1,map[8][6]=2;
15     map[8][10]=2,map[9][7]=2,map[10][9]=1;
16 }
17 void floyd(){
18     int i,j,k;
19     for(i=1;i<=n;i++)
20         for(j=1;j<=n;j++)
21             dist[i][j]=map[i][j],path[i][j]=0;
22     for(k=1;k<=n;k++)
23         for(i=1;i<=n;i++)
24             for(j=1;j<=n;j++)
25                 if(dist[i][k]+dist[k][j]<dist[i][j])
26                     dist[i][j]=dist[i][k]+dist[k][j],path[i][j]=k;
27 }
28 void output(int i,int j){
29     if(i==j) return;
30     if(path[i][j]==0) cout<<j<<' ';
31     else{
32         output(i,path[i][j]);
33         output(path[i][j],j);
34     }
35 }
36 int main(){
37     int u,v;
38     init();
39     floyd();
40     while(cin>>u>>v,u||v){
41         if(dist[u][v]==INF) cout<<"No path"<<endl;
42         else{
43             cout<<u<<' ';
44             output(u,v);
45             cout<<endl;
46         }
47     }
48     return 0;
49 }

输入 1 3
输出 1 2 5 8 6 3

MiYu 2010-09-25 20:03 发表评论

多重背包O(N*V)算法详解（使用单调队列）(转载)

MiYu — Fri, 03 Sep 2010 02:59:00 GMT

摘要: 多重背包O(N*V)算法详解（使用单调队列）多重背包问题：有N种物品和容量为V的背包，若第i种物品，容量为v[i]，价值为w[i]，共有n[i]件。怎样装才能使背包内的物品总价值最大？网上关于“多重背包”的资料倒是不少，但是关于怎么实现O(N*V)算法的资料，真得好少呀，关于“单调队列”那部分算法，又没说明得很清楚，看了几遍没... 阅读全文

MiYu 2010-09-03 10:59 发表评论

fill memset for 小测试

MiYu — Thu, 02 Sep 2010 02:47:00 GMT

摘要: MiYu原创, 转帖请注明 : 转载自 ______________白白の屋做ACM题目的时候 , 经常使用到 fill, memset , for 操作对数据进行初始化操作, 在测试数据不大,而且数组范围也不大的情况下,这几种操作的时间差距不是很明显. 但是!... 阅读全文

MiYu 2010-09-02 10:47 发表评论

学习笔记 -- 关于 STL 中的 heap ( 堆 )

MiYu — Wed, 01 Sep 2010 09:18:00 GMT

摘要: MiYu原创, 转帖请注明 : 转载自 ______________白白の屋 C ++ STL 中与heap 有关的操作有如下几个 : make_heap(), pop_heap(), push_heap(), sort_heap(), is_heap... 阅读全文

MiYu 2010-09-01 17:18 发表评论

STL 学习笔记 ( 二. vector )

MiYu — Tue, 31 Aug 2010 14:12:00 GMT

摘要: MiYu原创, 转帖请注明 : 转载自 ______________白白の屋 vector – 一. vector可以模拟动态数组 – 二. vector的元素可以是任意类型T，但必须具备赋值和拷贝能力（具有public &nb... 阅读全文

MiYu 2010-08-31 22:12 发表评论

STL 学习笔记 ( 一. 概述 )

MiYu — Tue, 31 Aug 2010 13:47:00 GMT

摘要: • MiYu原创, 转帖请注明 : 转载自 ______________白白の屋几种常用的容器: map, vector, list, queue,stack, string ( 这个字符串也算个容器 ) STL容器的共通操作 –一. 初始化（initi... 阅读全文

MiYu 2010-08-31 21:47 发表评论

标准模板库(STL)学习---List容器 ( 转载 )

MiYu — Mon, 30 Aug 2010 03:31:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

定义一个list

　　我们可以象这样来定义一个STL的list： 

#include ＜string＞
#include ＜list＞
int main (void) 
{
　list＜string＞ Milkshakes;
　return 0;
}

　　这就行了，你已经定义了一个list。简单吗？list＜string＞ Milkshakes这句是你声明了list＜string＞模板类 的一个实例，然后就是实例化该类的一个对象。但是我们别急着做这个。在这一步其实你只需要知道你定义了 一个字符串的list。你需要包含提供STL list类的头文件。我用gcc 2.7.2在我的Linux上编译这个测试程序，例如： 

　　g++ test1.cpp -o test1 注意iostream.h这个头文件已经被STL的头文件放弃了。这就是为什么这个例子中没有它的原因。 

　　现在我们有了一个list，我们可以看实使用它来装东西了。我们将把一个字符串加到这个list里。有一个非常 重要的东西叫做list的值类型。值类型就是list中的对象的类型。在这个例子中,这个list的值类型就是字符串,string ， 这是因为这个list用来放字符串。 

　　使用list的成员函数push_back和push_front插入一个元素到list中：

#include ＜string＞
#include ＜list＞

int main (void) 
{
　list＜string＞ Milkshakes;
　Milkshakes.push_back("Chocolate");
　Milkshakes.push_back("Strawberry");
　Milkshakes.push_front("Lime");
　Milkshakes.push_front("Vanilla");
　return 0;
}

　　我们现在有个4个字符串在list中。list的成员函数push_back()把一个对象放到一个list的后面，而 push_front()把对象放到前面。我通常把一些错误信息push_back()到一个list中去，然后push_front()一个标题到list中， 这样它就会在这个错误消息以前打印它了。

The list member function empty()list的成员函数empty()

　　知道一个list是否为空很重要。如果list为空，empty()这个成员函数返回真。 我通常会这样使用它。通篇程序我都用push_back()来把错误消息放到list中去。然后，通过调用empty() 我就可以说出这个程序是否报告了错误。如果我定义了一个list来放信息，一个放警告，一个放严重错误， 我就可以通过使用empty()轻易的说出到底有那种类型的错误发生了。 

　　我可以整理这些list，然后在打印它们之前，用标题来整理它们，或者把它们排序成类。 

/*
|| Using a list to track and report program messages and status 
*/
#include ＜iostream.h＞
#include ＜string＞
#include ＜list＞
int main (void) 
{
　#define OK 0 
　#define INFO 1
　#define WARNING 2
　int return_code;
　list＜string＞ InfoMessages;
　list＜string＞ WarningMessages;

　// during a program these messages are loaded at various points
　InfoMessages.push_back("Info: Program started");
　// do work...
　WarningMessages.push_back("Warning: No Customer records have been found");
　// do work...

　return_code = OK; 

　if (!InfoMessages.empty()) {
　　// there were info messages
　　InfoMessages.push_front("Informational Messages:");
　　// ... print the info messages list, we'll see how later
　　return_code = INFO;
　}

　if (!WarningMessages.empty()) {
　　// there were warning messages
　　WarningMessages.push_front("Warning Messages:");
　　// ... print the warning messages list, we'll see how later
　　return_code = WARNING; 
　}

　// If there were no messages say so.
　if (InfoMessages.empty() && WarningMessages.empty()) {
　　cout ＜＜ "There were no messages " ＜＜ endl;
　}

　return return_code;
}

用for循环来处理list中的元素

　　我们想要遍历一个list，比如打印一个中的所有对象来看看list上不同操作的结果。要一个元素一个元素的遍历一个list， 我们可以这样做： 

/*
|| How to print the contents of a simple STL list. Whew! 
*/
#include ＜iostream.h＞
#include ＜string＞
#include ＜list＞

int main (void) 
{
　list＜string＞ Milkshakes;
　list＜string＞::iterator MilkshakeIterator;

　Milkshakes.push_back("Chocolate");
　Milkshakes.push_back("Strawberry");
　Milkshakes.push_front("Lime");
　Milkshakes.push_front("Vanilla");

　// print the milkshakes
　Milkshakes.push_front("The Milkshake Menu");
　Milkshakes.push_back("*** Thats the end ***");
　for (MilkshakeIterator=Milkshakes.begin(); MilkshakeIterator!=Milkshakes.end(); ++MilkshakeIterator) 
　{
　　// dereference the iterator to get the element
　　cout ＜＜ *MilkshakeIterator ＜＜ endl;
　} 
}

　　这个程序定义了一个iterator，MilkshakeIterator。我们把它指向了这个list的第一个元素。 这可以调用Milkshakes.begin()来作到，它会返回一个指向list开头的iterator。然后我们把它和Milkshakes.end()的 返回值来做比较，当我们到了那儿的时候就停下来。 

　　容器的end()函数会返回一个指向容器的最后一个位置的iterator。当我们到了那里，就停止操作。 我们不能不理容器的end()函数的返回值。我们仅知道它意味着已经处理到了这个容器的末尾，应该停止处理了。 所有的STL容器都要这样做。 

　　在上面的例子中，每一次执行for循环，我们就重复引用iterator来得到我们打印的字符串。 

　　在STL编程中，我们在每个算法中都使用一个或多个iterator。我们使用它们来存取容器中的对象。 要存取一个给定的对象，我们把一个iterator指向它，然后间接引用这个iterator。 

　　这个list容器，就象你所想的，它不支持在iterator加一个数来指向隔一个的对象。 就是说，我们不能用Milkshakes.begin()+2来指向list中的第三个对象，因为STL的list是以双链的list来实现的， 它不支持随机存取。vector和deque(向量和双端队列)和一些其他的STL的容器可以支持随机存取。 

　　上面的程序打印出了list中的内容。任何人读了它都能马上明白它是怎麽工作的。它使用标准的iterator和标准 的list容器。没有多少程序员依赖它里面装的东西， 仅仅是标准的C++。这是一个向前的重要步骤。这个例子使用STL使我们的软件更加标准。 

用STL的通用算法for_each来处理list中的元素

　　使用STL list和 iterator，我们要初始化、比较和给iterator增量来遍历这个容器。STL通用的for_each 算法能够减轻我们的工作。 

/*
|| How to print a simple STL list MkII
*/
#include ＜iostream.h＞
#include ＜string＞
#include ＜list＞
#include ＜algorithm＞

PrintIt (string& StringToPrint) {
　cout ＜＜ StringToPrint ＜＜ endl;
}

int main (void) {
　list＜string＞ FruitAndVegetables;
　FruitAndVegetables.push_back("carrot");
　FruitAndVegetables.push_back("pumpkin");
　FruitAndVegetables.push_back("potato");
　FruitAndVegetables.push_front("apple");
　FruitAndVegetables.push_front("pineapple");

　for_each (FruitAndVegetables.begin(), FruitAndVegetables.end(), PrintIt);
}

　　在这个程序中我们使用STL的通用算法for_each()来遍历一个iterator的范围，然后调用PrintIt()来处理每个对象。 我们不需要初始化、比较和给iterator增量。for_each()为我们漂亮的完成了这些工作。我们执行于对象上的 操作被很好的打包在这个函数以外了，我们不用再做那样的循环了，我们的代码更加清晰了。 

　　for_each算法引用了iterator范围的概念，这是一个由起始iterator和一个末尾iterator指出的范围。 起始iterator指出操作由哪里开始，末尾iterator指明到哪结束，但是它不包括在这个范围内。
 用STL的通用算法count()来统计list中的元素个数

　　STL的通用算法count()和count_it()用来给容器中的对象记数。就象for_each()一样，count()和count_if() 算法也是在iterator范围内来做的。 

　　让我们在一个学生测验成绩的list中来数一数满分的个数。这是一个整型的List。 

/*
|| How to count objects in an STL list
*/
#include ＜list＞
#include ＜algorithm＞
#
int main (void) 
{
　list＜int＞ Scores;
　#
　Scores.push_back(100); Scores.push_back(80);
　Scores.push_back(45); Scores.push_back(75);
　Scores.push_back(99); Scores.push_back(100);
　#
　int NumberOf100Scores(0); 
　count (Scores.begin(), Scores.end(), 100, NumberOf100Scores);
　#
　cout ＜＜ "There were " ＜＜ NumberOf100Scores ＜＜ " scores of 100" ＜＜ endl;
}

　　count()算法统计等于某个值的对象的个数。上面的例子它检查list中的每个整型对象是不是100。每次容器中的对象等于100，它就给NumberOf100Scores加1。这是程序的输出： 

There were 2 scores of 100

用STL的通用算法count_if()来统计list中的元素个数

　　count_if()是count()的一个更有趣的版本。他采用了STL的一个新组件，函数对象。count_if() 带一个函数对象的参数。函数对象是一个至少带有一个operator()方法的类。有些STL算法作为参数接收 函数对象并调用这个函数对象的operator()方法。 

　　函数对象被约定为STL算法调用operator时返回true或false。它们根据这个来判定这个函数。举个例子会 说的更清楚些。count_if()通过传递一个函数对象来作出比count()更加复杂的评估以确定一个对象是否应该被 记数。在这个例子里我们将数一数牙刷的销售数量。我们将提交包含四个字符的销售码和产品说明的销售记录。 

/*
|| Using a function object to help count things
*/
#include ＜string＞
#include ＜list＞
#include ＜algorithm＞

const string ToothbrushCode("0003");

class IsAToothbrush 
{
　public: 
　　bool operator() ( string& SalesRecord ) 
　　{
　　　return SalesRecord.substr(0,4)==ToothbrushCode;
　　} 
};

int main (void) 
{
　list＜string＞ SalesRecords;

　SalesRecords.push_back("0001 Soap");
　SalesRecords.push_back("0002 Shampoo");
　SalesRecords.push_back("0003 Toothbrush");
　SalesRecords.push_back("0004 Toothpaste");
　SalesRecords.push_back("0003 Toothbrush");

　int NumberOfToothbrushes(0); 
　count_if (SalesRecords.begin(), SalesRecords.end(), 
　IsAToothbrush(), NumberOfToothbrushes);

　cout ＜＜ "There were " 
　＜＜ NumberOfToothbrushes 
　＜＜ " toothbrushes sold" ＜＜ endl;
}

　　这是这个程序的输出： 

　　There were 2 toothbrushes sold 这个程序是这样工作的：定义一个函数对象类IsAToothbrush，这个类的对象能判断出卖出的是否是牙刷 。如果这个记录是卖出牙刷的记录的话，函数调用operator()返回一个true，否则返回false。 

　　count_if()算法由第一和第二两个iterator参数指出的范围来处理容器对象。它将对每个 IsAToothbrush()返回true的容器中的对象增加NumberOfToothbrushes的值。 

　　最后的结果是NumberOfToothbrushes这个变量保存了产品代码域为"0003"的记录的个数，也就是牙刷的个数。 

　　注意count_if()的第三个参数IsAToothbrush()，它是由它的构造函数临时构造的一个对象。你可以把IsAToothbrush类的一个临时对象 传递给count_if()函数。count_if()将对该容器的每个对象调用这个函数。 
 
使用count_if()的一个更加复杂的函数对象

　　我们可以更进一步的研究一下函数对象。假设我们需要传递更多的信息给一个函数对象。我们不能通过 调用operator来作到这点，因为必须定义为一个list的中的对象的类型。 然而我们通过为IsAToothbrush指出一个非缺省的构造函数就可以用任何我们所需要的信息来初始化它了。 例如，我们可能需要每个牙刷有一个不定的代码。我们可以把这个信息加到下面的函数对象中： 

/*
|| Using a more complex function object
*/
#include ＜iostream.h＞
#include ＜string＞
#include ＜list＞
#include ＜algorithm＞

class IsAToothbrush 
{
　public:
　　IsAToothbrush(string& InToothbrushCode) : 
　　ToothbrushCode(InToothbrushCode) {}
　　bool operator() (string& SalesRecord) 
　　{
　　　return SalesRecord.substr(0,4)==ToothbrushCode;
　　} 
　private:
　　string ToothbrushCode; 
};

int main (void) 
{
　list＜string＞ SalesRecords;

　SalesRecords.push_back("0001 Soap");
　SalesRecords.push_back("0002 Shampoo");
　SalesRecords.push_back("0003 Toothbrush");
　SalesRecords.push_back("0004 Toothpaste");
　SalesRecords.push_back("0003 Toothbrush");

　string VariableToothbrushCode("0003");

　int NumberOfToothbrushes(0); 
　count_if (SalesRecords.begin(), SalesRecords.end(), 
　IsAToothbrush(VariableToothbrushCode),
　NumberOfToothbrushes);
　cout ＜＜ "There were "
　＜＜ NumberOfToothbrushes 
　＜＜ " toothbrushes matching code "
　＜＜ VariableToothbrushCode
　＜＜ " sold" 
　＜＜ endl;
}

　　程序的输出是： 

　　There were 2 toothbrushes matching code 0003 sold 这个例子演示了如何向函数对象传递信息。你可以定义任意你想要的构造函数，你可以再函数对象中做任何你 想做的处理，都可以合法编译通过。 

　　你可以看到函数对象真的扩展了基本记数算法。 

MiYu 2010-08-30 11:31 发表评论

线段树入门 (zz)

MiYu — Sun, 29 Aug 2010 13:22:00 GMT

摘要: 从简单说起，线段树其实可以理解成一种特殊的二叉树。但是这种二叉树较为平衡，和静态二叉树一样，都是提前已经建立好的树形结构。针对性强，所以效率要高。这里又想到了一句题外话：动态和静态的差别。动态结构较为灵活，但是速度较慢；静态结构节省内存，速度较快。接着回到线段树上来，线段树是建立在线段的基础上，每个结点都代表了一条线段 [a , b]。长度为1的线段成为元线段。非元线段都有两个子结点，左... 阅读全文

MiYu 2010-08-29 21:22 发表评论

霍夫曼编码

MiYu — Fri, 27 Aug 2010 11:20:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

代码霍夫曼编码是一种被广泛应用而且非常有效的数据压缩技术，根据待压缩数据的特征，一个可压缩掉20%~90%。这里考虑的数据指的是字符串序列。要理解霍夫曼编码，先要理解霍夫曼树，即最优二叉树，是一类带权路径长度最短的树。

路径是指从树中一个结点到另一个结点之间的通路，路径上的分支数目称为路径长度。

树的路径长度是从树根到每一个叶子之间的路径长度之和。结点的带权路径长度为从该结点到树根之间的路径长度与该结点权的乘积，树的带权路径长度为树中所有叶子结点的带权路径长度之和.

霍夫曼树是指所有叶子结点的二叉树中带权路径长度最小的二叉树.

当给定了n个叶子结点的权值后，构造出的最优二叉树的结点数目m就确定了，即m=2n-1,所以可用一维结构数组来存储最优二叉树
#define MAXLEAFNUM 50           /*最优二叉树中最大叶子树目*/

struct node{

        char ch;          /*当前结点表示的字符，对于非叶子结点，此域不用*/

        int weight;              /*当前结点的权值*/

        int parent;               /*当前结点的父结点的下标，为0时表示无父结点*/

        int lchild,rchild;       /*当前结点的左，右孩子结点的下标，为0时表示无孩子结点*/

}HuffmanTree[2 * MAXLEAFNUM];

typedef char *HuffmanCode[MAXLEAFNUM + 1]；

/*创建最优二叉树*/

void createHTree(HuffmanTree HT, char *c, int *w, int n)

{

        /*数组c[0..n-1]和w[0..n-1]存放了n个字符及其概率，构造霍夫树HT*/

        int i, s1, s2;

        if (n <= 1)

               return;

        /*根据n个权值构造n棵只有根结点的二叉树*/

        for (i=1; i<=n; i++)

        {

               HT[i].ch = c[i-1];

               HT[i].weight = w[i-1];

               HT[i].parent = HT[i].lchild = HT[i].rchild = 0;     

        }

        for (; i<2*n; ++i)

        {

               HT[i].parent = 0;

               HT[i].lchild = 0;

               HT[i].rchild = 0;

        }

/*构造霍夫曼树*/

        for (i=n+1; i<2*n; i++)

        {

               /*从HT[1..i-1]中选择parent为0且weight最小的两棵树，其序号为s1和s2*/

               select(HT,i-1,s1,s2);

               HT[s1].parent = i;

               HT[s2].parent = i;

               HT[i].lchild = s1;

               HT[i].rchild = s2;

               HT[i].weight = HT[s1].weight + HT[s2].weight;

        }

}
复制代码
霍夫曼算法(构造靍夫曼树)
　　对应于霍夫曼树的算法也叫做霍夫曼算法。此算法的思想是：
　　（1）设给定的一组权值为{W1，W2，W3，……Wn}，据此生成森林F={T1，T2，T3，……Tn},F 中的每棵二叉树只有一个带权为W1的根节点（i=1，2，……n）。
　　（2）在F中选取两棵根节点的权值最小和次小的二叉树作为左右构造一棵新的二叉树，新二叉树根节点的权值为其左、右子树根节点的权值之和。
　　（3）在F中删除这两棵最小和次小的二叉树，同时将新生成的二叉树并入森林中。
　　（4）重复（2）（3）过程直到F中只有一棵二叉树为止。
霍夫曼树的应用非常广，在不同的应用中叶子节点的权值可以作不同的解释。霍夫曼树应用于信息编码中，权值可以看成某个符号出现的频率；应用到判定过程中，权值可以看成某类数据出现的频率；应用到排序过程中，权值可以看成是已排好次序而等待合并的序列长度等。

应用霍夫曼编码

        假设有一个包含100 000个字符的数据文件要压缩存储。各字符在该文件中的出现频度见表1。仅有6种不同字符出现过，字符a出现了45000次。

                    a       b      c      d       e       f

频度（千字）   45     13     12     16      9       5

固定代码字      000   001   010    011   100    101

变长代码字      0      101   100   111    1101   1100

表1   一个字符编码问题。大小为100 000个字符的一个数据文件仅包含字符a~f，每个字符出现的频度如表中所示。如果对每个字符赋予一个三位的编码，则该文件可被编码为300000位。如果利用表中的可变长度编码，该文件可被编码为224000位。

可以用很多种方式来表示这样一个文件。采用固定长度编码，则需要三位二进制数字来表示六个字符：a=000，b=001，…，f=101。这种方法需要300 000来对整个原文件编码。

MiYu 2010-08-27 19:20 发表评论

常用算法讲解---迭代法

MiYu — Fri, 27 Aug 2010 11:18:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

代码

要使计算机能完成人们预定的工作，首先必须为如何完成预定的工作设计一个算法，然后再根据算法编写程序。计算机程序要对问题的每个对象和处理规则给出正确详尽的描述，其中程序的数据结构和变量用来描述问题的对象，程序结构、函数和语句用来描述问题的算法。算法数据结构是程序的两个重要方面。
算法是问题求解过程的精确描述，一个算法由有限条可完全机械地执行的、有确定结果的指令组成。指令正确地描述了要完成的任务和它们被执行的顺序。计算机按算法指令所描述的顺序执行算法的指令能在有限的步骤内终止，或终止于给出问题的解，或终止于指出问题对此输入数据无解。
通常求解一个问题可能会有多种算法可供选择，选择的主要标准是算法的正确性和可靠性，简单性和易理解性。其次是算法所需要的存储空间少和执行更快等。
算法设计是一件非常困难的工作，经常采用的算法设计技术主要有迭代法、穷举搜索法、递推法、贪婪法、回溯法、分治法、动态规划法等等。另外，为了更简洁的形式设计和藐视算法，在算法设计时又常常采用递归技术，用递归描述算法。
一、迭代法 
     迭代法是用于求方程或方程组近似根的一种常用的算法设计方法。设方程为f(x)=0，用某种数学方法导出等价的形式x=g(x)，然后按以下步骤执行：
（1）   选一个方程的近似根，赋给变量x0；
（2）   将x0的值保存于变量x1，然后计算g(x1)，并将结果存于变量x0；
（3）   当x0与x1的差的绝对值还小于指定的精度要求时，重复步骤（2）的计算。
若方程有根，并且用上述方法计算出来的近似根序列收敛，则按上述方法求得的x0就认为是方程的根。上述算法用C程序的形式表示为：
【算法】迭代法求方程的根
{    x0=初始近似根；
   do {
      x1=x0；
      x0=g(x1)；   /*按特定的方程计算新的近似根*/
      } while ( fabs(x0-x1)>Epsilon)；
   printf(“方程的近似根是%f\n”，x0)；
}
迭代算法也常用于求方程组的根，令
      X=（x0，x1，…，xn-1）
设方程组为：
      xi=gi(X)      (I=0，1，…，n-1)
则求方程组根的迭代算法可描述如下：
【算法】迭代法求方程组的根
   {    for (i=0;i<n;i++)
         x[i]=初始近似根;
      do {
         for (i=0;i<n;i++)
            y[i]=x[i];
         for (i=0;i<n;i++)
            x[i]=gi(X);
         for (delta=0.0,i=0;i<n;i++)
            if (fabs(y[i]-x[i])>delta)      delta=fabs(y[i]-x[i])；
         } while (delta>Epsilon)；
      for (i=0;i<n;i++)
         printf(“变量x[%d]的近似根是 %f”，I，x[i])；
      printf(“\n”)；
   }
   具体使用迭代法求根时应注意以下两种可能发生的情况：
（1）   如果方程无解，算法求出的近似根序列就不会收敛，迭代过程会变成死循环，因此在使用迭代算法前应先考察方程是否有解，并在程序中对迭代的次数给予限制；
（2）   方程虽然有解，但迭代公式选择不当，或迭代的初始近似根选择不合理，也会导致迭代失败。

MiYu 2010-08-27 19:18 发表评论

常用算法讲解---穷举搜索法

MiYu — Fri, 27 Aug 2010 11:13:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

穷举搜索法 
     穷举搜索法是对可能是解的众多候选解按某种顺序进行逐一枚举和检验，并从众找出那些符合要求的候选解作为问题的解。
【问题】   将A、B、C、D、E、F这六个变量排成如图所示的三角形，这六个变量分别取[1，6]上的整数，且均不相同。求使三角形三条边上的变量之和相等的全部解。如图就是一个解。
程序引入变量a、b、c、d、e、f，并让它们分别顺序取1至6的证书，在它们互不相同的条件下，测试由它们排成的如图所示的三角形三条边上的变量之和是否相等，如相等即为一种满足要求的排列，把它们输出。当这些变量取尽所有的组合后，程序就可得到全部可能的解。细节见下面的程序。
【程序1】# include 
void main()
{   int a,b,c,d,e,f;
   for (a=1;a<=6;a++)   
      for (b=1;b<=6;b++)      {
         if (b==a)      continue;
         for (c=1;c<=6;c++)      {
            if (c==a)||(c==b)   continue;
            for (d=1;d<=6;d++)      {
               if (d==a)||(d==b)||(d==c)    continue;
for (e=1;e<=6;e++)      {
   if (e==a)||(e==b)||(e==c)||(e==d)    continue;
f=21-(a+b+c+d+e);
if ((a+b+c==c+d+e))&&(a+b+c==e+f+a))   {
printf(“%6d,a);
   printf(“%4d%4d”,b,f);
   printf(“%2d%4d%4d”,c,d,e);
   scanf(“%*c”);
}
                  }
               }
            }
         }
      }
复制代码
按穷举法编写的程序通常不能适应变化的情况。如问题改成有9个变量排成三角形，每条边有4个变量的情况，程序的循环重数就要相应改变。
   对一组数穷尽所有排列，还有更直接的方法。将一个排列看作一个长整数，则所有排列对应着一组整数。将这组整数按从小到大的顺序排列排成一个整数，从对应最小的整数开始。按数列的递增顺序逐一列举每个排列对应的每个整数，这能更有效地完成排列的穷举。从一个排列找出对应数列的下一个排列可在当前排列的基础上作部分调整来实现。倘若当前排列为1，2，4，6，5，3，并令其对应的长整数为124653。要寻找比长整数124653更大的排列，可从该排列的最后一个数字顺序向前逐位考察，当发现排列中的某个数字比它前一个数字大时，如本例中的6比它的前一位数字4大，这说明还有对应更大整数的排列。但为了顺序从小到大列举出所有的排列，不能立即调整得太大，如本例中将数字6与数字4交换得到的排列126453就不是排列124653的下一个排列。为了得到排列124653的下一个排列，应从已经考察过的那部分数字中选出比数字大，但又是它们中最小的那一个数字，比如数字5，与数字4交换。该数字也是从后向前考察过程中第一个比4大的数字。5与4交换后，得到排列125643。在前面数字1，2，5固定的情况下，还应选择对应最小整数的那个排列，为此还需将后面那部分数字的排列顺序颠倒，如将数字6，4，3的排列顺序颠倒，得到排列1，2，5，3，4，6，这才是排列1，2，4，6，5，3的下一个排列。按以上想法编写的程序如下。
【程序2】# include 
# define SIDE_N   3
# define LENGTH   3
# define VARIABLES   6
int A,B,C,D,E,F;
int *pt[]={&A,&B,&C,&D,&E,&F};
int *side[SIDE_N][LENGTH]={&A,&B,&C,&C,&D,&E,&E,&F,&A};
int side_total[SIDE_N];
main{}
{   int i,j,t,equal;
   for (j=0;j
      *pt[j]=j+1;
   while(1)
   {   for (i=0;i
      {   for (t=j=0;j
            t+=*side[i][j];
         side_total[i]=t;
      }
      for (equal=1,i=0;equal&&i
         if (side_total[i]!=side_total[i+1]   equal=0;
      if (equal)
      {   for (i=1;i
            printf(“%4d”,*pt[i]);
         printf(“\n”);
         scanf(“%*c”);
      }
      for (j=VARIABLES-1;j>0;j--)
         if (*pt[j]>*pt[j-1])   break;
      if (j==0)   break;
      for (i=VARIABLES-1;i>=j;i--)
         if (*pt[i]>*pt[i-1])   break;
      t=*pt[j-1];* pt[j-1] =* pt[i]; *pt[i]=t;
      for (i=VARIABLES-1;i>j;i--,j++)
      {   t=*pt[j]; *pt[j] =* pt[i]; *pt[i]=t;   }
   }
}
复制代码
从上述问题解决的方法中，最重要的因素就是确定某种方法来确定所有的候选解。下面再用一个示例来加以说明。
【问题】   背包问题
问题描述：有不同价值、不同重量的物品n件，求从这n件物品中选取一部分物品的选择方案，使选中物品的总重量不超过指定的限制重量，但选中物品的价值之和最大。
设n个物品的重量和价值分别存储于数组w[ ]和v[ ]中，限制重量为tw。考虑一个n元组（x0，x1，…，xn-1），其中xi=0 表示第i个物品没有选取，而xi=1则表示第i个物品被选取。显然这个n元组等价于一个选择方案。用枚举法解决背包问题，需要枚举所有的选取方案，而根据上述方法，我们只要枚举所有的n元组，就可以得到问题的解。
显然，每个分量取值为0或1的n元组的个数共为2n个。而每个n元组其实对应了一个长度为n的二进制数，且这些二进制数的取值范围为0～2n-1。因此，如果把0～2n-1分别转化为相应的二进制数，则可以得到我们所需要的2n个n元组。
【算法】maxv=0;
for (i=0;i<2n;i++)
{   B[0..n-1]=0;
   把i转化为二进制数，存储于数组B中;
   temp_w=0;
   temp_v=0;
   for (j=0;j
   {   if (B[j]==1)
      {   temp_w=temp_w+w[j];
         temp_v=temp_v+v[j];
      }
      if ((temp_w<=tw)&&(temp_v>maxv))
      {   maxv=temp_v;
         保存该B数组；
      }
   }
}
复制代码

MiYu 2010-08-27 19:13 发表评论

HDOJ 部分分类

MiYu — Thu, 26 Aug 2010 04:08:00 GMT

模拟题, 枚举
1002 1004 1013 1015 1017 1020 1022 1029 1031 1033 1034 1035 1036 1037 1039 1042 1047 1048 1049 1050 1057 1062 1063 1064 1070 1073 1075 1082 1083 1084 1088 1106 1107 1113 1117 1119 1128 1129 1144 1148 1157 1161 1170 1172 1177 1197 1200 1201 1202 1205 1209 1212(大数取模) 1216（链表）1218 1219 1225 1228 1229 1230 1234 1235 1236 1237 1239 1250
1256 1259 1262 1263 1265 1266 1276 1279 1282 1283 1287 1296 1302 1303 1304 1305 1306 1309 1311 1314
复杂模拟

搜索，递归求解
1010 1016 1026 1043(双广) 1044 (BFS+DFS) 1045 1067 1072 1104 1175 1180 1195 1208 1226 1238 1240 1241 1242 1258 1271 1312 1317
博奕
1079

动态规划
1003 1024 1025 1028 1051 1058 1059 1069 1074 1078 1080 1081 1085 1087 1114 1158 1159 1160 1171 1176 1181 1203 1224 1227 1231 1244 1248 1253 1254 1283 1300

数学，递推，规律
1005 1006 1012 1014 1018 1019 1021 1023 1027 1030 1032 1038 1041 1046 1059 1060 1061 1065 1066 1071(微积分) 1097 1098 1099 1100 1108 1110 1112 1124 1130 1131 1132 1134 1141 1143 1152 1155(物理题) 1163 1165 1178 1194 1196(lowbit) 1210 1214 1200 1221 1223 1249 1261 1267 1273 1290 1291 1292 1294 1297 1313 1316
数论
1164 1211 1215 1222 1286 1299

计算几何
1086 1115 1147
贪心
1009 1052 1055 1257

并查集
1198 1213 1232 1272
线段树,离散化
1199 1255
图论
最短路相关的问题 1142 1162 1217 1301
二分图问题 1054 1068 1150 1151 1281
其他
1053 (huffman) 1102(MST) 1116（欧拉回路） 1233(MST) 1269（强连通）
数据结构
1103（堆+模拟）1166（数状树组）1247 1251 1285（Topol） 1298
汉诺塔系列
1207
最近顶点对 1007

1500 DP
1501 DP
1502 DP or 记忆化
1503 DP
1504 模拟
1505 DP
1506 DP
1507 2分匹配
1508 记忆化容易点
1509 模拟
1510 DP
1511 搜索可以过
1512 左偏树
1513 DP
1514 DP
1515 DFS
1516 DP
1517 博奕
1518 搜索
1519 DP（不确定）
1520 树状DP
1521 数学题，母函数什么的。其实都可以过
1522 稳定婚姻
1523 DP
1524 博弈
1525 博弈
1526 Maxflow
1527 博弈
1528 2分匹配
1529 简单题
1530 最大团
1531 差分约束
1532 Maxflow 入门题
1533 KM Or 最小费用流
1534 差分约束
1535 差分约束
1536 博弈
1537 模拟加置换群的理论 CODE可以短些，其实没必要。。。
1538 很有意思的题目。据说是Microsoft亚洲总裁面试的题目
1539 搜索
1540 线段树
1541 树状数组
1542 离散，线段树
1543 线段树
1544 简单的
1545 DP http://acm.hdu.edu.cn/forum/htm_data/18/0608/2050.html
1546 搜索
1547 模拟
1548 模拟
1551 2分答案
1553
1554
1555 简单
1556 技巧。数学
1557 搜索
1558 并查 + 线段判交
1559 DP
1560 减支 + 搜索
1561 树状DP
1562 暴力 between 1000 and 9999
1563 简单
1564 博弈。
1565 状态DP
1566 数学
1567 模拟
1568 大数
1569 最小割
1570 数学
1571 最段路
1572 搜索
1573 数学
1574 DP
1575 2分
1576 数论
1577 模拟，处理精度
1579 记忆化
1580 DP
1582 搜索
1583 模拟
1584 搜索
1585
1586
1587 简单题目
1591 模拟
1592 简单
1593 数学
1594 数学
1595 图论
1596 图论
1597 图论
1598 图论
1599 图论

基础题：1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、1170、1194、1196、1197、1201、1202、1205、1219、1234、1235、1236、1248、1266、1279、1282、1283、1302、1303、1323、1326、1330、1334、1335、1339、1390、1391、1393、1395、1397、1405、1406、1407、1408、1412、1418、1420、1465、1491、1555、1562、1563、1570、1587、1673、1678、1708、1718、1720、1785、1799、1859、1862、1877、1898、1976、1977、1985、1994、2000、2001、2002、2003、2004、2005、2006、2007、2008、2009、2010、2011、2012、2013、2014、2015、2016、2017、2018、2019、2020、2021、2022、2023、2024、2025、2026、2027、2028、2029、2030、2031、2032、2033、2034、2035、2039、2040、2042、2043、2048、2049、2051、2053、2055、2056、2057、2060、2061、2071、2073、2075、2076、2078、2081、2083、2088、2090、2092、2093、2095、2096、2097、2098、2099、2101、2103、2106、2107、2109、2113、2114、2115、2123、2131、2132、2133、2135、2136、2137、2138、2139、2143、2148、2153、2156、2161、2162、2164、2178、2186、2192、2200、2201、2212、2304、2309、2317、2401、2500、2502、2503、2504、2519、2520、2521、2523、2524、2535、2537、2539、2547、2548、2549、2550、2551、2552、2555、2560、2561、2562、2566、2567、2568、2700、2710、

DP：1003、1024、1029、1069、1074、1087、1114、1159、1160、1171、1176、1203、1231、1257、1260、1284、1421、1789、1978、2059、2084、2159、2191、2544、2571、2602、2709、

搜索：1010、1015、1016、1026、1072、1075、1175、1180、1181、1238、1239、1240、1241、1242、1253、1254、1312、1372、1548、1597、1671、1677、1728、1800、1983、2102、2141、2553、2563、2605、2612、2614、1616、2717

贪心：1009、1045、1049、1050、1051、1052、1257、1800、2037、2111、2124、2187、2391、2570

数学题：1018、1065、1071、1115、1141、1162、1212、1220、1492、1593、1701、1722、1798、1840、1999、2036、2080、2086、2089、2105、2108、2134、2303、2393、2438、2529、2547、2548、2552、2554、2601、2603、2701、

递推：1133、1143、1207、1249、1267、1284、1290、1297、1396、1992、1995、1996、2013、2014、2044、2045、2046、2047、2050、2064、2065、2067、2068、2070、2077、2085、2151、2154、2160、2190、2501、2512、2563、2569、2709、2716、

字符串：1020、1039、1043、1062、1073、1075、1088、1113、1161、1200、1251、1256、1288、1321、1328、1379、1804、1860、1982、1984、2017、2024、2025、2026、2027、2043、2052、2054、2072、2074、2087、2131、2137、2140、2163、2203、2206、2352、2500、2549、2564、2565、2567、2572、2609、2607、2707、2708、2719、2721、2723、

大数：1002、1042、1133、1250、1297、1715、1753、1865、2100、

胡搞：1022、1027、1030、1035、1128、1165、1209、1210、1215、1222、1228、1229、1230、1237、1259、1276、1286、1337、1342、1361、1370、1506、1577、1597、1702、1716、1727、1868、1870、1896、1981、1986、1987、1988、1997、1998、1999、2058、2062、2089、2090、2094、2104、2116、2117、2135、2175、2183、2184、2197、2303、2368、2370、2374、2511、2522、2527、2600、2615、2703、2711、2714、2715、2725、

博弈：1077、1404、1517、1524、1525、1527、1536、1564、1729、1730、1846、1847、1848、1849、1850、2147、2149、2176、2177、2188

母函数：1085、1171、1398、2079、2082、2110、2152、2189、2566、

hash：1264、1280、1425、1496、1800、2522、2600、

MiYu 2010-08-26 12:08 发表评论

树状数组小结

MiYu — Wed, 25 Aug 2010 12:19:00 GMT

今天学习了树状数组, 自己小结下 :

简单介绍下树状数组 :

　　树状数组是一个查询和修改复杂度都为log(n)的数据结构，假设数组a[1...n]，那么查询a[1] + …… + a[i]　的时间是log级别的，而且是一个在线的数据结构，支持随时修改某个元素的值，复杂度也为log级别。

来观察一下这个图：

令这棵树的结点编号为C1，C2……Cn。令每个结点的值为这棵树的值的总和，那么容易发现：

C1 = A1

C2 = A1 + A2

C3 = A3

C4 = A1 + A2 + A3 + A4

C5 = A5

C6 = A5 + A6

C7 = A7

C8 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8

……

C16 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8 + A9 + A10 + A11 + A12 + A13 + A14 + A15 + A16

这里有一个有趣的性质，下午推了一下发现：

设节点编号为x，那么这个节点管辖的区间为2^k（其中k为x二进制末尾0的个数）个元素。因为这个区间最后一个元素必然为Ax，所以很明显：

Cn = A(n – 2^k + 1) + …… + An

算这个2^k有一个快捷的办法，定义一个函数如下即可：

int lowbit(int x){

return x & (x ^ (x – 1));

}

当想要查询一个SUM(n)时，可以依据如下算法即可：

step1:　令sum = 0，转第二步；

step2:　假如n <= 0，算法结束，返回sum值，否则sum = sum + Cn，转第三步；

step3: 令n = n – lowbit(n)，转第二步。

可以看出，这个算法就是将这一个个区间的和全部加起来，为什么是效率是log(n)的呢？以下给出证明：

n = n – lowbit(n)这一步实际上等价于将n的二进制的最后一个1减去。而n的二进制里最多有log(n)个1，所以查询效率是log(n)的。

那么修改呢，修改一个节点，必须修改其所有祖先，最坏情况下为修改第一个元素，最多有log(n)的祖先。所以修改算法如下（给某个结点i加上x）：

step1: 当i > n时，算法结束，否则转第二步；

step2: Ci = Ci + x， i = i + lowbit(i)转第一步。

i = i +lowbit(i)这个过程实际上也只是一个把末尾1补为0的过程。

//修改过程必须满足减法规则！

所以整个程序如下：

const int MAX = 50000;

#define lowbit(x) ((x)&(-x))

int com[ MAX + 1 ],N,T;

void modify ( int pos, int val ){

while ( pos <= N ){

com[pos] += val;

pos = pos + lowbit(pos);

}

int quy ( int x ){

int sum = 0;

while ( x > 0 ){

sum = sum + com[x];

x = x - lowbit(x);

}

return sum;

}

初始化 : 　　 for ( int i = 1; i <= N; ++ i ){

scanf ( "%d",&x );

modify ( i, x );

}

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

为什么要用树状数组 ?

原因如下:

| 1. 首先我们得知道一个问题,那就是线段树得作用并

不只是用来存储线段的,也可以存储点的值等等.

| 2. 对于静态的线段树,空间上需要的数组有:当前结点

的数据值,左儿子编号,右儿子编号.至少这么三个数组

3. | 而在时间上虽然是NlogN的复杂度,但是系数很大.|

4. 实现起来的时候编程复杂度大,空间复杂度大,时间

效率也不是很理想.

所以这个时候树状数组成了一个很好的选择.

先看一个例题:

数列操作:

给定一个初始值都为0的序列,动态地修改一些

位置上的数字,加上一个数,减去一个数,或者乘上

一个数,然后动态地提出问题,问题的形式是求出

一段数字的和.

如果直接用朴素方法做的话,修改的复杂度是O(1),

询问的复杂度是O(N),M次询问的复杂度是M*N.

M,N的范围可以有100000以上!!!!

有没有更好的方法???

呵呵, 肯定有啦, 就是我要说的树状数组!!!

具体的树状数组的解释请看上面, 那么这个2^k怎么求? 是怎么

来的?

K的计算可以这样:

|2^k=x and (x & (x-1))

|以6为例

| (6)10=(0110)2

|xor 6-1=(5)10=(0101)2

| (0011)2

|and (6)10=(0110)2

| (0010)2

所以:

由数字的机器码可以更简单的优化成: x & (-x)

对于上面那一题,每次修改与询问都是对C数组做处理.

空间复杂度有3N降为N,时间效率也有所提高.编程复杂

度更是降了不少.

MiYu 2010-08-25 20:19 发表评论

STL MAP 详解 (zz)

MiYu — Wed, 25 Aug 2010 03:53:00 GMT

摘要: MiYu原创, 转帖请注明 : 转载自 ______________白白の屋由于STL是一个统一的整体，map的很多用法都和STL中其它的东西结合在一起；map中由于它内部有序，由红黑树保证，因此很多函数执行的时间复杂度都是log2N的，如果用map函数可以实现的功能，而STL Algorithm也可以完成该功能，... 阅读全文

MiYu 2010-08-25 11:53 发表评论

scanf/sscanf 格式的特殊控制

MiYu — Wed, 25 Aug 2010 03:38:00 GMT

代码scanf中一种很少见但很有用的转换字符：[...]和[ ^...]。
#include<stdio.h>
int main() 
{ 
char strings[100]; 
scanf("%[1234567890]",strings); 
printf("%s",strings);
return 0; 
} 
运行，输入：1234werew后，结果是：1234。
通过运行可以发现它的作用是：如果输入的字符属于方括号内字符串中某个字符，那么就提取该字符；如果一经发现不属于就结束提取。该方法会自动加上一个字符串结束符到已经提取的字符后面。 
scanf("%[^1234567890]",strings); 它的作用是：如果一经发现输入的字符属于方括号内字符串中某个字符，那么就结束提取；如果不属于就提取该字符。该方法会自动加上一个字符串结束符到已经提取的字符后面。 
注意：方括号两边不能空格，如：scanf("%[ 1234567890 ]",strings); scanf("%[ ^1234567890 ]",strings); 不让空格也会算在里面的。
用这种方法还可以解决scanf的输入中不能有空格的问题。只要用
scanf("%[^\n]",strings); 就可以了。很神奇吧。

ANSI C 标准向 scanf() 增加了一种新特性，称为扫描集(scanset)。 扫描集定义一个字符集合，可由 scanf() 读入其中允许的字符并赋给对应字符数组。 扫描集合由一对方括号中的一串字符定义，左方括号前必须缀以百分号。 例如，以下的扫描集使 scanf() 读入字符 A、B 和 C：
    %[ABC]

    使用扫描集时，scanf() 连续吃进集合中的字符并放入对应的字符数组，直到发现不在集合中的字符为止(即扫描集仅读匹配的字符)。返回时，数组中放置以 null 结尾、由读入字符组成的字符串。

    用字符 ^ 可以说明补集。把 ^ 字符放为扫描集的第一字符时，构成其它字符组成的命令的补集合，指示 scanf() 只接受未说明的其它字符。
    对于许多实现来说，用连字符可以说明一个范围。 例如，以下扫描集使 scanf() 接受字母 A 到 Z：
    %[A-Z]
    重要的是要注意扫描集是区分大小写的。因此，希望扫描大、小写字符时，应该分别说明大、小写字母。

搜集一些特殊用法：

%[ ] 的用法：%[ ]表示要读入一个字符集合, 如果[ 后面第一个字符是”^”，则表示反意思。

                     [ ]内的字符串可以是1或更多字符组成。空字符集（%[]）是违反规定的，可

                      导致不可预知的结果。%[^]也是违反规定的。
          
%[a-z] 读取在 a-z 之间的字符串，如果不在此之前则停止，如

              char s[]="hello, my friend” ; // 注意: ,逗号在不 a-z之间

               sscanf( s, “%[a-z]”, string ) ; // string=hello

%[^a-z] 读取不在 a-z 之间的字符串，如果碰到a-z之间的字符则停止，如

               char s[]="HELLOkitty” ; // 注意: ,逗号在不 a-z之间

              sscanf( s, “%[^a-z]”, string ) ; // string=HELLO

%*[^=] 前面带 * 号表示不保存变量。跳过符合条件的字符串。

              char s[]="notepad=1.0.0.1001" ;

       char szfilename [32] = "" ;

       int i = sscanf( s, "%*[^=]", szfilename ) ;
// szfilename=NULL,因为没保存

int i = sscanf( s, "%*[^=]=%s", szfilename ) ;
// szfilename=1.0.0.1001

%40c 读取40个字符

%[^=] 读取字符串直到碰到’=’号，’^’后面可以带更多字符,如：

              char s[]="notepad=1.0.0.1001" ;

              char szfilename [32] = "" ;

             int i = sscanf( s, "%[^=]", szfilename ) ;
           // szfilename=notepad 

        如果参数格式是：%[^=:] ，那么也可以从 notepad:1.0.0.1001读取notepad

MiYu 2010-08-25 11:38 发表评论

牛顿迭代法求解方程

MiYu — Wed, 25 Aug 2010 03:37:00 GMT

摘要: ax^3+bX^2+cx+d=0根的关系:x1 + x2 + x3 = - b / a;x1 * x2 + x1 * x3 + x2 * x3 = c / a;x1 * x2 * x3 = - d / a;牛顿迭代解方程(x0附近的根)01double Newton_Iterative(double a,double b,double c,double&nb... 阅读全文

MiYu 2010-08-25 11:37 发表评论

ZOJ POJ 题目分类

MiYu — Wed, 25 Aug 2010 03:36:00 GMT

ZOJ POJ 题目分类 

ZOJ题目分类
初学者题：

1001 1037 1048 1049 1051 1067 1115 1151 1201 1205 1216 1240 1241 1242 1251 1292 1331 1334 1337 1338 1350 1365 1382 1383 1394 1402 1405 1414 1494 1514 1622 1715 1730 1755 1760 1763 1796 1813 1879 1889 1904 1915 1949 2001 2022 2099 2104 2108 2172 2176 2201 2208 2321 2345 2351 2376 2388 2405 2417 2433 

模拟问题：

1006 1009 1012 1016 1019 1023 1026 1028 1038 1042 1045 1051 1056 1057 1058 1061 1065 1066 1068 1072 1073 1078 1087 1088 1097 1098 1099 1103 1111 1121 1124 1126 1128 1133 1138 1146 1152 1154 1160 1175 1178 1187 1194 1207 1222 1224 1244 1259 1267 1274 1275 1277 1278 1279 1281 1282 1294 1295 1300 1308 1317 1324 1339 1351 1362 1392 1393 1397 1398 1399 1400 1402 1432 1434 1444 1452 1475 1487 1493 1497 1517 1526 1527 1530 1531 1552 1569 1573 1592 1601 1610 1623 1631 1641 1652 1657 1659 1682 1692 1700 1702 1707 1708 1712 1728 1732 1737 1746 1747 1750 1752 1754 1758 1764 1768 1774 1797 1799 1804 1807 1811 1822 1824 1831 1834 1837 1838 1842 1844 1845 1854 1858 1862 1870 1881 1884 1889 1896 1906 1921 1951 1969 1978 2000 2022 2040 2046 2047 2051 2072 2084 2101 2112 2131 2133 2138 2148 2153 2156 2160 2164 2172 2178 2184 2185 2187 2189 2193 2196 2201 2204 2208 2211 2212 2220 2229 2233 2239 2240 2261 2262 2269 2277 2288 2301 2309 2311 2312 2316 2320 2321 2322 2328 2330 2350 2389 2405 2410 2414 2420 2421 2483 2508 2560 2569 2572 2593 2613 2617 2680 2681 2731 2732 2743 

动态规划：

1013 1022 1025 1027 1074 1076 1093 1094 1100 1107 1108 1136 1149 1183 1196 1200 1206 1227 1234 1245 1249 1250 1276 1303 1346 1353 1366 1368 1387 1424 1425 1428 1446 1448 1449 1454 1459 1462 1463 1470 1474 1475 1483 1484 1490 1499 1503 1512 1515 1520 1524 1539 1540 1554 1563 1567 1579 1602 1607 1611 1629 1638 1642 1651 1666 1695 1713 1717 1731 1733 1736 1738 1743 1756 1757 1787 1792 1800 1819 1853 1864 1877 1880 1893 1913 1918 1925 1953 1985 1986 1988 1991 1995 2002 2014 2025 2042 2058 2059 2067 2068 2069 2081 2096 2127 2136 2142 2144 2156 2180 2189 2202 2206 2213 2224 2227 2242 2244 2254 2255 2264 2271 2278 2280 2281 2283 2284 2297 2319 2337 2338 2341 2349 2353 2354 2366 2372 2374 2397 2401 2402 2414 2422 2424 2432 2498 2501 2521 2522 2527 2536 2547 2561 2563 2565 2568 2581 2591 2598 2604 2621 2624 2625 2626 2641 2642 2667 2673 2683 2685 2692 2702 2710 2711 2734 2739 2744 2745 

字符串处理问题：

1002 1004 1005 1008 1016 1019 1046 1048 1049 1050 1051 1052 1053 1054 1055 1056 1061 1063 1086 1089 1091 1094 1099 1101 1103 1111 1115 1117 1118 1120 1123 1125 1126 1129 1130 1136 1139 1143 1150 1151 1152 1154 1159 1160 1168 1170 1177 1178 1179 1180 1181 1184 1188 1189 1190 1191 1192 1195 1197 1243 1295 1315 1325 1392 1582 1698 1707 1720 1729 1808 1831 1854 1858 1905 1963 1969 1970 1984 

搜索问题： 

1002 1003 1008 1031 1038 1039 1041 1060 1063 1069 1080 1083 1088 1089 1103 1144 1155 1190 1204 1217 1229 1249 1297 1301 1344 1355 1361 1412 1415 1435 1443 1457 1479 1505 1518 1530 1593 1649 1671 1675 1686 1709 1711 1719 1742 1832 1909 1935 1940 1977 1984 2031 2033 2043 2053 2093 2103 2110 2128 2165 2233 2241 2252 2276 2288 2355 2372 2374 2412 2416 2418 2437 2440 2442 2466 2471 2475 2477 2509 2515 2531 2534 2580 2588 2594 2631 2633 2688 

数论问题：

1007 1028 1088 1113 1133 1160 1222 1278 1284 1312 1314 1385 1489 1526 1530 1569 1577 1596 1601 1652 1657 1712 1797 1842 1889 1906 1951 2000 2022 2028 2060 2095 2105 2156 2189 2212 2233 2277 2288 2305 2316 2320 2330 2360 2371 2400 2410 2414 

几何问题：

1010 1032 1037 1041 1081 1090 1104 1123 1139 1165 1199 1426 1439 1460 1472 1597 1608 1648 1683 1910 2015 2102 2107 2157 2228 2234 2318 2335 2347 2352 2361 2370 2375 2394 2403 

树型结构问题：

1011 1038 1043 1062 1141 1159 1167 1203 1319 1335 1387 1406 1481 1511 1542 1586 1610 1635 1674 1700 1752 1788 1805 1809 1900 1944 1955 1959 1965 1990 2243 2425 

图表问题：

1015 1030 1082 1084 1085 1105 1119 1127 1130 1140 1203 1311 1377 1420 1453 1465 1492 1589 1798 1802 1919 1935 2016 2236 2238 2281 2326 

匹配问 题： 

1002 1059 1077 1137 1140 1157 1197 1231 1364 1516 1525 1576 1626 1654 1882 2067 2192 2221 2223 2333 2362 2404


pku题目分类 
麻 烦题：
1697, 1712, 1713, 1720, 1729, 1765, 1772, 1858, 1872, 1960, 1963, 2050, 2122, 2162, 2219, 2237,

简单题目：
1000, 1003, 1004, 1005, 1007, 1046, 1207, 1226, 1401, 1504, 1552, 1607, 1657, 1658, 1674, 1799, 1862, 1906, 1922, 1929, 1931, 1969, 1976, 2000, 2005, 2017, 2027, 2070, 2101, 2105, 2109, 2116, 2136, 2160, 2190, 2232, 2234, 2275, 2301, 2350, 2363, 2389, 2393, 2413, 2419, 
推荐：
1063, 1064, 1131, 1140, 1715, 2163, 

杂题：
1014, 1218, 1316, 1455, 1517, 1547, 1580, 1604, 1663, 1678, 1749, 1804, 2013, 2014, 2056, 2059, 2100, 2188, 2189, 2218, 2229, 2249, 2290, 2302, 2304, 2309, 2313, 2316, 2323, 2326, 2368, 2369, 2371, 2402, 2405, 2407, 
推荐：
1146, 1147, 1148, 1171, 1389, 1433, 1468, 1519, 1631, 1646, 1672, 1681, 1700, 1701, 1705, 1728, 1735, 1736, 1752, 1754, 1755, 1769, 1781, 1787, 1796, 1797, 1833, 1844, 1882, 1933, 1941, 1978, 2128, 2166, 2328, 2383, 2420, 

高精度：
1001, 1220, 1405, 1503, 

排序：
1002, 1318, 1877, 1928, 1971, 1974, 1990, 2001, 2002, 2092, 2379, 2388, 2418, 
推荐：
1423, 1694, 1723, 1727, 1763, 1788, 1828, 1838, 1840, 2201, 2376, 2377, 2380, 

搜索
容易：
1128, 1166, 1176, 1231, 1256, 1270, 1321, 1543, 1606, 1664, 1731, 1742, 1745, 1847, 1915, 1950, 2038, 2157, 2182, 2183, 2381, 2386, 2426, 
不易：
1024, 1054, 1117, 1167, 1708, 1746, 1775, 1878, 1903, 1966, 2046, 2197, 2349, 
推荐：
1011, 1190, 1191, 1416, 1579, 1632, 1639, 1659, 1680, 1683, 1691, 1709, 1714, 1753, 1771, 1826, 1855, 1856, 1890, 1924, 1935, 1948, 1979, 1980, 2170, 2288, 2331, 2339, 2340, 

数据结构
容易：
1182, 1656, 2021, 2023, 2051, 2153, 2227, 2236, 2247, 2352, 2395, 
不易：
1145, 1177, 1195, 1227, 1661, 1834, 
推荐：
1330, 1338, 1451, 1470, 1634, 1689, 1693, 1703, 1724, 1988, 2004, 2010, 2119, 2274, 

动态规划
容 易：
1018, 1050, 1083, 1088, 1125, 1143, 1157, 1163, 1178, 1179, 1189, 1208, 1276, 1322, 1414, 1456, 1458, 1609, 1644, 1664, 1690, 1699, 1740, 1742, 1887, 1926, 1936, 1952, 1953, 1958, 1959, 1962, 1975, 1989, 2018, 2029, 2033, 2063, 2081, 2082, 2181, 2184, 2192, 2231, 2279, 2329, 2336, 2346, 2353, 2355, 2356, 2385, 2392, 2424, 
不易：
1019, 1037, 1080, 1112, 1141, 1170, 1192, 1239, 1655, 1695, 1707, 1733, 1737, 1837, 1850, 1920, 1934, 1937, 1964, 2039, 2138, 2151, 2161, 2178, 
推荐：
1015, 1635, 1636, 1671, 1682, 1692, 1704, 1717, 1722, 1726, 1732, 1770, 1821, 1853, 1949, 2019, 2127, 2176, 2228, 2287, 2342, 2374, 2378, 2384, 2411, 

字 符串：
1488, 1598, 1686, 1706, 1747, 1748, 1750, 1760, 1782, 1790, 1866, 1888, 1896, 1951, 2003, 2121, 2141, 2145, 2159, 2337, 2359, 2372, 2406, 2408, 

贪心：
1042, 1065, 1230, 1323, 1477, 1716, 1784, 

图 论
容易：
1161, 1164, 1258, 1175, 1308, 1364, 1776, 1789, 1861, 1939, 1940, 1943, 2075, 2139, 2387, 2394, 2421, 
不易：
1041, 1062, 1158, 1172, 1201, 1275, 1718, 1734, 1751, 1904, 1932, 2173, 2175, 2296, 
网络 流：
1087, 1273, 1698, 1815, 2195, 
匹配：
1274, 1422, 1469, 1719, 2060, 2239, 
Euler：
1237, 1637, 1394, 2230, 
推荐：
2049, 2186, 

计算几何
容易：
1319, 1654, 1673, 1675, 1836, 2074, 2137, 2318, 
不 易：
1685, 1687, 1696, 1873, 1901, 2172, 2333, 
凸包：
1113, 1228, 1794, 2007, 2187, 

模拟
容易：
1006, 1008, 1013, 1016, 1017, 1169, 1298, 1326, 1350, 1363, 1676, 1786, 1791, 1835, 1970, 2317, 2325, 2390, 
不易：
1012, 1082, 1099, 1114, 1642, 1677, 1684, 1886, 

数 学
容易：
1061, 1091, 1142, 1289, 1305, 1306, 1320, 1565, 1665, 1666, 1730, 1894, 1914, 2006, 2042, 2142, 2158, 2174, 2262, 2305, 2321, 2348, 
不 易：
1067, 1183, 1430, 1759, 1868, 1942, 2167, 2171, 2327, 
推荐：
1423, 1450, 1640, 1702, 1710, 1721, 1761, 1830, 1930, 2140,

MiYu 2010-08-25 11:36 发表评论

HDOJ 题目分类

MiYu — Wed, 25 Aug 2010 03:36:00 GMT

HDOJ 题目分类 
/*
 * 一:简单题
 */ 
1000：    入门用；
1001：    用高斯求和公式要防溢出
1004：1012：
1013：    对9取余好了
1017：1021：
1027：    用STL中的next_permutation（）
1029：1032：1037：1039：1040：1056：1064：1065：
1076：    闰年
1084：
1085：
1089，1090，1091，1092，1093，1094， 1095， 1096：全是A+B
1108：1157：1196：
1197：    进制
1202：1215：1219：1228：1229：1234：1235：1236：1256：1259：1262：1279：1280：1283：
1239：
1321：1395：1406：
1407：    因为xyz是对称的，所以yz没必要从1开始找起
1408：1412：1420：
1425：    n^2的复杂度是被卡掉了的
1562：1587：1594：1701：1713：1718：1785：1860：1862：1877：1976：1984：1985：
HDU 11页 入门必做
2101：2304：2309：2502：2503：2504：2519：2520：2547：2548：2549：2550：2561：2562：2564：2565：
2566：2567：2568：2950：2959：3040：


/*
 * 二:图论
 */ 
//1.搜索：
*1010：搜索    
1015： 搜索        5个for暴力也可以?????
*1016：搜索    
*1072：搜索：    bfs过
1240：搜 索        最基本的bfs,三维而已，注意输入坐标是x,y,z,但map[z][y][x] 
*1241：搜索
*1242：搜 索
1253：搜索        bfs,bfs走出来的路是最短的
*1312：搜索
*1342：搜索        dfs可以，6个for也可以
1372：搜索        太经典了,8 个方向bfs 
*1496：搜索        很好的一个题
*1548：搜索||图论        一维上的bfs,开始走过的没标记，导致mle，以为stl没优化好，自己写了个动态分配的链队还是mle，后来标记重新submit证明用stl的内 存比自己写的链队要小...；据说最短路也可以做~
*1728：搜索
*2181: 搜索
*2660：搜索
*2952：搜索 
2717：搜索        bfs,注意走过的要标记，否则mle
* 2102：搜索
//2.最小生成树
？1102：    最小生成树
？1162： 最小生成树
*1233：    最小生成树
*1301：    最小生成树
*1875：    最小生成树
1863：    最小生成树
//3.最短路
*1690：        最短路
*1874：        最短路
*2544：        最短路
//4.并查
*1213：        并查
*1232：        并查
*1272：并查
*1856：    并查 
//5.其他
1053：        Huffman树
1285：         top排序
*1878：        欧拉回路
*3118：        二分图


/*
 * 三.字符串：
 */ 
1020 1048 1062 1088 1106 1113 1161 1200 1591 1870 1982 2140 2203   s1连两个
2206   这题数据很叼专
2265 2487 2673 3125
*1686    kmp
*1075    字典树 
*1181    字典树
*1800   字典树    据说hash也可以过
1804
*1251   字典树


/*
 *四:模拟题：
 */ 
1008：
*1022：    模拟栈
1049：1170：
1237：    队，加减入队，乘除算出来
*1873：2816：2832：2919：2957：1702：


/*
 * 五.数论：
 */ 
1014：        互质就行，和1222相似
1019：        多个数的lcm
？1098：    
1222：        同 1014，互质就行
3123：
？2854：        打表过的


/*
 * 六.计算几何：
 */ 
？1086：线 段交点 
？1115：    多边形重心
1221：    圆和矩形相交
*1392：        凸包
？2105： 多边形的重心
？2108：    判断多边形的凹凸性 
？2202：    凸包 
？2857：    对称问题
？3124： 投机过的


/*
 * 七.数学题:
 */ 
1005：    看出有周期
？1018：    striling公式求阶乘的位数
？1023：    Catalan数求出栈种数
？1060：    leftmost digit
？1061：    rightmost digit
1071：    积分 
？1130：    Catalan数求二叉树的种数
？1133：    Catalan数应用
？1134：    Catalan数
？1178：    求指数底数 
1205：    1239：？1249：？1290：
？1465： 错排
？1466：1555：1570：
1593：    找同心圆
？1597：1703：1717：1798：？2114：？2200：2289：？2501：？2563：？2569：？2922：


/*
 * 八.DP:
 */ 
*1003：        最大子段和
*1058：
*1159：        lcs(最长公共字串，不连续)
*1160：         先排序
*1238：
*1257：        最小拦截系统
*1501：
*2084：       经典
*2668：        最长不同字串


/*
 * 九.其他：
 */ 
1002：大数加法    模板~
1041：大数
1042：大数阶乘
1212： 大数
1250：大数
1715：大数
？1865：大数    Fibonacci
1895：hash
1009：贪心        贪比例大的
*1050：贪心
*1097：二分        二分球a^b%m
1144：hash
1201：杂题        日期
1563：hash
？1564：博弈
*2602： 背包
*2817：二分求幂
2946：hash
？2954：博弈
*2986：高精度
*1028     整数的拆分种数

//分类不是绝对的
//"*" 表示好题，需要多次回味
//"?"表示结论是正确的，但还停留在模块阶 段，需要理解，证明。
//简单题看到就可以敲的

MiYu 2010-08-25 11:36 发表评论

C++博客-ACM___________________________-随笔分类-ACM_资料

Splay Tree 介绍

(转)伸展树 ( Splay tree )

树状数组 （Binary Indexed Trees ）论文解析

HDU 1512 HDOJ 1512 Monkey King ( 左偏树 ) ACM 1512 IN HDU

左偏树详解 ( 转载 )

Bellman-Ford && SPFA 算法

B-F

算法描述

时空复杂度

算法简介

算法流程

算法代码

trie树--详解

前向星+SPFA(转载)

松弛操作

什么是离散化?

[翻译]Wine完全使用指南——从基本到高级[转]

线段树的一种简化实现[转] by 踏雪赤兔

Floyd-Warshall算法详解（转）

多重背包O(N*V)算法详解（使用单调队列）(转载)

fill memset for 小测试

学习笔记 -- 关于 STL 中的 heap ( 堆 )

STL 学习笔记 ( 二. vector )

STL 学习笔记 ( 一. 概述 )

标准模板库(STL)学习---List容器 ( 转载 )

线段树入门 (zz)

霍夫曼编码

常用算法讲解---迭代法

常用算法讲解---穷举搜索法

HDOJ 部分分类

树状数组 小结

STL MAP 详解 (zz)

scanf/sscanf 格式的特殊控制

牛顿迭代法 求解方程

ZOJ POJ 题目分类

ZOJ POJ 题目分类

HDOJ 题目分类

HDOJ 题目分类

树状数组（Binary Indexed Trees ）论文解析

树状数组小结

牛顿迭代法求解方程