亚洲黄一区二区三区,亚洲视频一二,欧美日韩在线观看一区二区

��量数据面试题整理（转）

koson — Thu, 23 Sep 2010 12:42:00 GMT

1. �l�定a、b两个文�g�Q�各存放50亿个url�Q�每个url各占64字节�Q�内存限制是4G�Q�让你找出a、b文�g共同的url�Q?/strong>

�Ҏ��1�Q�可以估计每个文件安的大��ؓ50G×64=320G�Q�远�q�大于内存限制的4G。所以不可能��其完全加蝲到内存中处理。考虑采取分而治之的�Ҏ���?/p>
s 遍历文�ga�Q�对每个url求取�Q�然后根据所取得的值将url分别存储�?a name=baidusnap0>1000个小文�g�Q�记�?a >�Q�中。这��h��个小文�g的大�U��ؓ300M�?/p>

s 遍历文�gb�Q�采取和a相同的方式将url分别存储�?strong style="BACKGROUND-COLOR: #ffff66; COLOR: black">1000各小文�g�Q�记�?a >�Q�。这�?strong style="BACKGROUND-COLOR: #ff66ff; COLOR: black">处理后，所有可能相同的url都在对应的小文�g�Q?a >�Q�中�Q�不对应的小文�g不可能有相同的url。然后我们只要求�?strong style="BACKGROUND-COLOR: #ffff66; COLOR: black">1000对小文�g中相同的url卛_��?/p>

s 求每对小文�g中相同的url�Ӟ��可以把其中一个小文�g的url存储到hash_set中。然后遍历另一个小文�g的每个url�Q�看其是否在刚才构徏的hash_set中，如果是，那么��是共同的url�Q�存到文仉��面就可以了�?/p>

�Ҏ��2�Q�如果允许有一定的错误率，可以使用Bloom filter�Q?G内存大概可以表示340亿bit。将其中一个文件中的url使用Bloom filter映射��340亿bit�Q�然后挨个读取另外一个文件的url�Q�检查是否与Bloom filter�Q�如果是�Q�那么该url应该是共同的url�Q�注意会有一定的错误率）�?/p>

2. �?0个文�Ӟ��每个文�g1G�Q�每个文件的每一行存攄��都是用户的query�Q�每个文件的query都可能重复。要求你按照query的频度排序�?/strong>

�Ҏ��1�Q?/p>
s ��序��d��10个文�Ӟ��按照hash(query)%10的结果将query写入到另�?0个文�Ӟ��Cؓ�Q�中。这��h��生成的文件每个的大小大约�?G�Q�假设hash函数是随机的�Q��?/p>
s 找一台内存在2G左右的机器，依次�?a >用hash_map(query, query_count)来统计每个query出现的次数。利用快�?�?归�ƈ排序按照出现�ơ数�q�行排序。将排序好的query和对应的query_cout输出到文件中。这样得��C��10个排好序的文�Ӟ��Cؓ�Q��?/p>
s �?a >�q?0个文件进行归�q�排序（内排序与外排序相�l�合�Q��?/p>
�Ҏ��2�Q?/p>
一般query的总量是有限的�Q�只是重复的�ơ数比较多而已�Q�可能对于所有的query�Q�一�ơ性就可以加入到内存了。这��P��我们��可以采用trie�?hash_map�{�直接来�l�计每个query出现的次敎ͼ�然后按出现次数做快�?�?归�ƈ排序��可以了�?/p>
�Ҏ��3�Q?/p>
与方�?�c�M��Q�但在做完hash�Q�分成多个文件后�Q�可以交�l�多个文件来处理�Q�采用分布式的架构来处理�Q�比如MapReduce�Q�，最后再�q�行合�ƈ�?/p>
3. 有一�?G大小的一个文�Ӟ��里面每一行是一个词�Q�词的大��不��过16字节�Q�内存限制大��是1M。返回频数最高的100个词�?/strong>

�Ҏ��1�Q�顺序读文�g中，对于每个词x�Q�取�Q�然后按照该值存�?000个小文�g�Q�记�?a >�Q�中。这��h��个文件大概是200k左右。如果其中的有的文�g��过�?M大小�Q�还可以按照�c�M��?strong style="BACKGROUND-COLOR: #880000; COLOR: white">�Ҏ��l�箋往下分�Q�知道分解得到的��文件的大小都不��过1M。对每个��文�Ӟ��l�计每个文�g中出现的词以及相应的频率�Q�可以采用trie�?hash_map�{�）�Q��ƈ取出出现频率最大的100个词�Q�可以用�?strong style="BACKGROUND-COLOR: #ffff66; COLOR: black">100个结点的最��堆�Q�，�q�把100词及相应的频率存入文�Ӟ��q�样又得��C��5000个文件。下一步就是把�q?000个文件进行归�qӞ��c�M��与归�q�排序）的过�E�了�?/p>

4. ��量日志数据�Q�提取出某日讉K��癑ֺ��ơ数最多的那个IP�?/strong>

�Ҏ��1�Q�首先是�q�一天，�q�且是访问百度的日志中的IP取出来，逐个写入��C��个大文�g中。注意到IP�?2位的�Q�最多有个IP。同样可以采用映��的�Ҏ���Q�比如模1000�Q�把整个大文件映��ؓ1000个小文�g�Q�再扑և�每个��文中出现频率最大的IP�Q�可以采用hash_map�q�行频率�l�计�Q�然后再扑և�频率最大的几个�Q�及相应的频率。然后再在这1000个最大的IP中，扑և�那个频率最大的IP�Q�即为所求�?/p>
5. �?.5亿个整数中找��Z��重复的整敎ͼ�内存不��以容�U��2.5亿个整数�?/strong>

�Ҏ��1�Q�采�?-Bitmap�Q�每个数分配2bit�Q?0表示不存在，01表示出现一�ơ，10表示多次�Q?1无意义）�q�行�Q�共需内存内存�Q�还可以接受。然后扫描这2.5亿个整数�Q�查看Bitmap中相对应位，如果�?0�?1�Q?1�?0�Q?0保持不变。所描完事后�Q�查看bitmap�Q�把对应位是01的整数输出即可�?/p>
�Ҏ��2�Q�也可采用上题类似的�Ҏ���Q�进行划分小文�g�?strong style="BACKGROUND-COLOR: #880000; COLOR: white">�Ҏ��。然后在��文件中扑և�不重复的整数�Q��ƈ排序。然后再�q�行归�ƈ�Q�注意去除重复的元素�?/p>
6. ��量数据分布�?strong style="BACKGROUND-COLOR: #ffff66; COLOR: black">100台电脑中�Q�想个办法高校统计出�q�批数据的TOP10�?/strong>

�Ҏ��1�Q?/p>
s 在每台电脑上求出TOP10�Q�可以采用包�?0个元素的堆完成（TOP10��，用最大堆�Q�TOP10大，用最��堆�Q�。比如求TOP10大，我们首先取前10个元素调整成最��堆�Q�如果发玎ͼ�然后扫描后面的数据，�q�与堆顶元素比较�Q�如果比堆顶元素大，那么用该元素替换堆顶�Q�然后再调整为最��堆。最后堆中的元素��是TOP10大�?/p>
s 求出每台电脑上的TOP10后，然后把这100台电脑上的TOP10�l�合��h��Q�共1000个数据，再利用上面类似的�Ҏ��求出TOP10��可以了�?/p>
7. 怎么在�v量数据中扑և�重复�ơ数最多的一个？

�Ҏ��1�Q�先做hash�Q�然后求模映��ؓ��文�Ӟ��求出每个��文件中重复�ơ数最多的一个，�q�记录重复次数。然后找��Z��一步求出的数据中重复次数最多的一个就是所求（具体参考前面的题）�?/p>
8. 上千万或上亿数据�Q�有重复�Q�，�l�计其中出现�ơ数最多的钱N个数据�?/strong>

�Ҏ��1�Q�上千万或上亿的数据�Q�现在的机器的内存应该能存下。所以考虑采用hash_map/搜烦二叉�?�U�黑树等来进行统计次数。然后就是取出前N个出现次数最多的数据了，可以用第6题提到的堆机制完成�?/p>
9. 1000万字�W�串�Q�其中有些是重复的，需要把重复的全部去掉，保留没有重复的字�W�串。请怎么设计和实玎ͼ�

�Ҏ��1�Q�这题用trie树比较合适，hash_map也应该能行�?/p>
10. 一个文本文�Ӟ��大约有一万行�Q�每行一个词�Q�要求统计出其中最频繁出现的前10个词�Q�请�l�出思想�Q�给出时间复杂度分析�?/strong>

�Ҏ��1�Q�这题是考虑旉��效率。用trie树统计每个词出现的次敎ͼ�旉��复杂度是O(n*le)�Q�le表示单词的��^准长度）。然后是扑և�出现最频繁的前10个词�Q�可以用堆来实现�Q�前面的题中已经讲到了，旉��复杂度是O(n*lg10)。所以�ȝ��旉��复杂度，是O(n*le)与O(n*lg10)中较大的哪一个�?/p>
11. 一个文本文�Ӟ��扑և��?0个经常出现的词，但这�ơ文件比较长�Q�说是上亿行或十亿行�Q��M��无法一�ơ读入内存，问最优解�?/strong>

�Ҏ��1�Q�首先根据用hash�q�求模，��文件分解�ؓ多个��文�Ӟ��对于单个文�g利用上题�?strong style="BACKGROUND-COLOR: #880000; COLOR: white">�Ҏ��求出每个文�g件中10个最常出现的词。然后再�q�行归�ƈ处理�Q�找出最�l�的10个最常出现的词�?/p>
12. 100w个数中找出最大的100个数�?/strong>

�Ҏ��1�Q�在前面的题中，我们已经提到了，用一个含100个元素的最��堆完成。复杂度为O(100w*lg100)�?/p>
�Ҏ��2�Q�采用快速排序的思想�Q�每�ơ分割之后只考虑比��u大的一部分�Q�知道比轴大的一部分在比100多的时候，采用传统排序��法排序�Q�取�?strong style="BACKGROUND-COLOR: #ffff66; COLOR: black">100个。复杂度为O(100w*100)�?/p>
�Ҏ��3�Q�采用局部淘汰法。选取�?strong style="BACKGROUND-COLOR: #ffff66; COLOR: black">100个元素，�q�排序，��Cؓ序列L。然后一�ơ扫描剩余的元素x�Q�与排好序的100个元素中最��的元素比，如果比这个最��的要大�Q�那么把�q�个最��的元素删除�Q��ƈ把x利用插入排序的思想�Q�插入到序列L中。依�ơ��@环，知道扫描了所有的元素。复杂度为O(100w*100)�?/p>
13. ��L��热门查询�Q?/strong>

搜烦引擎会通过日志文�g把用��h��ơ检索��用的所有检索串都记录下来，每个查询串的长度�?-255字节。假讄��前有一千万个记录，�q�些查询串的重复��L��较高�Q�虽然��L��?千万�Q�但是如果去除重复和�Q�不��过3百万个。一个查询串的重复度��高�Q�说明查询它的用戯��多，也就��热门。请你统计最热门�?0个查询串�Q�要求��用的内存不能��过1G�?/p>
(1) ��h��q�C��解决�q�个问题的思�\�Q?/p>
(2) ��L��Z��要的处理��程�Q�算法，以及��法的复杂度�?/p>
�Ҏ��1�Q�采用trie树，关键字域存该查询串出现的�ơ数�Q�没有出��Cؓ0。最后用10个元素的最��推来对出现频率�q�行排序�?/p>
14. 一共有N个机器，每个机器上有N个数。每个机器最多存O(N)个数�q�对它们操作。如何找�?a >个数中的中数�Q?/strong>

�Ҏ��1�Q�先大体估计一下这些数的范��_��比如�q�里假设�q�些数都�?2位无�W�号整数�Q�共�?a >个）。我们把0�?a >的整数划分�ؓN个范围段�Q�每个段包含个整数。比如，�W�一个段�?�?a >�Q�第二段�?a >�?a >�Q?#8230;�Q�第N个段�?a >�?a >。然后，扫描每个机器上的N个数�Q�把属于�W�一个区�D늚�数放到第一个机器上�Q�属于第二个区段的数攑ֈ��W�二个机器上�Q?#8230;�Q�属于第N个区�D늚�数放到第N个机器上。注意这个过�E�每个机器上存储的数应该是O(N)的。下面我们依�ơ统计每个机器上数的个数�Q�一�ơ篏加，直到扑ֈ��W�k个机器，在该机器上篏加的数大于或�{�于�Q�而在�W�k-1个机器上的篏加数��于�Q��ƈ把这个数��Cؓx。那么我们要扄��中位数在�W�k个机器中�Q�排在第位。然后我们对�W�k个机器的数排序，�q�找出第个数�Q�即为所求的中位数。复杂度�?a >的�?/p>
�Ҏ��2�Q�先�Ҏ��台机器上的数�q�行排序。排好序后，我们采用归�ƈ排序的思想�Q�将�q�N个机器上的数归�ƈ��h��得到最�l�的排序。找到第个便是所求。复杂度�?a >的�?/p>
15. 最大间隙问�?/strong>

�l�定n个实�?a >�Q�求着n个实数在实��u上向�?个数之间的最大差��|��要求�U�性的旉��法�?/p>
�Ҏ��1�Q�最先想到的�Ҏ����是先对�q�n个数据进行排序，然后一遍扫描即可确定相�ȝ��最大间隙。但�?strong style="BACKGROUND-COLOR: #880000; COLOR: white">�Ҏ��不能满��U�性时间的要求。故采取如下�Ҏ���Q?/p>
s 扑ֈ�n个数据中最大和最��数据max和min�?/p>
s 用n-2个点�{�分区间[min, max]�Q�即��[min, max]�{�分为n-1个区��_��前闭后开区间�Q�，��这些区间看作桶�Q�编号�ؓ�Q�且�?a >的上界和桶i+1的下届相同，��x��个桶的大��相同。每个桶的大��ؓ�Q?a >。实际上�Q�这些桶的边界构成了一个等差数列（首项为min�Q�公差�ؓ�Q�，且认为将min攑օ��W�一个桶�Q�将max攑օ��W�n-1个桶�?/p>
s ��n个数攑օ�n-1个桶中：��每个元�?a >分配到某个桶�Q�编号�ؓindex�Q�，其中�Q��ƈ求出分到每个桶的最大最��数据�?/p>
s 最大间隙：除最大最��数据max和min以外的n-2个数据放入n-1个桶中，由抽屉原理可知至��有一个桶是空的，又因为每个桶的大��相同，所以最大间隙不会在同一桶中出现�Q�一定是某个桶的上界和气候某个桶的下界之间隙�Q�且该量�{�之间的�Ӟ��即便好在该连个便好之间的�Ӟ��一定是�I�桶。也��是��_��最大间隙在桶i的上界和桶j的下界之间��?a >。一遍扫描即可完成�?/p>
16. ��多个集合合�q�成没有交集的集合：�l�定一个字�W�串的集合，格式如：。要求将其中交集不�ؓ�I�的集合合�ƈ�Q�要求合�q�完成的集合之间无交集，例如上例应输�?a >�?/strong>

(1) ��h��q�C��解决�q�个问题的思�\�Q?/p>
(2) �l�出主要�?strong style="BACKGROUND-COLOR: #ff66ff; COLOR: black">处理��程�Q�算法，以及��法的复杂度�Q?/p>
(3) ��h��q�可能的改进�?/p>
�Ҏ��1�Q�采用�ƈ查集。首先所有的字符串都在单独的�q�查集中。然后依扫描每个集合�Q�顺序合�q�将两个盔R��元素合�ƈ。例如，对于�Q�首先查看aaa和bbb是否在同一个�ƈ查集中，如果不在�Q�那么把它们所在的�q�查集合�qӞ��然后再看bbb和ccc是否在同一个�ƈ查集中，如果不在�Q�那么也把它们所在的�q�查集合�q�。接下来再扫描其他的集合�Q�当所有的集合都扫描完了，�q�查集代表的集合便是所求。复杂度应该是O(NlgN)的。改�q�的话，首先可以记录每个节点的根�l�点�Q�改�q�查询。合�q�的时候，可以把大的和��的�q�行合，�q�样也减��复杂度�?/p>
17. 最大子序列与最大子矩阵问题

数组的最大子序列问题�Q�给定一个数�l�，其中元素有正�Q�也有负�Q�找出其中一个连�l�子序列�Q��和最大�?/p>
�Ҏ��1�Q�这个问题可以动态规划的思想解决。设表示以第i个元�?a >�l�尾的最大子序列�Q�那么显�?a >。基于这一点可以很快用代码实现�?/p>
最大子矩阵问题�Q�给定一个矩阵（二维数组�Q�，其中数据有大有小�Q�请找一个子矩阵�Q��得子矩阵的和最大，�q�输��个和�?/p>
�Ҏ��1�Q�可以采用与最大子序列�c�M��的思想来解冟뀂如果我们确定了选择�W�i列和�W�j列之间的元素�Q�那么在�q�个范围内，其实��是一个最大子序列问题。如何确定第i列和�W�j列可以词用暴搜的�Ҏ���q�行�?/p>

koson 2010-09-23 20:42 发表评论

POJ 1523 无向囄��割点

koson — Wed, 28 Apr 2010 12:57:00 GMT
看了无向囄��割点�Q�割边的东西�Q�顺便做了这道题。题目要求出割点以及除去割点后的�q�通子囄��数量。求割点的方法利用深度优先搜索的子数�Q�以及记录结点的讉K��旉��以及�l�点所能到辄��最低祖先，然后对这两个数进行比较从而确定结�Ҏ��否是割点�Q�求出割点后�Q�要求出此割点去掉后�q�通子囄��数量�Q�一�U�方法是�Q�对每一个割点，对它的相邻顶点分别进行一�ơ深搜，每搜一�ơ结果加1。但从求割点的过�E�中分析可知�Q�不通过�q�样的遍历就可以方便的得到这个结果。用tag[i]标记�l�点i是否为割点，对于根结点，当搜索它的第一个子树时�Q�由于子树数�?�Q�所以tag[i]仍�ؓ�Ӟ��当每搜烦其它一��子树时�Q�都可以判定根结�Ҏ��割点�Q�那么tag[i]++, 所以根�l�点如果是割的情况下它所能�Ş成的�q�通子图数目�ؓtag[i]+1�Q?对于非根�l�点�Q�当�W�一�ơ遍历到�q�个�l�点�Ӟ��q�个�l�点�q�不能判断�ؓ割点�Q�之后对此结点的每一��子树，如果能判定i是割点，则tag[i]++, 最后连通子图数�q�要加上�W�一�ơ遍历到�q�个�l�点时所形成的图�Q�所以�ȝ��q�通子图数为tag[i]+1。另外此题的�l�点不一定是�q�箋的。只�?000多个�l�点�Q�可以直接用��L��矩阵�Q�但要占用比较多的空间�?br>附上代码�Q?br>
1 #include<stdio.h>
2 #include<string.h>
3 #define N 1050
4 int w[N][N];
5 int n;
6 int m;
7 int time;
8 int dis[N];
9 int low[N];
10 int tag[N];
11 void dfs(int v,int prt)
12 {
13     time++;
14     dis[v]=low[v]=time;
15     int child=0;
16     int i;
17     for(i=m;i<=n;++i)
18     {
19         if(w[v][i]==0) continue;
20         if(i!=prt&&dis[i]>0)
21         {
22             if(dis[i]<low[v])
23                 low[v]=dis[i];
24         }else if(dis[i]==0)
25         {
26             child++;
27             dfs(i,v);
28             if(low[i]<low[v])
29                 low[v]=low[i];
30             if((v!=m&&dis[v]<=low[i])||(child>=2&&v==m))
31                 tag[v]++;
32         }
33     }
34 }
35 void input()
36 {
37     int a,b;
38     int cur=0;
39     while(scanf("%d",&a)&&a!=0)
40     {
41         scanf("%d",&b);
42         n=0;
43         m=1005;
44         memset(w,0,sizeof(w));
45         w[a][b]=w[b][a]=1;
46         if(a>n) n=a;
47         if(b>n) n=b;
48         if(a<m) m=a;
49         if(b<m) m=b;
50         while(scanf("%d",&a)&&a!=0)
51         {
52             scanf("%d",&b);
53             w[a][b]=w[b][a]=1;
54             if(a>n) n=a;
55             if(b>n) n=b;
56             if(a<m) m=a;
57             if(b<m) m=b;
58         }
59         memset(tag,0,sizeof(tag));
60         memset(dis,0,sizeof(dis));
61         memset(low,0,sizeof(low));
62         time=0;
63         dfs(m,0);
64         int i,j,bb;
65         bb=0;
66         printf("Network #%d\n",++cur);
67
68         for(i=m;i<=n;++i)
69         {
70             if(tag[i])
71             {
72                 bb=1;
73                 printf("  SPF node %d leaves %d subnets\n",i,tag[i]+1);
74
75             }
76         }
77         if(!bb) printf("  No SPF nodes\n");
78         printf("\n");
79     }
80 }
81
82 int main()
83 {
84     input();
85     return 1;
86 }
87

koson 2010-04-28 20:57 发表评论

有向囑ּ��q�通分量的三种��法

koson — Tue, 27 Apr 2010 04:08:00 GMT
     摘要: document.body.oncopy = function() { if (window.clipboardData) { setTimeout(function() { var text = clipboardData.getData("text"); if (text && text.length > 300) { text = text + "\r\n\n本文来自CSDN博客�Q?..  阅读全文

koson 2010-04-27 12:08 发表评论

四道有趣的单链表面试题（单链表反序、找出链表的中间元素、链表排序、判断一个单链表是否有环�Q?(�?

koson — Wed, 21 Apr 2010 07:50:00 GMT
以下�l�出链表�l�点的数据结构：

1  typedef struct _list_node
2 {
3     double keyVal;
4     struct _list_node *next;
5 }ListNode;
Q1 单链表的反序

Code
1 ListNode* reverseList(ListNode* head)
2 {
3     ListNode *p1, *p2 , *p3;
4     //链表为空�Q�或是单�l�点链表直接�q�回头结�?/span>
5     if (head == NULL || head->next == NULL)
6     {
7         return head;
8     }
9     p1 = head;
10     p2 = head->next;
11     while (p2 != NULL)
12     {
13         p3 = p2->next;
14         p2->next = p1;
15         p1 = p2;
16         p2 = p3;
17     }
18     head->next = NULL;
19     head = p1;
20
21     return head;
22 }
Q2 扑և�链表的中间元�?br>
Code
1 ListNode* find_midlist(ListNode* head)
2 {
3     ListNode *p1, *p2;
4
5     if (head == NULL || head->next == NULL)
6     {
7         return head;
8     }
9     p1 = p2 = head;
10     while (1)
11     {
12         if (p2->next != NULL && p2->next->next != NULL)
13         {
14             p2 = p2->next->next;
15             p1 = p1->next;
16         }
17         else
18         {
19             break;
20         }
21     }
22     return p1;
23 }

思�\分析�Q?/span>

�?/span>链表的一个比较大的特点用一句广告语来说��是“不走回头�?#8221;�Q�不能实现随机存取（random access�Q�。如果我们想要找一个数�l�a的中间元素，直接a[len/2]��可以了�Q�但是链表不行，因�ؓ只有a[len/2 - 1] 知道a[len/2]在哪儿，其他��Z��知道。因此，如果按照数组的做法依��L��葫芦�Q�要扑ֈ�链表的中点，我们需要做两步�Q?�Q�知道链表有多长�Q?�Q�从头结点开始顺序遍历到链表长度的一半的位置。这��需�?.5n�Q�n为链表的长度�Q�的旉��复杂度了。有没有更好的办法呢�Q�有的。想法很��单：两个��跑，如果A的速度是B的两倍的话，当A到终点的时候，B应该刚到中点。这只需要遍历一遍链表就行了�Q�还不用计算链表的长度�?/span>

上面的代码就体现了这个想法�?/span>
Q3 链表排序

Code
1 double cmp(ListNode *p ,ListNode *q)
2 {return (p->keyVal - q->keyVal);}
3
4 ListNode* mergeSortList(ListNode *head)
5 {
6     ListNode *p, *q, *tail, *e;
7     int nstep = 1;
8     int nmerges = 0;
9     int i;
10     int psize, qsize;
11     if (head == NULL || head->next == NULL)
12     {return head;}
13     while (1)
14     {   p = head;
15         tail = NULL;
16         nmerges = 0;
17         while (p)
18         {   nmerges++;  q = p;  psize = 0;
19             for (i = 0; i < nstep; i++){
20                 psize++;
21                 q = q->next;
22                 if (q == NULL)break;
23 }
24             qsize = nstep;
25             while (psize >0 || (qsize >0 && q))
26 {
27                 if (psize == 0 ){e = q; q = q->next; qsize--;}
28                 elseif (q == NULL || qsize == 0){e = p; p = p->next; psize--;}
29                 elseif (cmp(p,q) <= 0){e = p; p = p->next; psize--;}
30                 else{e = q; q = q->next; qsize--;}
31                 if (tail != NULL){tail->next = e;}
32                 else{head = e;}
33                 tail = e;
34               }
35             p = q;
36         }
37         tail->next = NULL;
38         if (nmerges <= 1){return head;}
39         else{nstep <<= 1;}
40     }
41 }

思�\分析�Q?/span>

  链表排序最好��用归�q�排序算法。堆排序、快速排序这些在数组排序时性能非常好的��法�Q�在链表只能“��序讉K��”的魔咒下无法施展能力�Q�但是归�q�排序却如鱼得水�Q�非但保持了它O(nlogn)的时间复杂度�Q�而且它在数组排序中广受诟病的�I�间复杂度在链表排序中也�?/span>O(n)降到�?/span>O(1)。真是好得不得了啊，哈哈。以上程序是递推法的�E�序�Q�另外值得一说的是看看那个时间复杂度�Q�是不是有点眼熟�Q�对�Q�这��是分治法的旉��复杂度，归�ƈ排序又是divide and conquer�?/span>
Q4 判断一个单链表是否有环

Code
1 int is_looplist (ListNode *head)
2 {
3     ListNode *p1, *p2;
4     p1 = p2 = head;
5
6     if (head == NULL || head->next == NULL)
7     {
8         return 0;
9     }
10
11     while (p2->next != NULL && p2->next->next != NULL)
12     {
13         p1 = p1->next;
14         p2 = p2->next->next;
15         if (p1 == p2)
16         {
17             return 1;
18         }
19     }
20
21     return 0;
22
23 }

思�\分析�Q?/span>

  �q�道题是�?span>C专家�~�程》中的题了。其实算法也有很多，比如��_��我觉得进行对讉K��q�的�l�点�q�行标记�q�个��x��也不错，而且在树遍历�{�场合我们也�l�常使用。但是在不允许做标记的场合就无法使用了。在�U�种限制的条件下�Q�就有了上面的这�U�算法，其实思想很简单：��像两个人在操场上跑步一��P��只要有个人的速度比另一个�h的速度快一点，他们肯定会有盔R��的时候的。不�q�带环链表与操场又不一��P��带环链表的状态是��L��的，所以选择走得快的要比走得慢的快多��很重要。比如说�q�里�Q�如果一个指针一�ơ走三步�Q�一个指针一�ơ走一步的话，很有可能它们虽然在一个环中但是永�q�遇不到�Q�这要取决于环的大小以及两个指针初始位置相差多少了。呵��c��你能看��Z��个指针的速度应该满��什么关�p�L��能在有环的情况下盔R��吗？如果你知道，不妨跟我讨论一下，呵呵�?/span>

koson 2010-04-21 15:50 发表评论

POJ 1094 拓扑排序

koson — Tue, 20 Apr 2010 07:42:00 GMT

使用深搜�Q�根据每个结点的�l�束讉K��旉��的降序对�l�点�q�行拓扑排序�Q�如果在某个�l�点的扩展过�E�中发现反向边，则出��C��矛盾�Q�否则对所得到的结点序列，�q�行一�ơ遍历，对于盔R��的结�Ҏ��是否存在连接边�Q�存在则表示它们的顺序已�l�可以确定）�Q�如果所有的盔R��l�点都可��定��序�Q�则�q�个序列是完全有序的�Q�对于后面的输入可以忽略�Q�如果处理完所有的输入�q�不能得到完全有序序列，则输出序列顺序不能确定�?br>题意实际上暗�C�Z��Ҏ��一�ơ输入都要做处理�Q�如果对于某一�ơ输入已�l�能��定序列矛盾或者序列完全有序，则可以忽略后面的输入�?br>

1 #include<stdio.h>
2 #include<string.h>
3 int n,m;
4 int e[27][27];
5 char in[4];
6 char temp[27];
7 int cur;
8 int incons;
9 int color[27];
10 void dfs(int k)
11 {
12     color[k]=1;
13     int i;
14     for(i=1;i<=n;++i)
15     {
16         if(e[k][i]&&color[i]==0) dfs(i);
17         else if(e[k][i]&&color[i]==1) incons=1; //reverse edge exist, inconsistency found
18     }
19     color[k]=2;
20     temp[cur++]=k-1+'A';
21 }
22 int main()
23 {
24     int i,j,found;
25     while(scanf("%d%d",&n,&m)&&n&&m)
26     {
27         memset(e,0,sizeof(e));
28         found=0;
29         incons=0;
30         for(i=1;i<=m;++i)
31         {
32             scanf("%s",in);
33             e[in[0]-'A'+1][in[2]-'A'+1]=1;
34             if(!found&&!incons)
35             {
36                 cur=0;
37                 memset(color,0,sizeof(color));
38                 for(j=1;j<=n;++j)
39                     if(color[j]==0) dfs(j);
40                 temp[cur]='\0';
41                 if(incons==1) //inconsistency found
42                     incons=i;
43                 else{
44                     int bb=1;
45                     for(j=cur-1;j>0;--j) //check if the sort of sequence can be confirmed
46                         if(!e[temp[j]-'A'+1][temp[j-1]-'A'+1]) {bb=0;break;}
47                     if(bb) found=i; // sorted sequence determined
48                 }
49             }
50         }
51         char tt;
52         for(i=0,j=cur-1;i<j;i++,j--)  //reverse the sorted sequence
53         {
54             tt=temp[i];
55             temp[i]=temp[j];
56             temp[j]=tt;
57         }
58         if(incons) printf("Inconsistency found after %d relations.\n",incons);
59         else if(found) printf("Sorted sequence determined after %d relations: %s.\n",found,temp);
60         else printf("Sorted sequence cannot be determined.\n");
61     }
62     return 1;
63 }
64

koson 2010-04-20 15:42 发表评论

koson — Mon, 19 Apr 2010 07:05:00 GMT
用深度优先搜索，�׃��每对��点之间可能会有不同路径长度或费用��|��所以采用邻接表来表�C�图。搜索过�E�中�Q�剪掉那些当前�\径长度大于前面已�l�计��得出的最��值或者当前花费值大于所有值的分支�?br>

koson 2010-04-19 15:05 发表评论

poj 1988　�q�查集的应用

koson — Thu, 08 Apr 2010 04:27:00 GMT
　　题意是给出N个立方体�Q�可以将立方体移动到其它立方体�Ş成堆�Q�然后有P个下面的操作: 1) M X Y ,��X立方体所在的堆移到Y立方体所在的堆的上面; 2) C X 输出在X所在的堆上,在X立方体下面的立方体个数�?br>　　使用�q�查集来解决�q�个问题。关键在于怎么存储和更新立方体的结�?��x��?的输出�?。用三个数组�Q�p,h,t, p[i]表示i的根�l�点�Q�h[i]表示i的结果，卛_��在i下面的立方体个数�Q�t[i]表示i所在的堆的立方体��M��数。对于每一堆立方体�Q�根�l�点使用堆底的立方体�Q�而且在这个堆所对应的集合内�Q�通过更新�Q��得只有根�l�点的t��gؓ�q�堆的��M��敎ͼ�h��gؓ0(因�ؓ它在堆底)�Q�其它的立方体的t值都�?�Q�h值在�q�查集的查找步骤中进行递归更新。　　　
　　在�ƈ查集的查扑և�数的执行中，先向上找到根�l�点�Q��ƈ且保存当前结点x的父节点为temp�Q�找到根�l�点后，向下依次一更新�l�点的h,t倹{�?br>      1)若t[x]不�ؓ0,卌��C�x是一个堆的堆底元素，h[x]�?,其父节点是另外一堆的堆底(因�ؓ在�ƈ查集的操作中�Q�通过��一个堆的堆底指向另一个堆的堆底来实现合�ƈ),　h[x]+=t[temp],t[temp]+=t[x],t[x]=0 �Q�这三个语句��x的h值加上父�l�点的��M��?因�ؓ是将x所在的堆放在父节点的堆),然后��父节点的t值加上x的t�?父节点的堆的��L��变�ؓ两者之和）�Q�然后再��x的t值置0.
      2)若t[x]�?,卌��C�x不是堆底�Q�那么只要将x的h值加上父节点的h值即可。h[x]+=h[temp] �?br>　　��M��囄��后稍微分析查找操作的�q�程��p��得到上面的结果。下面是�q�查集的几个函数。在合�ƈ操作里面�Q�合�q�完后我们再对x,y执行一�ơ查找操作以更新对应堆的��|��因�ؓ在下�ơ合�q�的时候可能堆�q�没有来得及更新�?br>
1 void make_set()
2 {
3     int i;
4     for(i=1;i<N;++i)
5     {
6         p[i]=i;
7         h[i]=0;
8         t[i]=1;
9     }
10 }
11 int find_set(int x)
12 {
13     int temp;
14     if(x!=p[x])
15     {
16         temp=p[x];
17         p[x]=find_set(p[x]);
18         if(t[x]!=0)
19         {
20             h[x]+=t[temp];
21             t[temp]+=t[x];
22             t[x]=0;
23         }else
24         {
25             h[x]+=h[temp];
26         }
27     }
28     return p[x];
29 }
30 void union_set(int x,int y)
31 {
32     int px=find_set(x),py=find_set(y);
33     p[px]=py;
34     find_set(x),find_set(y);
35 }
36

koson 2010-04-08 12:27 发表评论

二叉树前序、中序、后序三�U�遍历的非递归��法

koson — Thu, 18 Mar 2010 04:23:00 GMT

一。教�U�书标准��法
1.先序遍历非递归��法
void PreOrderUnrec(Bitree *t)
{
    Stack s;
StackInit(s);
Bitree *p=t;

while (p!=NULL || !StackEmpty(s))
{
      while (p!=NULL)          //遍历左子�?br>       {
         visite(p->data);
         push(s,p);
         p=p->lchild;
        }

        if (!StackEmpty(s))       //通过下一�ơ��@环中的内嵌while实现叛_��树遍�?br>       {
         p=pop(s);
         p=p->rchild;
      }//endif

}//endwhile
}

2.中序遍历非递归��法
void InOrderUnrec(Bitree *t)
{
    Stack s;
StackInit(s);
Bitree *p=t;

    while (p!=NULL || !StackEmpty(s))
{
      while (p!=NULL)          //遍历左子�?br>       {
         push(s,p);
         p=p->lchild;
      }

        if (!StackEmpty(s))
      {
         p=pop(s);
         visite(p->data);       //讉K��根结�?br>          p=p->rchild;          //通过下一�ơ��@环实现右子树遍历
      }//endif

}//endwhile
}

3.后序遍历非递归��法
typedef enum{L,R} tagtype;
typedef struct
{
Bitree ptr;
tagtype tag;
}stacknode;

typedef struct
{
stacknode Elem[maxsize];
int top;
}SqStack;

void PostOrderUnrec(Bitree t)
{
SqStack s;
stacknode x;
StackInit(s);
p=t;

do
{
      while (p!=null)       //遍历左子�?br>       {
         x.ptr = p;
         x.tag = L;       //标记为左子树
         push(s,x);
         p=p->lchild;
      }

      while (!StackEmpty(s) && s.Elem[s.top].tag==R)
      {
         x = pop(s);
         p = x.ptr;
         visite(p->data); //tag为R�Q�表�C�右子树讉K��完毕�Q�故讉K��根结�?nbsp;
      }

      if (!StackEmpty(s))
      {
         s.Elem[s.top].tag =R;    //遍历叛_��?br>          p=s.Elem[s.top].ptr->rchild;
      }
}while (!StackEmpty(s));
}//PostOrderUnrec

二。前序最��z�算�?br>void PreOrderUnrec(Bitree *t)
{
   Bitree *p;
   Stack s;
   s.push(t);

   while (!s.IsEmpty())
   {
      s.pop(p);
      visit(p->data);
      if (p->rchild != NULL) s.push(p->rchild);
      if (p->lchild != NULL) s.push(p->lchild);
   }
}

三。后序算法之�?/strong>
void BT_PostOrderNoRec(pTreeT root)
{
stack s;
pTreeT pre=NULL;

while ((NULL != root) || !s.empty())
{
if (NULL != root)
{
s.push(root);
root = root->left;
}
else
{
root = s.top();
if (root->right!=NULL && pre!=root->right){
root=root->right;
}
else{
root=pre=s.top();
visit(root);
s.pop();
root=NULL;
}
}
}
}

koson 2010-03-18 12:23 发表评论

koson — Wed, 17 Mar 2010 08:25:00 GMT

利用快速排序的分组思�\�Q�假讑֯�当前��d��值t,已将数组分成三个部分�Q�a[0,m-1]部分都小于t�Q�a[m]�{�于t,a[m+1,n-1]大于�{�于t,此时比较m+1与k,若m+1k�Q�则��分�l�区间的右下标改为m-1,若是m+1==k,则表�C�找��C��W�k个元素，�q�回a[m]。可知这个算法的旉��复杂度�ؓO(cn)�Q�其中c为某个很��的常数。实现时�Q�依赖于分组的方法，有单向分�U�与双向分组�Q�用随机生成的百万个数据�q�行��试�Q�结果单向分�l�的旉��为双向分�l�的两倍�?br>代码如下�Q?br>#include
#include
#define MAX 1000001
int n,k;
int h[MAX];
int search1()
{
        int l,r,i,m,t,temp;
        for(l=0,r=n-1;;)
        {
                t=h[l];
                m=l;
                for(i=l+1;i<=r;++i)
                        if(h[i]                        {
                                temp=h[i];
                                h[i]=h[++m];
                                h[m]=temp;
                        }
                h[l]=h[m];
                h[m]=t;
                if(m+1                else if(m+1>k) r=m-1;
                else break;
        }
        return h[m];
}

int search()
{
        int l,r,i,j,t,temp;
        for(l=0,r=n-1;;)
        {
                t=h[l];
                i=l,j=r+1;
                while(1)
                {
                        do{
                                i++;
                        }while(i<=r&&h[i]                        do{
                                j--;
                        }while(j>=l+1&&h[j]>=t);
                        if(i>j)
                                break;
                        else
                        {
                                temp=h[i];
                                h[i]=h[j];
                                h[j]=temp;
                        }
                }
                h[l]=h[j];
                h[j]=t;
                if(j+1                        l=j+1;
                else if(j+1>k)
                        r=j-1;
                else break;
        }
        return h[j];
}

int main()
{
        scanf("%d%d",&n,&k);
        int i,j;
        for(i=0;i                scanf("%d",&h[i]);
        time_t start,end;
        start=clock();
        printf("%d\n",search());
        end=clock();
        printf("%f\n",((end-start)*1.0)/CLOCKS_PER_SEC);

        return 0;
}

koson 2010-03-17 16:25 发表评论

大数据量�Q��v量数�?处理�Ҏ��ȝ��(转）

koson — Mon, 15 Mar 2010 06:40:00 GMT

1.Bloom filter

适用范围�Q�可以用来实现数据字典，�q�行数据的判重，或者集合求交集

基本原理及要点：

�?于原理来说很��单，位数�l?k个独立hash函数。将hash函数对应的值的位数�l�置1�Q�查找时如果发现所有hash函数对应位都�?说明存在�Q�很明显�q?个过�E��ƈ不保证查扄��l�果�?00%正确的。同时也不支持删除一个已�l�插入的关键字，因�ؓ该关键字对应的位会牵动到其他的关键字。所以一个简单的改进��是 counting Bloom filter�Q�用一个counter数组代替位数�l�，��可以支持删除了�?br>

�q?有一个比较重要的问题�Q�如何根据输入元素个数n�Q�确定位数组m的大��及hash函数个数。当hash函数个数k=(ln2)*(m/n)旉��误率最��。在错误率不大于E的情况下�Q�m臛_��要等于n*lg(1/E)才能表示��L��n个元素的集合。但m�q�应该更大些�Q�因��要保证bit数组里至��一半�ؓ0�Q�则m�?�?gt;=nlg(1/E)*lge 大概��是nlg(1/E)1.44�?lg表示�?为底的对�?�?/div>

举个例子我们假设错误率�ؓ0.01�Q�则此时m应大概是n�?3倍。这样k大概�?个�?/div>

注意�q�里m与n的单位不同，m是bit为单位，而n则是以元素个��Cؓ单位(准确的说是不同元素的个数)。通常单个元素的长度都是有很多bit的。所以��用bloom filter内存上通常都是节省的�?/div>

扩展�Q?/strong>

Bloom filter��集合中的元素映��到位数�l�中�Q�用k�Q�k为哈希函��C��敎ͼ�个映��位是否�?表示元素在不在这个集合中。Counting bloom filter�Q�CBF�Q�将位数�l�中的每一位扩展�ؓ一个counter�Q�从而支持了元素的删除操作。Spectral Bloom Filter�Q�SBF�Q�将其与集合元素的出现次数关联。SBF采用counter中的最��值来�q�似表示元素的出现频率�?/div>

问题实例�Q?/strong>�l�你A,B两个文�g�Q�各存放50亿条URL�Q�每条URL占用64字节�Q�内存限制是4G�Q�让你找出A,B文�g共同的URL。如果是三个乃至n个文件呢�Q?/div>

�?据这个问题我们来计算下内存的占用�Q?G=2^32大概�?0�?8大概�?40亿，n=50亿，如果按出错率0.01��需要的大概�?50亿个bit�?现在可用的是340亿，相差�q�不多，�q�样可能会��出错率上升些。另外如果这些urlip是一一对应的，��可以�{换成ip�Q�则大大��单了�?/div>

2.Hashing

适用范围�Q?/strong>快速查找，删除的基本数据结构，通常需要��L��据量可以攑օ�内存

基本原理及要点：

hash函数选择�Q�针对字�W�串�Q�整敎ͼ�排列�Q�具体相应的hash�Ҏ��?/div>
��撞处理�Q�一�U�是open hashing�Q�也�U�Cؓ拉链法；另一�U�就是closed hashing�Q�也�U�开地址法，opened addressing�?/div>

扩展�Q?/strong>

d-left hashing中的d是多个的意思，我们先简化这个问题，看一�?-left hashing�?-left hashing指的是将一个哈希表分成长度相等的两半，分别叫做T1和T2�Q�给T1和T2分别配备一个哈希函敎ͼ�h1和h2。在存储一个新的key�Ӟ��?时用两个哈希函数�q�行计算�Q�得��Z��个地址h1[key]和h2[key]。这旉��要检查T1中的h1[key]位置和T2中的h2[key]位置�Q�哪一�?位置已经存储的（有碰撞的�Q�key比较多，然后��新key存储在负载少的位�|�。如果两边一样多�Q�比如两个位�|�都为空或者都存储了一个key�Q�就把新key 存储在左边的T1子表中，2-left也由此而来。在查找一个key�Ӟ��必须�q�行两次hash�Q�同时查找两个位�|��?/div>

问题实例�Q?/strong>

1).��量日志数据�Q�提取出某日讉K��癑ֺ��ơ数最多的那个IP�?/div>

IP的数目还是有限的�Q�最�?^32个，所以可以考虑使用hash��ip直接存入内存�Q�然后进行统计�?/div>

3.bit-map

适用范围�Q?/strong>可进行数据的快速查找，判重�Q�删除，一般来说数据范围是int�?0倍以�?/div>

基本原理及要�?/strong>�Q��用bit数组来表�C�某些元素是否存在，比如8位电话号�?/div>

扩展�Q�bloom filter可以看做是对bit-map的扩�?/div>

问题实例�Q?/strong>

1)已知某个文�g内包含一些电话号码，每个��L��?位数字，�l�计不同��L��的个数�?/div>

8位最�?9 999 999�Q�大概需�?9m个bit�Q�大�?0几m字节的内存即可�?/div>

2)2.5亿个整数中找��Z��重复的整数的个数�Q�内存空间不��以容纳�q?.5亿个整数�?/div>

��bit-map扩展一下，�?bit表示一个数卛_��Q?表示未出玎ͼ�1表示出现一�ơ，2表示出现2�ơ及以上。或者我们不�?bit来进行表�C�，我们用两个bit-map卛_��模拟实现�q�个2bit-map�?/div>

4.�?/font>

适用范围�Q��v量数据前n大，�q�且n比较��，堆可以放入内�?/div>

基本原理及要�?/strong>�Q?最大堆求前n��，最��堆求前n大。方法，比如求前n��，我们比较当前元素与最大堆里的最大元素，如果它小于最大元素，则应该替换那个最大元素。这��h��后得到的n个元素就是最��的n个。适合大数据量�Q�求前n��，n的大��比较小的情况，�q�样可以扫描一遍即可得到所有的前n元素�Q�效率很高�?/div>

扩展�Q?/strong>双堆�Q�一个最大堆与一个最��堆�l�合�Q�可以用来维护中位数�?/div>

问题实例�Q?/strong>

1)100w个数中找最大的�?00个数�?/div>

用一�?00个元素大��的最��堆卛_��?/div>

5.双层桶划�?/font>

适用范围�Q�第k大，中位敎ͼ�不重复或重复的数�?/div>

基本原理及要�?/strong>�Q�因为元素范围很大，不能利用直接��d��表，所以通过多次划分�Q�逐步��定范围�Q�然后最后在一个可以接受的范围内进行。可以通过多次�~�小�Q�双层只是一个例子�?/div>

扩展�Q?/strong>

问题实例�Q?/div>
1).2.5亿个整数中找��Z��重复的整数的个数�Q�内存空间不��以容纳�q?.5亿个整数�?/div>

有点像鸽巢原理，整数个数�?^32,也就是，我们可以��这2^32个数�Q�划分�ؓ2^8个区�?比如用单个文件代表一个区�?�Q�然后将数据分离��C��同的区域�Q�然后不同的区域在利用bitmap��可以直接解决了。也��是说只要有��_��的磁盘空��_��可以很方便的解冟�?/div>

2).5亿个int扑֮�们的中位数�?/div>

�q�个例子比上面那个更明显。首先我们将int划分�?^16个区域，然后��d��数据�l�计落到各个区域里的数的个数�Q�之后我们根据统计结果就可以判断中位数落到那个区域，同时知道�q�个区域中的�W�几大数刚好是中位数。然后第二次扫描我们只统计落在这个区域中的那些数��可以了�?/div>

�?际上�Q�如果不是int是int64�Q�我们可以经�q?�ơ这��L��划分卛_��降低到可以接受的�E�度。即可以先将int64分成2^24个区域，然后��定区域的第�?大数�Q�在��该区域分成2^20个子区域�Q�然后确定是子区域的�W�几大数�Q�然后子区域里的数的个数只有2^20�Q�就可以直接利用direct addr table�q�行�l�计了�?/div>

6.数据库烦�?/font>

适用范围�Q?/strong>大数据量的增删改�?/div>

基本原理及要点：利用数据的设计实现方法，�Ҏ�v量数据的增删�Ҏ��q�行处理�?/div>
扩展�Q?/strong>

问题实例�Q?/strong>

7.倒排索引(Inverted index)

适用范围�Q?/strong>搜烦引擎�Q�关键字查询

基本原理及要点：��Z��叫倒排索引�Q�一�U�烦引方法，被用来存储在全文搜烦下某个单词在一个文档或者一�l�文档中的存储位�|�的映射�?/div>

以英文�ؓ例，下面是要被烦引的文本�Q?/div>
T0 = "it is what it is"

T1 = "what is it"

T2 = "it is a banana"

我们��p��得到下面的反向文件烦引：

"a": {2}

"banana": {2}

"is": {0, 1, 2}

"it": {0, 1, 2}

"what": {0, 1}

��索的条�g"what", "is" �?"it" ��对应集合的交集�?/div>

�?向烦引开发出来用来存储每个文档的单词的列表�?正向索引的查询往往满��每个文档有序频繁的全文查询和每个单词在校验文档中的验证这��L��查询。在正向索引中，文档占据了中心的位置�Q�每个文档指向了一个它所包含的烦引项的序列。也��是说文档指向了它包含的那些单词�Q�而反向烦引则是单词指向了包含它的文档�Q�很�Ҏ��看到�q�个反向的关�p�R�?/div>

扩展�Q?/strong>

问题实例�Q�文档检索系�l�，查询那些文�g包含了某单词�Q�比如常见的学术论文的关键字搜烦�?/div>

8.外排�?/font>

适用范围�Q�大数据的排序，去重

基本原理及要点：外排序的归�ƈ�Ҏ��Q�置换选择败者树原理�Q�最优归�q�树

扩展�Q?/strong>

问题实例�Q?/strong>

1).有一�?G大小的一个文�Ӟ��里面每一行是一个词�Q�词的大��不��过16个字节，内存限制大小�?M。返回频数最高的100个词�?/div>

�q�个数据��h��很明昄��特点�Q�词的大��ؓ16个字节，但是内存只有1m做hash有些不够�Q�所以可以用来排序。内存可以当输入�~�冲��Z��用�?/div>

9.trie�?/strong>

适用范围�Q�数据量大，重复多，但是数据�U�类��可以放入内�?/div>

基本原理及要�?/strong>�Q�实现方式，节点孩子的表�C�方�?/div>

扩展�Q?/strong>压羃实现�?/div>

问题实例�Q?/strong>

1).�?0个文�Ӟ��每个文�g1G�Q?每个文�g的每一行都存放的是用户的query�Q�每个文件的query都可能重复。要你按照query的频度排�?�?/div>

2).1000万字�W�串�Q�其中有些是相同�?重复),需要把重复的全部去掉，保留没有重复的字�W�串。请问怎么设计和实玎ͼ�

3).��L��热门查询�Q�查询串的重复度比较高，虽然��L��?千万�Q�但如果除去重复后，不超�q?百万个，每个不超�q?55字节�?/div>
10.分布式处�?mapreduce

适用范围�Q�数据量大，但是数据�U�类��可以放入内�?/div>

基本原理及要点：��数据交�l�不同的机器��d��理，数据划分�Q�结果归�U��?/div>

扩展�Q?/strong>

问题实例�Q?/strong>

1).The canonical example application of MapReduce is a process to count the appearances of

each different word in a set of documents:

void map(String name, String document):

   // name: document name

   // document: document contents

   for each word w in document:

   EmitIntermediate(w, 1);

void reduce(String word, Iterator partialCounts):

   // key: a word

   // values: a list of aggregated partial counts

   int result = 0;

   for each v in partialCounts:

   result += ParseInt(v);

   Emit(result);

Here, each document is split in words, and each word is counted initially with a "1" value by

the Map function, using the word as the result key. The framework puts together all the pairs

with the same key and feeds them to the same call to Reduce, thus this function just needs to

sum all of its input values to find the total appearances of that word.

2).��量数据分布�?00台电脑中�Q�想个办法高效统计出�q�批数据的TOP10�?/div>

3).一共有N个机器，每个机器上有N个数。每个机器最多存O(N)个数�q�对它们操作。如何找到N^2个数的中�?median)�Q?/div>

�l�典问题分析

上千万or亿数据（有重复）�Q�统计其中出现次数最多的前N个数�?分两�U�情况：可一�ơ读入内存，不可一�ơ读入�?/strong>

可用思�\�Q?/strong>trie�?堆，数据库烦引，划分子集分别�l�计�Q�hash�Q�分布式计算�Q�近似统计，外排�?/div>

所谓的是否能一�ơ读入内存，实际上应该指去除重复后的数据量。如果去重后数据可以攑օ�内存�Q�我们可以�ؓ数据建立字典�Q�比如通过 map�Q�hashmap�Q�trie�Q�然后直接进行统计即可。当然在更新每条数据的出现次数的时候，我们可以利用一个堆来维护出现次数最多的前N个数据，�?然这样导致维护次数增加，不如完全�l�计后在求前N大效率高�?/div>

如果数据无法攑օ�内存。一斚w��我们可以考虑上面的字典方法能否被改进以适应�q�种情�Ş�Q�可以做的改变就是将字典存放到硬盘上�Q�而不是内存，�q�可以参考数据库的存储方法�?/div>

�?然还有更好的�Ҏ��Q�就是可以采用分布式计算�Q�基本上��是map-reduce�q�程�Q�首先可以根据数据值或者把数据hash(md5)后的��|��数据按照范围划分到不同的机子，最好可以让数据划分后可以一�ơ读入内存，�q�样不同的机子负责处理各�U�的数��D��_��实际上就是map。得到结果后�Q�各个机子只需拿出�?自的出现�ơ数最多的前N个数据，然后汇总，选出所有的数据中出现次数最多的前N个数据，�q�实际上��是reduce�q�程�?/div>

�?际上可能想直接将数据均分��C��同的机子上进行处理，�q�样是无法得到正��的解的。因��Z��个数据可能被均分��C��同的机子上，而另一个则可能完全聚集��C��个机�?上，同时�q�可能存在具有相同数目的数据。比如我们要扑և�现次数最多的�?00个，我们��?000万的数据分布�?0台机器上�Q�找到每台出现次数最多的�?100个，归�ƈ之后�q�样不能保证扑ֈ�真正的第100个，因�ؓ比如出现�ơ数最多的�W?00个可能有1万个�Q�但是它被分��C��10台机子，�q�样在每��C��只有1�?个，假设�q�些机子排名�?000个之前的那些都是单独分布在一台机子上的，比如�?001个，�q�样本来��h��1万个的这个就会被淘汰�Q�即使我们让每台机子�?出出现次数最多的1000个再归�ƈ�Q�仍然会出错�Q�因为可能存在大量个��Cؓ1001个的发生聚集。因此不能将数据随便均分��C��同机子上�Q�而是要根据hash 后的值将它们映射��C��同的机子上处理，让不同的机器处理一个数��D��围�?/div>

而外排序的方法会消耗大量的IO�Q�效率不会很高。而上面的分布式方法，也可以用于单机版本，也就是将�ȝ��数据�Ҏ��值的范围�Q�划分成多个不同的子文�g�Q�然后逐个处理。处理完毕之后再对这些单词的及其出现频率�q�行一个归�q�。实际上��可以利用一个外排序的归�q�过�E��?br>
另外�q�可以考虑�q�似计算�Q�也��是我们可以通过�l�合自然语言属性，只将那些真正实际中出现最多的那些词作��Z��个字典，使得�q�个规模可以攑օ�内存�?br>
转蝲��h��明出处：http://duanple.blog.163.com/blog/static/7097176720091026458369/
作者phylips@bmy

koson 2010-03-15 14:40 发表评论

POJ 2002

koson — Sun, 14 Mar 2010 06:30:00 GMT

在一个坐标内�l�出臛_��1000个不同的点，要求可以形成正方形的个数。��M��思�\是两两枚举不同的点对�Q�然后求��q�两个点可以形成正方形的另外两个点，然后再查找这两个�Ҏ��否存在，查找可以使用哈希或者二分，�l�果昄��哈希的效率比二分的高�?/p>

koson 2010-03-14 14:30 发表评论

我的pku层次分类

koson — Sun, 14 Mar 2010 04:23:00 GMT
本来在google doc上编辑的�Q�但反应很慢�Q�只好搬来这里了

转脓 ACM的算法（觉得很好�Q�有层次感）
OJ上的一些水�?可用来练手和增加自信)
(poj3299*,   poj2159*,    poj2739*   ,poj1083*   ,poj2262*   ,poj1503* (高精�?前导�?,poj3006*(素数,暴力),poj2255*(递归),
poj3094*)

初期:
一.基本��法:
     (1)枚�D. (poj1753*(bfs)   ,poj2965*(推论||bfs) )
     (2)贪心(poj1328*(区间�D?,   poj2109*(long double)   ,poj2586*(分情况讨�?
     (3)递归和分��L��.
     (4)递推.
     (5)构造法.(poj3295*(�?
     (6)模拟�?(poj1068*   ,poj2632*   ,poj1573*   ,poj2993,poj2996)
�?囄��?
     (1)囄��深度优先遍历和广度优先遍�?
     (2)最短�\径算�?heap+dijkstra,dijkstra,bellman-ford,floyd,)
         poj1860
       poj3259*(bellman-ford 换了�U�描�q�而已)
         poj1062*(枚�Dm�U�等�U�即�?每种求最短�\)
         poj2253*(dijkstra思想)
         poj1125*
       poj2240*(floyd)
       poj 3013 #(dijkstra+heap实现的最��优先队�?��L��? )
     (3)最��生成树��法(prim,kruskal)
        (poj1789*,   poj2485*(prim最大边),   poj1258*(prime),   poj3026 ,poj 1251*,poj 1861*(生成树的最大边) )
     (4)拓扑排序
          poj1094 #(深搜�Q�以�l�点讉K��l�束旉��降序��定拓扑��序)
     (5)二分囄��最大匹�?(匈牙利算�? (poj3041*(行列匚w��),poj3020)
     (6)最大流的增�q��\��法(KM��法). (poj3436,   poj 1273 #(基础,使用edmonds-karp��法) ,poj 1459 # (基础构图),poj 1149 # (�l�典构图) )
�?数据�l�构.
     (1)�?(poj1035*(brute force)   ,poj3080*(brute force c string函数使用)   ,poj1936)
     (2)排序(快排、归�q�排(与逆序数有�?、堆�? (poj2388*(qsort),poj2299*(归�ƈ))
     (3)��单�ƈ查集的应�? 2492*(讄��每个虫的一个异性虫) ,1182 #(通过讄��与结点的相对关系来实玎ͼ�要仔�l�推�?, 1988 #( 通过讄��辅助数组保存�l�果��|��q�在查找�q�程中进行更�?
     (4)哈希表和二分查找�{�高效查找法(数的Hash,串的Hash)
        (poj3349*(复杂度超�?不用STL写cmp更快),poj3274,POJ2151,   poj1840*#(hash# || bsearch)   ,poj2002#(hash,hash表保存点信息�Q�枚举两两点对，查找另外两点是否存在,也可使用二分查找�Q�二分效率比较低),   poj2503*(�l�典题目)   ,poj 2513�Q�poj2418#(用二叉查找树插入�Q�插入时如果扑ֈ�相同时则记录数加一�Q�否则作为新的结�Ҏ��入，最后用中序遍历输出) )
     (5)哈夫曼树(poj3253 *(use stl priority_queue and __int64)
     (6)�?poj 2442 #,每次对两个序列用堆在o(nlogn)旉��内求出前n个最��的敎ͼ�然后�q�个作�ؓ新的序列与后面的输入序列作重复处理，实现取前n个数我的�Ҏ��׃��可能取到重复��|��所以加了一个哈希表�q�于判重, poj 2051 #(跟有序链表的K路归�q�一��P��可参照CLRS) )
     (7)trie�?静态徏树、动态徏�? (poj2513*(�q�查�?trie+�Ƨ拉�? poj 3630(用一个结�Ҏ��l�静态模拟动态徏�?
�?��单搜�?nbsp;
     (1)深度优先搜烦 (poj2488*(递归),   poj3083,   poj3009*(dfs剪枝),   poj1321*(dfs),   poj2251*(bfs))
     (2)�q�度优先搜烦(poj3278*(bfs 使用set存储已访问结点��用find函数NlogN),   poj1426,   poj3126*( ),   poj3087*(每次只有一个分支的搜烦).poj3414*(BFS打印路径)
     (3)��单搜索技巧和剪枝(poj2531*(bfs+重复状态剪�?另可以随机化��法,动态规�?�q�没试过) ),   poj1416*(bfs+��单剪�?,   poj2676,1129)
�?动态规�?nbsp;
     (1)背包问题. (poj1837,poj1276)
     (2)型如下表的简单DP(可参考lrj的书 page149):
       1.E[j]=opt{D+w(i,j)} (poj3267,poj1836,poj1260,poj2533)

       2.E[i,j]=opt{D[i-1,j]+xi,D[i,j-1]+yj,D[i-1][j-1]+zij} (最长公共子序列)


         (poj3176,poj1080,poj1159)
       3.C[i,j]=w[i,j]+opt{C[i,k-1]+C[k,j]}.(最优二分检索树问题)
�?数学
     (1)�l�合数学:
        1.加法原理和乘法原�?
        2.排列�l�合.
        3.递推关系.
          (POJ3252,poj1850*(�l�合公式),poj1019*(�{�差数列),poj1942*(�l�合,T�?
     (2)数论.
        1.素数与整除问�?nbsp;
        2.�q�制�?
        3.同余模运��?
          (poj2635*(大整数模), poj3292,poj1845,poj2115)
     (3)计算�Ҏ��.
        1.二分法求解单调函数相关知�?(poj3273*(),   poj3258*,   poj1905*(),   poj3122*()) (数��D��的....)
�?计算几何�?
     (1)几何公式.
     (2)叉积和点�U�的�q�用(如线�D늛�交的判定,点到�U�段的距��ȝ��). (poj2031*(最��生成树),poj1039)

     (3)多边型的��单算�?求面�U?和相兛_��?点在多边型内,多边型是否相�?
         (poj1408*(求四边�Ş面积),   poj1584)
     (4)凸包. (poj2187*(求法,排序使用堆排,或快�? poj1113*())

*****************************************************************************

中��:
一.基本��法:
     (1)C++的标准模版库的应�? (poj3096*,   poj3007)
     (2)较�ؓ复杂的模拟题的训�l?poj3393,poj1472,poj3371,poj1027,poj2706)
�?囄��?
     (1)差分�U�束�pȝ��的徏立和求解. (poj1201,poj2983,poj1364*)
     (2)最��费用最大流(poj2516,poj2195)
     (3)双连通分�?poj2942 ,poj 3177)
     (4)��通分支及其羃�?(poj 2762*(单向�q�通图判断 1983ms ,该怎么优化),poj 2553* ,poj 1236*,)
         poj 2186 #(使用trajan求强�q�通分量，�q�将每个分量�~�成一点�Ş成新的图�Q�最后求出度�?的羃点的个数�Q�如果大于等�?个，则结果�ؓ0�Q�否则对�?br>                           分量的原�l�点个数)
     (5)囄��割边和割�? poj 3177)
         poj 1523 #(每次搜到一个割点i,令tag[i]++,最后输出割点i,�q�通区域的个数为tag[i]+1,�q�不需要每�ơ对图进行搜索求�q�通区域数�?
         poj 3352 #(先找出桥�Q�去掉桥��其余的�q�通分支羃成点�Q�再把桥加到�~�点图上形成一��|��Q�求出度��Cؓ1的点卛_��子结点的数目ret,�l�果�?ret+1)/2)
     (6)最��割模型、网�l�流规约(poj3308, )
�?数据�l�构.
     (1)�U�段�? (poj2528,poj2828,   poj2777*,   poj2886,poj2750,poj2985)
     (2)静态二叉检索树. (poj2482,poj2352)
     (3)树状树组(poj1195*(二��树状,作简单运��?,       poj3321 ,poj2481*,   poj2155)
     (4)RMQ. (poj3264*,   poj3368*(原数�l�的转换)
     (5)�q�查集的高��应用. (poj1703*,2492)
     (6)KMP��法. (poj1961*,poj2406*) 2752* (利用next函数的原�?
�?搜烦
     (1)最优化剪枝和可行性剪�?nbsp;
     (2)搜烦的技巧和优化
         poj3411
         poj1724 #( dfs�Q�剪枝，因�ؓ有重边，所以采用邻接表来表�C��)
     (3)记忆化搜�?poj3373,poj1691)

�?动态规�?nbsp;
     (1)较�ؓ复杂的动态规�?如动态规划解特别的施行商问题�{?
         (poj1191,poj1054,poj3280,poj2029,poj2948,poj1925,poj3034)
     (2)记录状态的动态规�? (POJ3254,poj2411,poj1185)
     (3)树型动态规�?poj2057,poj1947,poj2486,poj3140)
�?数学
     (1)�l�合数学:
        1.�Ҏ��原理.
        2.抽屉原理.
        3.�|�换��与Polya定理(poj1286,poj2409,poj3270,poj1026).
        4.递推关系和母函数.

     (2)数学.
        1.高斯消元�?poj2947,poj1487, poj2065,poj1166,poj1222)
        2.概率问题. (poj3071,poj3440)
        3.GCD、扩展的�Ƨ几里�d(中国剩余定理) (poj3101)
     (3)计算�Ҏ��.
        1.0/1分数规划. (poj2976)
        2.三分法求解单�?单谷)的极�?
        3.矩阵�?poj3150,poj3422,poj3070)
        4.�q�代��D��(poj3301)
     (4)随机化算�?poj3318*   ,poj2454)
     (5)杂题.
         (poj1870,poj3296,poj3286,poj1095)
�?计算几何�?
        (1)坐标��L��?
        (2)扫描�U�算�?例如求矩形的面积和周长�ƈ,常和�U�段树或堆一起��?.
            (poj1765,poj1177,poj1151,poj3277,poj2280,poj3004)
        (3)多边形的内核(半��^面交)(poj3130,poj3335)
        (4)几何工具的综合应�?(poj1819,poj1066,poj2043,poj3227,poj2165,poj3429

)
高��:
一.基本��法要求:
      (1)代码快速写�?�_��但不失风�?nbsp;
          (poj2525,poj1684,poj1421,poj1048,poj2050,poj3306)
      (2)保证正确性和高效�? poj3434
�?囄��?
      (1)度限制最��生成树和第K最短�\. (poj1639)
      (2)最短�\,最��生成树,二分�?最大流问题的相关理�?主要是模型徏立和求解)
         (poj3155, poj2112,poj1966,poj3281,poj1087,poj2289,poj3216,poj2446

      (3)最优比率生成树. (poj2728)
      (4)最��树形图(poj3164)
      (5)�ơ小生成�?
      (6)无向图、有向图的最��环
�?数据�l�构.
      (1)trie囄��建立和应�? (poj2778)
      (2)LCA和RMQ问题(LCA(最�q�公��q��先问�? 有离�U�算�?�q�查�?dfs) �?在线��法
          (RMQ+dfs)).(poj1330*   (此题可以直接使用遍历��Z��条�\径寻找最�q�相同点卛_��.�q�且比RMQ+DFS�q�快)
      (3)双端队列和它的应�?�l�护一个单调的队列,常常在动态规划中起到优化状态�{�U?

�?
          目的). (poj2823)
      (4)左偏�?可合�q�堆).
      (5)后缀�?非常有用的数据结�?也是赛区考题的热�?.
         (poj3415,poj3294)
�?搜烦
      (1)较麻烦的搜烦题目训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426)

      (2)�q�搜的状态优�?利用M�q�制数存储状态、�{化�ؓ串用hash表判重、按位压�~�存�?

状态、双向广搜、A*��法. (poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)
      (3)深搜的优�?��量用位�q�算、一定要加剪枝、函数参数尽可能��、层��C��易过�?

、可以考虑双向搜烦或者是轮换搜烦、IDA*��法. (poj3131,poj2870,poj2286)
�?动态规�?nbsp;
      (1)需要用数据�l�构优化的动态规�?
         (poj2754,poj3378,poj3017)
      (2)四边形不�{�式理论.
      (3)较难的状态DP(poj3133)
�?数学
      (1)�l�合数学.
        1.MoBius反演(poj2888,poj2154)
        2.偏序关系理论.
      (2)博奕�?
        1.极大极小�q�程(poj3317,poj1085)
        2.Nim问题.
�?计算几何�?
      (1)半��^面求�?poj3384,poj2540)
      (2)可视囄��建立(poj2966)
      (3)炚w��最��圆覆盖.
      (4)对踵�?poj2079)
      �?�l�合�?
      (poj3109,poj1478,poj1462,poj2729,poj2048,poj3336,poj3315,poj2148,poj1263

koson 2010-03-14 12:23 发表评论

hash��法大全

koson — Thu, 11 Mar 2010 10:44:00 GMT
     摘要: *** Hash��法大全
* 推荐使用FNV1��法* @algorithm None* @author Goodzzp 2006-11-20* @lastEdit Goodzzp 2006-11-20 * @editDetail Create*/pub...  阅读全文

koson 2010-03-11 18:44 发表评论

有层�ơPKU ACM分类

koson — Sun, 07 Mar 2010 12:03:00 GMT

OJ上的一些水�?可用来练手和增加自信)
(poj3299,poj2159,poj2739,poj1083,poj2262,poj1503,poj3006,poj2255,poj3094)
初期:
一.基本��法:
(1)枚�D. (poj1753,poj2965)
(2)贪心(poj1328,poj2109,poj2586)
(3)递归和分��L��.
(4)递推.
(5)构造法.(poj3295)
(6)模拟�?(poj1068,poj2632,poj1573,poj2993,poj2996)
�?囄��?
(1)囄��深度优先遍历和广度优先遍�?
(2)最短�\径算�?dijkstra,bellman-ford,floyd,heap+dijkstra)
(poj1860,poj3259,poj1062,poj2253,poj1125,poj2240)
(3)最��生成树��法(prim,kruskal)
(poj1789,poj2485,poj1258,poj3026)
(4)拓扑排序 (poj1094)
(5)二分囄��最大匹�?(匈牙利算�? (poj3041,poj3020)
(6)最大流的增�q��\��法(KM��法). (poj1459,poj3436)
�?数据�l�构
(1)�?(poj1035,poj3080,poj1936)
(2)排序(快排、归�q�排(与逆序数有�?、堆�? (poj2388,poj2299)
(3)��单�ƈ查集的应�?
(4)哈希表和二分查找�{�高效查找法(数的Hash,串的Hash)
(poj3349,poj3274,POJ2151,poj1840,poj2002,poj2503)
(5)哈夫曼树(poj3253)
(6)�?
(7)trie�?静态徏树、动态徏�? (poj2513)
�?��单搜�?
(1)深度优先搜烦 (poj2488,poj3083,poj3009,poj1321,poj2251)
(2)�q�度优先搜烦(poj3278,poj1426,poj3126,poj3087.poj3414)
(3)��单搜索技巧和剪枝(poj2531,poj1416,poj2676,1129)
�?动态规�?
(1)背包问题. (poj1837,poj1276)
(2)型如下表的简单DP(可参考lrj的书 page149):
1.E[j]=opt{D+w(i,j)} (poj3267,poj1836,poj1260,poj2533)
2.E[i,j]=opt{D[i-1,j]+xi,D[i,j-1]+yj,D[i-1][j-1]+zij} (最长公共子序列)

(poj3176,poj1080,poj1159)
3.C[i,j]=w[i,j]+opt{C[i,k-1]+C[k,j]}.(最优二分检索树问题)
�?数学
(1)�l�合数学:
1.加法原理和乘法原�?
2.排列�l�合.
3.递推关系.
(POJ3252,poj1850,poj1019,poj1942)
(2)数论.
1.素数与整除问�?
2.�q�制�?
3.同余模运��?
(poj2635, poj3292,poj1845,poj2115)
(3)计算�Ҏ��.
1.二分法求解单调函数相关知�?(poj3273,poj3258,poj1905,poj3122)
�?计算几何�?
(1)几何公式.
(2)叉积和点�U�的�q�用(如线�D늛�交的判定,点到�U�段的距��ȝ��).
(poj2031,poj1039)

(3)多边型的��单算�?求面�U?和相兛_��?点在多边型内,多边型是否相�?
(poj1408,poj1584)
(4)凸包. (poj2187,poj1113)
中��:
一.基本��法:
(1)C++的标准模版库的应�? (poj3096,poj3007)
(2)较�ؓ复杂的模拟题的训�l?poj3393,poj1472,poj3371,poj1027,poj2706)
�?囄��?
(1)差分�U�束�pȝ��的徏立和求解. (poj1201,poj2983)
(2)最��费用最大流(poj2516,poj2195)
(3)双连通分�?poj2942)
(4)��通分支及其羃�?(poj2186)
(5)囄��割边和割�?poj3352)
(6)最��割模型、网�l�流规约(poj3308, )
�?数据�l�构.
(1)�U�段�? (poj2528,poj2828,poj2777,poj2886,poj2750)
(2)静态二叉检索树. (poj2482,poj2352)
(3)树状树组(poj1195,poj3321)
(4)RMQ. (poj3264,poj3368)
(5)�q�查集的高��应用. (poj1703,2492)
(6)KMP��法. (poj1961,poj2406)
�?搜烦
(1)最优化剪枝和可行性剪�?
(2)搜烦的技巧和优化 (poj3411,poj1724)
(3)记忆化搜�?poj3373,poj1691)

�?动态规�?
(1)较�ؓ复杂的动态规�?如动态规划解特别的施行商问题�{?
(poj1191,poj1054,poj3280,poj2029,poj2948,poj1925,poj3034)
(2)记录状态的动态规�? (POJ3254,poj2411,poj1185)
(3)树型动态规�?poj2057,poj1947,poj2486,poj3140)
�?数学
(1)�l�合数学:
1.�Ҏ��原理.
2.抽屉原理.
3.�|�换��与Polya定理(poj1286,poj2409,poj3270,poj1026).
4.递推关系和母函数.

(2)数学.
1.高斯消元�?poj2947,poj1487, poj2065,poj1166,poj1222)
2.概率问题. (poj3071,poj3440)
3.GCD、扩展的�Ƨ几里�d(中国剩余定理) (poj3101)
(3)计算�Ҏ��.
1.0/1分数规划. (poj2976)
2.三分法求解单�?单谷)的极�?
3.矩阵�?poj3150,poj3422,poj3070)
4.�q�代��D��(poj3301)
(4)随机化算�?poj3318,poj2454)
(5)杂题.
(poj1870,poj3296,poj3286,poj1095)
�?计算几何�?
(1)坐标��L��?
(2)扫描�U�算�?例如求矩形的面积和周长�ƈ,常和�U�段树或堆一起��?.
(poj1765,poj1177,poj1151,poj3277,poj2280,poj3004)
(3)多边形的内核(半��^面交)(poj3130,poj3335)
(4)几何工具的综合应�?(poj1819,poj1066,poj2043,poj3227,poj2165)
高��:
一.基本��法要求:
(1)代码快速写�?�_��但不失风�?
(poj2525,poj1684,poj1421,poj1048,poj2050,poj3306)
(2)保证正确性和高效�? poj3434
�?囄��?
(1)度限制最��生成树和第K最短�\. (poj1639)
(2)最短�\,最��生成树,二分�?最大流问题的相关理�?主要是模型徏立和求解)
(poj3155, poj2112,poj1966,poj3281,poj1087,poj2289,poj3216,poj2446
(3)最优比率生成树. (poj2728)
(4)最��树形图(poj3164)
(5)�ơ小生成�?
(6)无向图、有向图的最��环
�?数据�l�构.
(1)trie囄��建立和应�? (poj2778)
(2)LCA和RMQ问题(LCA(最�q�公��q��先问�? 有离�U�算�?�q�查�?dfs) �?在线��?br>�?(RMQ+dfs)).(poj1330)
(3)双端队列和它的应�?�l�护一个单调的队列,常常在动态规划中起到优化状态�{
�Uȝ��目的). (poj2823)
(4)左偏�?可合�q�堆).
(5)后缀�?非常有用的数据结�?也是赛区考题的热�?.
(poj3415,poj3294)
�?搜烦
(1)较麻烦的搜烦题目训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426
)
(2)�q�搜的状态优�?利用M�q�制数存储状态、�{化�ؓ串用hash表判重、按位压�~�存
�?

状态、双向广搜、A*��法. (poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)
(3)深搜的优�?��量用位�q�算、一定要加剪枝、函数参数尽可能��、层��C��易过
�?
、可以考虑双向搜烦或者是轮换搜烦、IDA*��法. (poj3131,poj2870,poj2286)
�?动态规�?
(1)需要用数据�l�构优化的动态规�?
(poj2754,poj3378,poj3017)
(2)四边形不�{�式理论.
(3)较难的状态DP(poj3133)
�?数学
(1)�l�合数学.
1.MoBius反演(poj2888,poj2154)
2.偏序关系理论.
(2)博奕�?
1.极大极小�q�程(poj3317,poj1085)
2.Nim问题.
�?计算几何�?
(1)半��^面求�?poj3384,poj2540)
(2)可视囄��建立(poj2966)
(3)炚w��最��圆覆盖.
(4)对踵�?poj2079)
�?�l�合�?

(poj3109,poj1478,poj1462,poj2729,poj2048,poj3336,poj3315,poj2148,poj1263

)

koson 2010-03-07 20:03 发表评论

PKU题目分类

koson — Sun, 07 Mar 2010 11:57:00 GMT
pku上的题目分类

动态规划：
1037 A decorative fence�?050 To the Max�?088 滑雪�?125 Stockbroker Grapevine�?141 Brackets Sequence�?159 Palindrome�?160 Post Office�?163 The Triangle

�?458 Common Subsequence�?579 Function Run Fun�?887 Testing the CATCHER�?953 World Cup Noise�?386 Lake Counting

��单、模拟题�Q?br> 1001 Exponentiation �?002 487-3279�?003 Hangover �?701 Dissatisfying Lift�?301 Beat the Spread!�?304 Combination Lock�?328 Guessing Game�?403 Hay

Points �?406 Power Strings�?339 Rock, Scissors, Paper�?350 Above Average�?218 Does This Make Me Look Fat?�?260 Error Correction�?262 Goldbach\'s

Conjecture�?272 Bullseye�?136 Vertical Histogram�?174 Decoding Task�?183 Bovine Math Geniuses�?000 Gold Coins�?014 Flow Layout�?051 Argus�?081

Calendar�?918 Ranking List�?922 Ride to School�?970 The Game�?972 Dice Stacking�?974 The Happy Worm�?978 Hanafuda Shuffle�?979 Red and Black�?617

Crypto Columns�?666 Candy Sharing Game�?674 Sorting by Swapping�?503 Integer Inquiry�?504 Adding Reversed Numbers�?528 Perfection�?546 Basically

Speaking�?547 Clay Bully�?573 Robot Motion�?575 Easier Done Than Said?�?581 A Contesting Decision�?590 Palindromes�?454 Factorial Frequencies�?363

Rails�?218 THE DRUNK JAILER�?281 MANAGER�?132 Border�?028 Web Navigation�?br> 博弈�c?br> 1067 取石子游戏�?740 A New Stone Game�?234 Matches Game�?082 Calendar Game �?348 Euclid\'s Game�?413 How many Fibs?�?419 Forests
初等数学
1003 Hangover�?045 Bode Plot�?254 Hansel and Grethel�?269 Intersecting Lines�?401 Factorial�?410 Intersection�?363 Blocks �?365 Rope�?242 The

Circumference of the Circle�?291 Rotten Ropes�?295 A DP Problem�?126 Factoring a Polynomial�?191 Mersenne Composite Numbers�?196 Specialized Four-Digit

Numbers�?914 Cramer\'s Rule�?835 宇航员�?799 Yeehaa!�?607 Deck�?244 Slots of Fun�?269 Intersecting Lines�?299 Polar Explorer�?183 反正切函数的应用�?br>
图论及组合数�?br> 2421 Constructing Roads�?369 Permutations�?234 Matches Game�?243 Knight Moves�?249 Binomial Showdown�?255 Tree Recovery�?084 Game of Connections�?906

Three powers�?833 排列�?850 Code�?562 Oil Deposits�?496 Word Index�?306 Combinations�?125 Stockbroker Grapevine�?129 Channel Allocation�?146 ID Codes

�?095 Trees Made to order、找规律2247 Humble Numbers�?309 BST�?346 Lucky tickets�?370 Democracy in danger�?365 Rope�?101 Honey and Milk Land
2028 When Can We Meet?�?084 Game of Connections�?915 Knight Moves�?922 Ride to School�?941 The Sierpinski Fractal�?953 World Cup Noise�?958 Strange

Towers of Hanoi�?969 Count on Canton�?806 Manhattan 2025�?809 Regetni�?844 Sum�?870 Bee Breeding�?702 Eva\'s Balance�?728 A flea on a chessboard�?604

Just the Facts�?642 Stacking Cubes�?656 Counting Black�?657 Distance on Chessboard�?662 CoIns�?663 Number Steps�?313 Booklet Printing�?316 Self

Numbers�?320 Street Numbers�?323 Game Prediction�?338 Ugly Numbers�?244 Slots of Fun�?250 Tanning Salon�?102 LC-Display�?147 Binary codes�?013

Counterfeit Dollar�?br> ---------------------------------------------------------------------------------------------------------------------------
题目分类
排序 1002�Q�需要字�W�处理，排序用快排即可） 1007�Q�稳定的排序�Q?2159�Q�题意较难懂�Q?2231 2371�Q�简单排序） 2388�Q�顺序统计算法） 2418�Q�二叉排序树�Q?br>
回溯搜烦�Q?979�Q�和�q�宫�c�M��Q?1980�Q�对剪枝要求较高�Q?br>
数学计算  ��单（或不值得做的题）�Q?003 1004 1005 1068 1326 1656 1657 1658 1663 1922 1978 2000 2013 2014 2017 2070 2101 2105 2140 2190 2272 2301 2405 2419
      中等�Q?006�Q�中国剩余定理） 1323 1969 2015�Q�解密码�Q?2081�Q�预处理�Q?2085�Q�找规律�Q?br> 难：  1014 1037 1147 2082  �Q�这些是上课讲的�Q?br>
高精度计��：1001�Q�高�_�ֺ�乘法�Q?2413(高精度加法，�q�有二分查找)

历法�Q?008 2080 �Q�这�U�题要小心）

枚�D�Q?054�Q�剪枝要求较高） 1650 �Q�小数的�_�ֺ�问题�Q?br>
数据�l�构的典型算法：1125(弗洛伊�d��法) 2421�Q�图的最��生成树�Q?br>
动态规划：1163�Q�经兔R��Q?br>
贪心�Q?328 1755�Q�或用单�U��Ş�Ҏ��Q?2054

模拟�Q?1281 1928 2083 2141 2015

递归�Q?1664
字符串处理：2121 2403

---------------------------------------------------------------------------------------------------------------------------
有标准模型的�Q?br> 1125 1163 1183 1979 1185 1184 1187
��L��新算法的�Q?br> 1014 1067 1147 1922 2082
调节情��A用：
1004 950 1218 1281 1928 1978 2000 2027

---------------------------------------------------------------------------------------------------------------------------
��L��法�Q?br> 1.搜烦　//回溯
2.DP�Q�动态规划）　
3.贪心　
4.图论　//Dijkstra、最��生成树、网�l�流
5.数论　//解模�U�性方�E?br> 6.计算几何　//凸壳、同�{�安�|�矩形的�q�的面积与周�?br> 7.�l�合数学　//Polya定理
8.模拟　
9.数据�l�构　//�q�查集、堆
10.博弈论　
//表示举例

非主��算法：
1.送分题　
2.构造　
3.高精度　
4.几何　
5.排序　
6.日期/旉��处理　�Q�这�c�题目相当多的）
7.数学�Ҏ��　
8.枚�D　
9.递推　
10.递归　
11.分治　

说明�Q?br> 昄��“送分�?#8221;不是一�U�算法。但是ACM竞赛中经常有一些很��单很��单的题目�Q�具体涉及内容繁杂，难以归类�Q�干脆就��他们叫送分题�?br> 几何不同于计��几何，计算几何或者叫S计算几何�Q�以Shamos�?975�q�发表的一��论文�ؓ诞生标志。其实两者有很大的不同�?br>
部分题目分类�l�计�Q?br>
�|�络��：
最大流�Q?br> 1087 a plug for UNIX
1149 PIGS
1273 drainage ditches
1274 the perfect stall
1325 machine schedule
1459 power network
2239 selecting courses
最��费用最大流�Q?br> 2195 going home
?2400 supervisor, supervisee

压羃存储的DP
1038 bugs integrated inc
1185 炮兵阵地
2430 lazy cow

最长公共子�Ԍ��LCS�Q�：
1080 human gene functions
1159 palindrome
1458 common subsequence
2192 zipper

凸包
1113 wall
2187 beauty contest

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

说明�Q�递推��动归， ��L��化算数据�l�构�Q?�q�查集算数据�l�构�Q?博弈��动归， �ȝ��题一般都是不错的�l�合题，最短�\��图论，数据的有序化��排�?br>
�ȝ��题：
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,
推荐�Q?br> 1063, 1064, 1131, 1140, 1715, 2163,

杂题�Q?br> 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,
推荐�Q?br> 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,

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

搜烦
�Ҏ��Q?br> 1128, 1166, 1176, 1231, 1256, 1270, 1321, 1543, 1606, 1664, 1731, 1742, 1745, 1847, 1915, 1950, 2038, 2157, 2182, 2183, 2381, 2386, 2426,
不易�Q?br> 1024, 1054, 1117, 1167, 1708, 1746, 1775, 1878, 1903, 1966, 2046, 2197, 2349,
推荐�Q?br> 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,

数据�l�构
�Ҏ��Q?br> 1182, 1656, 2021, 2023, 2051, 2153, 2227, 2236, 2247, 2352, 2395,
不易�Q?br> 1145, 1177, 1195, 1227, 1661, 1834,
推荐�Q?br> 1330, 1338, 1451, 1470, 1634, 1689, 1693, 1703, 1724, 1988, 2004, 2010, 2119, 2274,

动态规�?br> �Ҏ��Q?br> 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,
不易�Q?br> 1019, 1037, 1080, 1112, 1141, 1170, 1192, 1239, 1655, 1695, 1707, 1733, 1737, 1837, 1850, 1920, 1934, 1937, 1964, 2039, 2138, 2151, 2161, 2178,
推荐�Q?br> 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,

贪心�Q?br> 1042, 1065, 1230, 1323, 1477, 1716, 1784,

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

计算几何
�Ҏ��Q?br> 1319, 1654, 1673, 1675, 1836, 2074, 2137, 2318,
不易�Q?br> 1685, 1687, 1696, 1873, 1901, 2172, 2333,
凸包�Q?br> 1113, 1228, 1794, 2007, 2187,

模拟
�Ҏ��Q?br> 1006, 1008, 1013, 1016, 1017, 1169, 1298, 1326, 1350, 1363, 1676, 1786, 1791, 1835, 1970, 2317, 2325, 2390,
不易�Q?br> 1012, 1082, 1099, 1114, 1642, 1677, 1684, 1886,

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

---------------------------------------------------------------------------------------------------------------------------
POJ部分题目分类
��法入门�Q�简单题�Q?br> 1000 1003 1004 1005 1006 1007 1015�Q�学会dp�Q?1016 10171018 1042�Q�dp�Q?1046�Q�简单数学） 1054�Q�简单的剪枝�Q?1062�Q�dp�Q?1068
1095 1113�Q�凸包，但规模小�Q�O(n^2)的也行）  1125  1127  1152  1154
1183�Q�用�W�算��）  1218 1221 1244 1281 1312 1313�Q�找找规律）
1315�Q�学会搜索） 1321�Q�同1315�Q?1323(dp)  1326 1331 1491
1493�Q�找规律�Q?1503�Q�高�_�ֺ��Q?1504 1517 1519 1547 1552
1563�Q�考虑仔细一点，�q�要注意�_�ֺ��Q?1650�Q�不是好题） 1651�Q�dp�Q?1656
1657 1658 1663 1675�Q�计��几何） 1681 1702�Q�三�q�制�q�算�Q?1799
1828 1862�Q�简单数学） 1887 1906�Q�实战好题） 1914 1915�Q�宽搜）
1928 1936 1978 1979 2000 2019�Q�dp好题�Q?2027�Q�垃��N��Q?2028
2078�Q�不要重复搜索） 2080 2081 2083 2140 2141 2184�Q�活用dp�Q?br> 2190 2192 2193 2196 2199 2209 2211  2243 2248�Q�搜索）
2260 2261 2262 2291 2301 2304 2309�Q�找规律�Q?2316 2317
2318 2325 2355 2357 2363 2378�Q�树的dp�Q?2381 2385 2393
2394 2395 2413�Q�高�_�ֺ�基础�Q?2418 2419

�l�典
1011�Q�搜索好题）
1012�Q�学会打表）
1013
1019�Q�它体现了很多此�c�问题的特点�Q?br> 1050�Q�绝对经典的dp�Q?br> 1088�Q�dp好题�Q?br> 1157�Q�花店，�l�典的dp�Q?br> 1163�Q�怎么�l�典的dp那么多呀�Q�？�Q�）
1328�Q�贪心）
1458�Q�最长公共子序列�Q?br> 1647�Q�很好的真题�Q�考��场分析准��和下手�q�速）
1654�Q�学会多边�Ş面积的三角�Ş求法�Q?br> 1655�Q�一�c�L��Ҏ��的dp问题�Q?br> 1804�Q�逆序对）
2084�Q�经典组合数学问题）
2187�Q�用凸包求最�q�点对，求出凸包后应该有O(N)的求法，可我��是调不出来�Q?br> 2195�Q�二分图的最佛_��配）
2242�Q�计��几何经典）
2295�Q�等式处理）
2353�Q�dp�Q�但要记录最佌��\径）
2354�Q�立体解析几何）
2362�Q�搜索好题）
2410�Q�读懂题是关键）
2411�Q�经典dp�Q?br>
��味
1067�Q�很隄��数学�Q�但仔细研究�Q�是一片广阔的领域�Q?br> 1147�Q�有O(n)的算法，需要思考）
1240�Q�直��C��|��的先序和后序遍历�Q�那么有几种中序遍历呢？dp�Q?br> 1426�Q�是数论吗？错，是图论！�Q?br> 1648�Q�别用计��几何，用整点这个特点绕�q�精度的障碍吧）
1833�Q�找规律�Q?br> 1844�Q�貌似dp或是搜烦�Q�其实是道有��的数学题）
1922�Q�贪心，哈哈�Q?br> 2231
2305�Q�不需要高�_�ֺ�噢）
2328�Q�要仔细噢）
2356�Q�数论知识）
2359�Q�约瑟夫问题变种�Q?br> 2392�Q�有��的问题�Q?br>
很繁的题
1001
1008
1087�Q�构囑־�烦，�q�有二分囄��最大匹配）
1128�Q�USACO�Q?br> 1245
1329
1550�Q�考的是读题和理解能力�Q?br> 1649�Q�dp�Q?br> 2200�Q�字�W�串处理+枚�D�Q?br> 2358�Q�枚丑֒�避免重复都很烦）
2361�Q�仔�l�仔�l�再仔细�Q?br>
��N��
1014�Q�数学证明比较难�Q�但有那�U�想法更重要�Q?br> 1037�Q�比较难的dp�Q?br> 1405�Q�高�_�ֺ��法也分有等�U�之分，不断改进吧）
2002�Q�不知道有没有比O(n^2*logn)更有的算法？�Q?br> 2054�Q�极难，很强的思考能力）
2085�Q�组合数学）
2414�Q�dp�Q�但要剪枝）
2415�Q�搜索）
2423�Q�计��几�?�l�计�Q?br>
多解�?br> 1002�Q�可以用排序�Q�也可以用统计的�Ҏ��Q?br> 1338�Q�搜索和dp都可以）
1664�Q�搜索和dp都练一�l�吧�Q?br> 2082�Q�这可是我讲的题噢）
2352�Q�桶排和二叉树都行）

---------------------------------------------------------------------------------------------------------------------------
Instruction:
If there is an * after a problem ID, it means a simple note followed below.
For freshman:
1001 1002 1007 1008 1012 1016 1068 1163 1218(*)
1281 1316 1326 1411 1552 1647 1650 1658 1659 1663
1666 1928 1936 2013 2014 2017 2080 2083 2105 2136
2141 2163 2242 2244 2328 2386 2403 2405 2413 2419
A little skill needed:
1013 1026 1029(similar to 1013) 1147 1152 1405 1649 1657 1922
2081 2085 2140 2159 2247 2309 2402
Math problem:
1006 1061 1095 1183 1700(*) 1844 1862 2084(*) 2232 2234(*)
Search:
1011(*) 1129 2078(*) 2362(similar to 1011)
Graph:
1062 1094 1125 1128 1130 1655 1661 1674(*) 1909 2049 2195(*) 2395(*)
2421
DP problems:
1029 1050 1080 1088 1651 1664 1742(*) 2181 2192 2392(similar to 1742)
2397 2411(*)
Greedy:
1017(*) 1065 1083(*) 1089 1323 1328 1505(*) 1828 2082(*) 2393
Data Structure :
1988(*) 2051(*) 2182(*) 2236(*) 2424
Others:
1150(*) 1654(*) 1833 1835 2299(*) 2406(*) 2407
A bit complicated:
1021(*) 1054 1863(*) 2015
Great Challenging
1014(*)

Note:
1011: 很经典的剪支
1014: 隑֜�数学�?br> 1017: 严格的数学证明貌��g��Ҏ��
1021: 有点�J?考察对图形进行各�U�旋转的处理
1083: 巧妙的思考角�?br> 1150: 分奇偶讨�?lg(n)��法
1218: 三行��够�?虽然��?但也有优劣之�?br> 1505: 二分加贪�?br> 1654: 做法也许很多�?本�h用有向面�U�做�?br> 1674: 计算圈的个数(��是graph �?
1700: 数学证明不容�?br> 1742: O(m*n)的算�?br> 1863: 要耐心地慢慢写…^_^
1988: �q�查�?br> 2051: �?br> 2078: 不难�Q�但剪支可以做到很好
2082::O(n),你想��C��吗？
2084: 卡特兰数
2182: �U�段�?br> 2195: 最��费用最大流
2234: �l�典博弈��法
2236: �q�查�?br> 2299: 二分思想
2395: Kruskal 最��生成树的拓�?br> 2406: KMP
2411: 用二�q�制串来表示状�?br>
---------------------------------------------------------------------------------------------------------------------------
Judge Online
基础�?
1000,1003,1004,1005,1008,1012,1013,1016,1019,1022
1026,1028,1029,1035,1046,1247,1298,1316,1326,1401
1504,1547,1552,1647,1648,1649,1650,1651,1652,1653
1657,1658,1663,1750,1754,1922,1928,1969,2027,2080
2081,2085,2105,2136,2190,2210,2249,2272,2273,2275
2291,2295,2301,2304,2316,2328,2334,2381,2390
基本数据�l�构:
�?
1442
排序分治:
1002,1007,1400,2084,2282,2299,2318,2379,2388
递归枚�D搜烦:
1010,1011,1018,1020,1054,1062,1256,1321,1363,1501
1650,1659,1664,1753,2078,2083,2303,2310,2329
动态规�?
1015,1163,1404,1651,1661,1742,2292,2385,2392
贪心:
1017,2054,2336,2393
图论�|�络��?
1021,1024,1027,1088,1125,1130,1154,1502,1751,2309
2312,2386,2387,2394,2395
数论:
1006,1014,1023,1061,1152,1183,1730,2262
计算几何:
1654,2179,2284
模拟�?
1049,1051,1234,1207,1218,1281,2271,2302,2317,2339
高精度数��D��?
1001,1131,1503,2305,2325,2389
概率�l�计:
1037,1050
其他:
1009,1147,2082

---------------------------------------------------------------------------------------------------------------------------
POJ已完成题目小�l?br> 基础题（比较�Ҏ��Q�应该很快做出来的）:
1000,1003,1004,1005,1008,1012,1013,1016,1019,1026,1046,1102,1107,1247,1298,1316,1326,
1519,1543,1547,1552,1565,1581,1647,1649,1648,1651,1652,1657,1658,1731,1799,1922,1928,
1969,2000,2013,2014,2017,2027,2070,2080,2081,2105,2136,2140,2041,2159,2190,2301,2350,
2388,2389,2390
数据�l�构�Q�包括最短�\�Q�最��生成树�{�）:2421,2092

排序分治: 1002,1007,2388

递归枚�D搜烦�Q�有些题目还是比较难�~�的�Q? 1054,2083,1318, 1321,1363,1659,1664,1062, 1190,1831,2386
博弈�?067,
构造（比较难想出来的） 1091, 1147
动态规划（有些很基��的，但也有很隄��哦）: 1163, 1014, 1037, 1062, 1088, 1190
贪心�Q�仔�l�想惌��是能够想到的�Q? 1017, 1042,1328, 1659�Q?092
图论�Q?125
数论�Q�想啊想�Q? 1006,1014,1061,1953
计算几何: 1654
模拟题（有些模拟题那个难�~�阿�Q? 1207,1218,1281,1323,1350,1455,1928�Q?051,2424
高精度数��D��（��是基础题）: 1001,1131,1405,1517,1604,2389
密码题里面一道可以的�Q?015

---------------------------------------------------------------------------------------------------------------------------
POJ已完成题目小�l?br> �Q�截�?005�q?�?2日）

归类�Q?br> 分类原则�Q�以��法核心指向��Z��
��法
题目
枚�D
1012 1046 1387 1411 2245 2326 2363 2381
搜烦、回溯、遍�?br> 1010 1011 1022 1054 1111 1118 1129 1190 1562 1564 1573 1655 2078 2184 2225 2243 2312 2362 2378 2386
动态规�?br> 1015 1018 1050 1088 1159 1163 1221 1322 1458 1579 1651 1664 1742 1745 1953 2033 2084 2229 2385 2392 2393
图论�Q�不含图遍历�Q?br> 1125 1128 1130 2320 2387 2394 2395
贪心
1017 1328 1862 1922 2054 2209 2313 2325 2370
计算几何
1648 1654 1927 2007 2098 2208 2242 2276 2318
数论
1061 1320 1597 1808 1811 1845
其他数学、历�?br> 1005 1006 1008 1032 1067 1152 1183 1209 1401 1423 1491 1517 1528 1543 1707 1799 1844 1905 1914 1942 2080 2126 2140 2190 2210 2234 2249 2299 2321 2348 2354

2365
��L��_�ֺ��q�算、数字游�?br> 1001 1023 1047 1060 1079 1131 1140 1142 1207 1220 1284 1289 1306 1316 1338 1405 1454 1503 1504 1519 1565 1650 1969 2000 2006 2081 2247 2262 2305 2316 2389
基础��法、数据结�?br> 1002 1007 1028 1281 1308 2092 2104 2106 2340 2352 2366 2371
字符串处�?br> 1016 1051 1126 1318 1572 1917 1936 2039 2083 2136 2271 2317 2330
人工逻辑
1013
机械模拟、语�a�解析�?br> 1049 1600 1684 1928 2050 2339 2383
其他题目
1014 1026 1045 1083 1102 1146 1477 1647 1656 1657 1660 1926 2018 2082 2231 2309 2359 2369 2380
构�?br> 1147 1256 1426 1659 1833 1898 1906 2015 2085 2144 2201 2319 2356
无聊题目
1000 1003 1004 1218 1298 1326 1552 1658 1665 2013 2017 2027 2105 2109 2272 2301 2328 2350 2388 2390
总计�Q?28�?br> ---------------------------------------------------------------------------------------------------------------------------
模拟题：
1002 1004 1005 1008 1016 1326 1928 2136 2424

高精度：
1001

枚�D�Q?br> 1012 1013

贪心�Q?br> 1017 1922

循环�Q?br> 1026

动态规划：
1163

递归�Q?br> 1664

最��生成树�Q?br> 2421

其他�Q?br> 1000 1147 1657 1658 2082
---------------------------------------------------------------------------------------------------------------------------

Judge On line
本学期刚开始做�Q�不是很多，分得较细�Q?br> 一、按�c�d��
基础�?
1000,1003,1004,1005�Q?013�Q?017
模拟�?
1281 1922 1928
2080 �Q�细心）
排序分治:
1002
动态规�?
1037  �Q�大规模�Q?
2084 �Q�做高精度）
贪心:
2054
数论:
1001 整数�q�算�Q�作高精度）
1014 集合划分�Q�与分治
1147 1163 2081 2085数列问题
几何有关的题目：
1054 解析几何+搜烦
2014
2016计算几何
2082集合的合�qӞ��q�算�Q�几何角度）
2083 分�Ş�Q�纯数学�Q?br> 图：
1125
利用题目所�l�信息来推演�Q?br> 2015
二、按难易
��单题
最基础的适应POJ的习题：1000 1003 1004 1005 2013 2017
需要根据情景稍微动下脑�{�的习题�Q?922
需要对语言有很深刻的了解，�ȝ��基本功的�Q?002 1281 2014 2081
要求初步熟练��法的习题：1928

中档题：
�ȝ��l�心考虑问题全面的习题：1001 2015 2080
要求熟练��法的习题：1054 1163 2084

��N��Q?br> �Ҏ��学要求很高的题目�Q?083 2085
对算法要求很高的题目�Q?125 2054
对综合能力要求很高的题目�Q?037 2016 2082
技巧性高的题目：1147
�ȝ��英文读题的题目：2015 2082

三、需要有很强的判断力的题目：
判断高精度： 2084
判断耗时�Q?002
判断变量�c�d��Q?001
要求会寻��N��目以外的信息�Q?080

koson 2010-03-07 19:57 发表评论

POJ 1837

koson — Tue, 01 Dec 2009 07:16:00 GMT
背包问题变�Ş�Q�定义数�l�，dp[21][4000+4000]�Q�dp[i][j]表示挂了i个砝码时力矩和�ؓj的方法数�Q�因为力矩可能�ؓ负，所以加�?000的位�U�量�Q�这��P��最�?dp[C][4000]即�ؓ所求的�l�果。状态�{�U�L��E��ؓ: dp[1][4000+c[k]*g[1]]=1�Q�k=1,,, C,挂一个砝码时�q�行初始�? 对于i=2,,,G, dp[i][j]+=dp[i-1][j- c[k]*g[i]], k=1,,,,C.�?

koson 2009-12-01 15:16 发表评论

POJ 3007

koson — Thu, 26 Nov 2009 06:23:00 GMT
��单枚举，每次分八�U�情��c�?使用stl一直TLE�Q�用hash�q�了�?一开始用next_permutation列出所有排列然后判断此排列是否属于所求的��|��后来发现next_permutation的复杂度为o(N!)�Q�所以一直TLE�?

koson 2009-11-26 14:23 发表评论

ZOJ 2050

koson — Wed, 25 Nov 2009 07:57:00 GMT
基础BFS题，使用一�?2位的int�?6位来存储状态，如果是b�Q�则对应位置�?�Q�否则�ؓ0。状态空间最多有2^16-1=65535个状态，实际剪枝后去掉了相当多的冗余状态。这题输入包含了�I��Q��用scanf(" ")来获取清除空行，因�ؓ�q�个贡献了几个presetation error�?

koson 2009-11-25 15:57 发表评论

poj 1157

koson — Tue, 17 Nov 2009 12:42:00 GMT
dp 设r[i][j]为i朵花攑֜�j个花瓶的最大�h�?br>初始�?nbsp; r[0][j]=0,j =1,2,...V
r[i][i]=r[i-1][i-1]+A[i][i]; i=1,2,...F
DP状态�{�U�L��E? i>=1,2,...F, j>=i+1,i+2,...V    r[i][j]=max{ r[i][j-1], r[i-1][j-1]+A[i][j] };
r[F][V]即�ؓ所求结�?

koson 2009-11-17 20:42 发表评论

zoj 1082

koson — Tue, 17 Nov 2009 08:37:00 GMT

图论�?br>用floyd求出所有点对之前的最短距��，遍历每个点作为出发点�Q�它与所有其它点之间的最长距��d��为当前出发点出发所需的时��_��再取出所有出发点的时间的最��值即为所求。注意当考虑某个出发�Ҏ��Q�如果存在某个点达不刎ͼ�则这�U�情�늛�接丢弃。另外还需考虑图不�q�通的情况�?/p>

koson 2009-11-17 16:37 发表评论

ZOJ 1029 moving tables

koson — Fri, 13 Nov 2009 05:51:00 GMT

枚�D所有移动，对当前移动，初始化移动次��Cؓ1�Q�保存�v始点和目标点�Q�然后判断所有的�U�d��Q�不包含当前�U�d��Q�，如果�U�d��区间跟当前移动有交叉�Q�则�U�d��ơ数�?�Q��ƈ且更新�v始点和目标点。最后取出所有移动次数最大的一个。复杂度为o(n^2)。题目n的规模�ؓ200�?/p>

koson 2009-11-13 13:51 发表评论

亚洲黄一区二区三区,亚洲视频一二,欧美日韩在线观看一区二区

���量数据面试题整理（转）

POJ 1523 无向囄���割点

有向囑ּ��q�通分量的三种���法

四道有趣的单链表面试题（单链表反序、找出链表的中间元素、链表排序、判断一个单链表是否有环�Q?(�?

POJ 1094 拓扑排序

poj 1988 �q�查集的应用

二叉树前序、中序、后序三�U�遍历的非递归���法

大数据量�Q��v量数�?处理�Ҏ���ȝ��(转）

POJ 2002

我的pku层次分类

hash���法大全

有层�ơPKU ACM分类

PKU题目分类

POJ 1837

POJ 3007

ZOJ 2050

poj 1157

zoj 1082

ZOJ 1029 moving tables

��量数据面试题整理（转）

POJ 1523 无向囄��割点

有向囑ּ��q�通分量的三种��法

poj 1988　�q�查集的应用

二叉树前序、中序、后序三�U�遍历的非递归��法

大数据量�Q��v量数�?处理�Ҏ��ȝ��(转）

hash��法大全