ACM学习计划

时间 2020-06-21

标签 acm 学习计划栏目应用数学繁體版

原文原文链接

ACM学习建议 php

一位高手对个人建议： html

通常要作到50行之内的程序不用调试、100行之内的二分钟内调试成功.acm主要是考算法的 node

，主要时间是花在思考算法上，不是花在写程序与debug上。 ios

下面给个计划你练练：算法

第一阶段：编程

练经典经常使用算法，下面的每一个算法给我打上十到二十遍，同时本身精简代码，数组

由于太经常使用，因此要练到写时不用想，10-15分钟内打完，甚相当掉显示器均可以把程序打服务器

出来. 网络

1.最短路(Floyd、Dijstra,BellmanFord) 数据结构

2.最小生成树(先写个prim,kruscal要用并查集，很差写)

3.大数（高精度）加减乘除

4.二分查找. (代码可在五行之内)

5.叉乘、判线段相交、而后写个凸包.

6.BFS、DFS,同时熟练hash表(要熟，要灵活,代码要简)

7.数学上的有：展转相除（两行内），线段交点、多角形面积公式.

8. 调用系统的qsort, 技巧不少，慢慢掌握.

9. 任意进制间的转换

第二阶段：

练习复杂一点，但也较经常使用的算法。

如：

1. 二分图匹配（匈牙利），最小路径覆盖

2. 网络流，最小费用流。

3. 线段树.

4. 并查集。

5. 熟悉动态规划的各个典型：LCS、最长递增子串、三角剖分、记忆化dp

6.博弈类算法。博弈树，二进制法等。

7.最大团，最大独立集。

8.判断点在多边形内。

9. 差分约束系统.

10. 双向广度搜索、A*算法，最小耗散优先.

第三阶段：

前两个阶段是打基础，第三阶段是锻炼在比赛中能够快速创建模型、想新算法

。这就要平时多作作综合的题型了。

1. 把oibh上的论文看看（大概几百篇的，我只看了一点点，呵呵）。

2. 平时扫扫zoj上的难题啦，别老作那些不用想的题.(中大acm的版主常常说我挑简单的来

作:-P )

3. 多参加网上的比赛，感觉一下比赛的气氛，评估本身的实力.

4. 一道题不要过了就算，问一下人，有更好的算法也打一下。

5. 作过的题要记好 :-)

ACM ICPC学习计划

大牛给的计划——

通常要作到50行之内的程序不用调试、100行之内的二分钟内调试成功.acm主要是考算法的,主要时间是花在思考算法上，不是花在写程序与debug上。

下面给个计划你练练：

第一阶段：练经典经常使用算法，下面的每一个算法给我打上十到二十遍，同时本身精简代码，

由于太经常使用，因此要练到写时不用想，10-15分钟内打完，甚相当掉显示器均可以把程序打

出来.

1.最短路(Floyd、Dijstra,BellmanFord)

2.最小生成树(先写个prim,kruscal要用并查集，很差写)

3.大数（高精度）加减乘除

4.二分查找. (代码可在五行之内)

5.叉乘、判线段相交、而后写个凸包.

6.BFS、DFS,同时熟练hash表(要熟，要灵活,代码要简)

7.数学上的有：展转相除（两行内），线段交点、多角形面积公式.

8. 调用系统的qsort, 技巧不少，慢慢掌握.

9. 任意进制间的转换

第二阶段：练习复杂一点，但也较经常使用的算法。

如：

1. 二分图匹配（匈牙利），最小路径覆盖

2. 网络流，最小费用流。

3. 线段树.

4. 并查集。

5. 熟悉动态规划的各个典型：LCS、最长递增子串、三角剖分、记忆化dp

6.博弈类算法。博弈树，二进制法等。

7.最大团，最大独立集。

8.判断点在多边形内。

9. 差分约束系统.

10. 双向广度搜索、A*算法，最小耗散优先.

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

ACMer必备知识（这么多呀，慢慢学了……

图论

路径问题

0/1边权最短路径

BFS

非负边权最短路径（Dijkstra）

能够用Dijkstra解决问题的特征

负边权最短路径

Bellman-Ford

Bellman-Ford的Yen-氏优化

差分约束系统

Floyd

广义路径问题

传递闭包

极小极大距离 / 极大极小距离

Euler Path / Tour

圈套圈算法

混合图的 Euler Path / Tour

Hamilton Path / Tour

特殊图的Hamilton Path / Tour 构造

生成树问题

最小生成树

第k小生成树

最优比率生成树

0/1分数规划

度限制生成树

连通性问题

强大的DFS算法

无向图连通性

割点

割边

二连通分支

有向图连通性

强连通分支

2-SAT

最小点基

有向无环图

拓扑排序

有向无环图与动态规划的关系

二分图匹配问题

通常图问题与二分图问题的转换思路

最大匹配

有向图的最小路径覆盖

0 / 1矩阵的最小覆盖

完备匹配

最优匹配

稳定婚姻

网络流问题

网络流模型的简单特征和与线性规划的关系

最大流最小割定理

最大流问题

有上下界的最大流问题

循环流

最小费用最大流 / 最大费用最大流

弦图的性质和断定

组合数学

解决组合数学问题时经常使用的思想

逼近

递推 / 动态规划

几率问题

Polya定理

计算几何 / 解析几何

计算几何的核心：叉积 / 面积

解析几何的主力：复数

基本形

点

直线，线段

多边形

凸多边形 / 凸包

凸包算法的引进，卷包裹法

Graham扫描法

水平序的引进，共线凸包的补丁

完美凸包算法

相关断定

两直线相交

两线段相交

点在任意多边形内的断定

点在凸多边形内的断定

经典问题

最小外接圆

近似O(n)的最小外接圆算法

点集直径

旋转卡壳，对踵点

多边形的三角剖分

数学 / 数论

最大公约数

Euclid算法

扩展的Euclid算法

同余方程 / 二元一次不定方程

同余方程组

线性方程组

高斯消元法

解mod 2域上的线性方程组

整系数方程组的精确解法

矩阵

行列式的计算

利用矩阵乘法快速计算递推关系

分数

分数树

连分数逼近

数论计算

求N的约数个数

求phi(N)

求约数和

快速数论变换

……

素数问题

几率判素算法

几率因子分解

数据结构

组织结构

二叉堆

左偏树

二项树

胜者树

跳跃表

样式图标

斜堆

reap

统计结构

树状数组

虚二叉树

线段树

矩形面积并

圆形面积并

关系结构

Hash表

并查集

路径压缩思想的应用

STL中的数据结构

vector

deque

set / map

动态规划 / 记忆化搜索

动态规划和记忆化搜索在思考方式上的区别

最长子序列系列问题

最长不降低子序列

最长公共子序列

最长公共不降低子序列

一类NP问题的动态规划解法

树型动态规划

背包问题

动态规划的优化

四边形不等式

函数的凸凹性

状态设计

规划方向

线性规划

经常使用思想

二分最小表示法

串

KMP Trie结构

后缀树/后缀数组 LCA/RMQ

有限状态自动机理论

排序

选择/冒泡快速排序堆排序归并排序

基数排序拓扑排序排序网络

中级:

一.基本算法:

(1)C++的标准模版库的应用. (poj3096,poj3007)

(2)较为复杂的模拟题的训练(poj3393,poj1472,poj3371,poj1027,poj2706)

二.图算法:

(1)差分约束系统的创建和求解. (poj1201,poj2983)

(2)最小费用最大流(poj2516,poj2516,poj2195)

(3)双连通份量(poj2942)

(4)强连通分支及其缩点.(poj2186)

(5)图的割边和割点(poj3352)

(6)最小割模型、网络流规约(poj3308, )

三.数据结构.

(1)线段树. (poj2528,poj2828,poj2777,poj2886,poj2750)

(2)静态二叉检索树. (poj2482,poj2352)

(3)树状树组(poj1195,poj3321)

(4)RMQ. (poj3264,poj3368)

(5)并查集的高级应用. (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)组合数学:

1.容斥原理.

2.抽屉原理.

3.置换群与Polya定理(poj1286,poj2409,poj3270,poj1026).

4.递推关系和母函数.

(2)数学.

1.高斯消元法(poj2947,poj1487, poj2065,poj1166,poj1222)

2.几率问题. (poj3071,poj3440)

3.GCD、扩展的欧几里德(中国剩余定理) (poj3101)

(3)计算方法.

1.0/1分数规划. (poj2976)

2.三分法求解单峰(单谷)的极值.

3.矩阵法(poj3150,poj3422,poj3070)

4.迭代逼近(poj3301)

(4)随机化算法(poj3318,poj2454)

(5)杂题.

(poj1870,poj3296,poj3286,poj1095)

七.计算几何学.

(1)坐标离散化.

(2)扫描线算法(例如求矩形的面积和周长并,常和线段树或堆一块儿使用).

(poj1765,poj1177,poj1151,poj3277,poj2280,poj3004)

(3)多边形的内核(半平面交)(poj3130,poj3335)

(4)几何工具的综合应用.(poj1819,poj1066,poj2043,poj3227,poj2165,poj3429)

高级:

一.基本算法要求:

(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)无向图、有向图的最小环

三.数据结构.

(1)trie图的创建和应用. (poj2778)

(2)LCA和RMQ问题(LCA(最近公共祖先问题) 有离线算法(并查集+dfs) 和在线算法

(RMQ+dfs)).(poj1330)

(3)双端队列和它的应用(维护一个单调的队列,经常在动态规划中起到优化状态转移的

目的). (poj2823)

(4)左偏树(可合并堆).

(5)后缀树(很是有用的数据结构,也是赛区考题的热点).

(poj3415,poj3294)

四.搜索

(1)较麻烦的搜索题目训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426)

(2)广搜的状态优化:利用M进制数存储状态、转化为串用hash表判重、按位压缩存储状态、双向广搜、A*算法. (poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)

(3)深搜的优化:尽可能用位运算、必定要加剪枝、函数参数尽量少、层数不易过大、能够考虑双向搜索或者是轮换搜索、IDA*算法. (poj3131,poj2870,poj2286)

五.动态规划

(1)须要用数据结构优化的动态规划.

(poj2754,poj3378,poj3017)

(2)四边形不等式理论.

(3)较难的状态DP(poj3133)

六.数学

(1)组合数学.

1.MoBius反演(poj2888,poj2154)

2.偏序关系理论.

(2)博奕论.

1.极大极小过程(poj3317,poj1085)

2.Nim问题.

七.计算几何学.

(1)半平面求交(poj3384,poj2540)

(2)可视图的创建(poj2966)

(3)点集最小圆覆盖.

(4)对踵点(poj2079)

八.综合题.

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

初期:

一.基本算法:

(1)枚举. (poj1753,poj2965) (2)贪心(poj1328,poj2109,poj2586)

(3)递归和分治法. (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)最大流的增广路算法(KM算法). (poj1459,poj3436)

三.数据结构.

(1)串 (poj1035,poj3080,poj1936)

(2)排序(快排、归并排(与逆序数有关)、堆排) (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)广度优先搜索(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)组合数学:

1.加法原理和乘法原理.

2.排列组合.

3.递推关系.

(POJ3252,poj1850,poj1019,poj1942)

(2)数论.

1.素数与整除问题

2.进制位.

3.同余模运算.

(poj2635, poj3292,poj1845,poj2115)

(3)计算方法.

1.二分法求解单调函数相关知识.(poj3273,poj3258,poj1905,poj3122)

七.计算几何学.

(1)几何公式.

(2)叉积和点积的运用(如线段相交的断定,点到线段的距离等). (poj2031,poj1039)

(3)多边型的简单算法(求面积)和相关断定(点在多边型内,多边型是否相交)

(poj1408,poj1584)

(4)凸包. (poj2187,poj1113)

（七）

第一阶段：练经典经常使用算法，下面的每一个算法给我打上十到二十遍，同时本身精简代码，

由于太经常使用，因此要练到写时不用想，10-15分钟内打完，甚相当掉显示器均可以把程序打

出来.

1.最短路(Floyd、Dijstra,BellmanFord)

2.最小生成树(先写个prim,kruscal要用并查集，很差写)

3.大数（高精度）加减乘除

4.二分查找. (代码可在五行之内)

5.叉乘、判线段相交、而后写个凸包.

6.BFS、DFS,同时熟练hash表(要熟，要灵活,代码要简)

7.数学上的有：展转相除（两行内），线段交点、多角形面积公式.

8. 调用系统的qsort, 技巧不少，慢慢掌握.

9. 任意进制间的转换

第二阶段：练习复杂一点，但也较经常使用的算法。

如：

1. 二分图匹配（匈牙利），最小路径覆盖

2. 网络流，最小费用流。

3. 线段树.

4. 并查集。

5. 熟悉动态规划的各个典型：LCS、最长递增子串、三角剖分、记忆化dp

6.博弈类算法。博弈树，二进制法等。

7.最大团，最大独立集。

8.判断点在多边形内。

9. 差分约束系统.

10. 双向广度搜索、A*算法，最小耗散优先.

（八）

搞实际项目的话基本用不着多少。lss说的那点都已经多了。固然，偶我的以为，判断一个问题是否NPC/NPH仍是比较有用的，判是之后就不会把本身的经历浪费在寻找多项式算法上了。这点acm要用，实际项目偶以为也有用。

acm的话上面贴的那一长串还不够用。所谓不够用，第一，指这些就算都会都不会写错，不会创建dp模型不会创建图论模型的话同样能挂得很惨，这种活的东西不是死作题就能会的。第二，这表还不全。既然图能够扯到最优比率生成树，那博弈的话至少也得扯SG定理，串的话至少也得扯AC自动机（吐槽：不是自动AC机），

（九）补充中。。。。

浙江大学 http://acm.zju.edu.cn 北京大学 http://acm.pku.edu.cn/JudgeOnline

天津大学 http://acm.tju.edu.cn 厦门大学 http://acm.xmu.edu.cn/JudgeOnline

福州大学 http://acm.fzu.edu.cn 华中科技 http://acm.hust.edu.cn/JudgeOnline

宁波理工 http://acm.nit.net.cn 合肥工大 http://acm.tdzl.net:83/JudgeOnline

汕头大学 http://acm.stu.edu.cn 北大内部 http://ai.pku.cn/JudgeOnline

中国科大 http://acm.ustc.edu.cn 暨南大学 http://202.116.24.78/JudgeOnline

浙江工业 http://acm.zjut.edu.cn 中山大学 http://202.116.77.69/sicily

福建师范 http://acm.fjnu.edu.cn 哈工业大 http://acm.hit.edu.cn/ojs/ojs.php

杭电科大 http://acm.hziee.edu.cn 四川大学 http://acm.scu.edu.cn/soj

哈工程大 http://acm.hrbeu.edu.cn 武汉大学 http://acm.whu.edu.cn/noah

同济大学 http://acm.tongji.edu.cn 湖南大学 http://acm.hnu.cn:8080/online/?

上海大学 http://pc.shu.edu.cn/openjudge/problemlist.php

兰州大学 http://acm.sundayclub.cn/JudgeOnline/problemlist

OJ上的一些水题(可用来练手和增长自信)

(poj3299,poj2159,poj2739,poj1083,poj2262,poj1503,poj3006,poj2255,poj3094)

初期:

一.基本算法:

(1)枚举. (poj1753,poj2965)

(2)贪心(poj1328,poj2109,poj2586)

(3)递归和分治法.

(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)最大流的增广路算法(KM算法). (poj1459,poj3436)

三.数据结构.

(1)串 (poj1035,poj3080,poj1936)

(2)排序(快排、归并排(与逆序数有关)、堆排) (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)广度优先搜索(poj3278,poj1426,poj3126,poj3087.poj3414)

(3)简单搜索技巧和剪枝(poj2531,poj1416,poj2676,1129)

五.动态规划

(1)背包问题. (poj1837,poj1276)

(2)型以下表的简单DP(可参考lrj的书 page149):

1.E[j]=opt{D[i]+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)组合数学:

1.加法原理和乘法原理.

2.排列组合.

3.递推关系.

(POJ3252,poj1850,poj1019,poj1942)

(2)数论.

1.素数与整除问题

2.进制位.

3.同余模运算.

(poj2635, poj3292,poj1845,poj2115)

(3)计算方法.

1.二分法求解单调函数相关知识.(poj3273,poj3258,poj1905,poj3122)

七.计算几何学.

(1)几何公式.

(2)叉积和点积的运用(如线段相交的断定,点到线段的距离等). (poj2031,poj1039)

(3)多边型的简单算法(求面积)和相关断定(点在多边型内,多边型是否相交)

(poj1408,poj1584)

(4)凸包. (poj2187,poj1113)

中级:

一.基本算法:

(1)C++的标准模版库的应用. (poj3096,poj3007)

(2)较为复杂的模拟题的训练(poj3393,poj1472,poj3371,poj1027,poj2706)

二.图算法:

(1)差分约束系统的创建和求解. (poj1201,poj2983)

(2)最小费用最大流(poj2516,poj2516,poj2195)

(3)双连通份量(poj2942)

(4)强连通分支及其缩点.(poj2186)

(5)图的割边和割点(poj3352)

(6)最小割模型、网络流规约(poj3308, )

三.数据结构.

(1)线段树. (poj2528,poj2828,poj2777,poj2886,poj2750)

(2)静态二叉检索树. (poj2482,poj2352)

(3)树状树组(poj1195,poj3321)

(4)RMQ. (poj3264,poj3368)

(5)并查集的高级应用. (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)组合数学:

1.容斥原理.

2.抽屉原理.

3.置换群与Polya定理(poj1286,poj2409,poj3270,poj1026).

4.递推关系和母函数.

(2)数学.

1.高斯消元法(poj2947,poj1487, poj2065,poj1166,poj1222)

2.几率问题. (poj3071,poj3440)

3.GCD、扩展的欧几里德(中国剩余定理) (poj3101)

(3)计算方法.

1.0/1分数规划. (poj2976)

2.三分法求解单峰(单谷)的极值.

3.矩阵法(poj3150,poj3422,poj3070)

4.迭代逼近(poj3301)

(4)随机化算法(poj3318,poj2454)

(5)杂题.

(poj1870,poj3296,poj3286,poj1095)

七.计算几何学.

(1)坐标离散化.

(2)扫描线算法(例如求矩形的面积和周长并,常和线段树或堆一块儿使用).

(poj1765,poj1177,poj1151,poj3277,poj2280,poj3004)

(3)多边形的内核(半平面交)(poj3130,poj3335)

(4)几何工具的综合应用.(poj1819,poj1066,poj2043,poj3227,poj2165,poj3429)

高级:

一.基本算法要求:

(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)无向图、有向图的最小环

三.数据结构.

(1)trie图的创建和应用. (poj2778)

(2)LCA和RMQ问题(LCA(最近公共祖先问题) 有离线算法(并查集+dfs) 和在线算法

(RMQ+dfs)).(poj1330)

(3)双端队列和它的应用(维护一个单调的队列,经常在动态规划中起到优化状态转移的

目的). (poj2823)

(4)左偏树(可合并堆).

(5)后缀树(很是有用的数据结构,也是赛区考题的热点).

(poj3415,poj3294)

四.搜索

(1)较麻烦的搜索题目训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426)

(2)广搜的状态优化:利用M进制数存储状态、转化为串用hash表判重、按位压缩存储状态、双向广搜、A*算法. (poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)

(3)深搜的优化:尽可能用位运算、必定要加剪枝、函数参数尽量少、层数不易过大、能够考虑双向搜索或者是轮换搜索、IDA*算法. (poj3131,poj2870,poj2286)

五.动态规划

(1)须要用数据结构优化的动态规划.

(poj2754,poj3378,poj3017)

(2)四边形不等式理论.

(3)较难的状态DP(poj3133)

六.数学

(1)组合数学.

1.MoBius反演(poj2888,poj2154)

2.偏序关系理论.

(2)博奕论.

1.极大极小过程(poj3317,poj1085)

2.Nim问题.

七.计算几何学.

(1)半平面求交(poj3384,poj2540)

(2)可视图的创建(poj2966)

(3)点集最小圆覆盖.

(4)对踵点(poj2079)

八.综合题.

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

同时因为我的练习的时候可能有些偏向性,可能上面的总结不是很全,还请你们提出和指正,并且因为ACM的题目中专门针对某个算法的题目可能比较少出现,因此上面的分类中的题有可能有多种解法或者是一些算法的综合,这都不会影响你们作题,但愿练习的同窗可以认真,扎实地训练,作到真正的理解算法,掌握算法.同时在论坛上还有许多前辈的分类,总结,你们也能够按本身的状况采用.注意FTP上有不少的资料,但愿你们好好地利用.

若是同窗能在明年暑假前能掌握上面大部分算法,那你也基本上达到了训练的目的,到暑假的时候你就能够选择本身比较喜欢的方面进行加深和强化,并且同窗们不要以为看算法的证实是很麻烦的事,这能够增强你的思惟能力,这在ACM中也很重要.同时也但愿老队员能帮助我整理习题和题目分类.同时ACM的题目是没有范围的,只能在平时中多积累多练习,多比别人多努力一点,你就会比别人多一线但愿.

我补充些动态规划、搜索方面的资料吧。

Dp状态设计与方程总结

1.不彻底状态记录

<1>青蛙过河问题

<2>利用区间dp

2.背包类问题

<1> 0-1背包，经典问题

<2>无限背包，经典问题

<3>断定性背包问题

<4>带附属关系的背包问题

<5> + -1背包问题

<6>双背包求最优值

<7>构造三角形问题

<8>带上下界限制的背包问题(012背包)

3.线性的动态规划问题

<1>积木游戏问题

<2>决斗（断定性问题）

<3>圆的最大多边形问题

<4>统计单词个数问题

<5>棋盘分割

<6>日程安排问题

<7>最小逼近问题(求出两数之比最接近某数/两数之和等于某数等等)

<8>方块消除游戏(某区间能够连续消去求最大效益)

<9>资源分配问题

<10>数字三角形问题

<11>漂亮的打印

<12>邮局问题与构造答案

<13>最高积木问题

<14>两段连续和最大

<15>2次幂和问题

<16>N个数的最大M段子段和

<17>交叉最大数问题

4.断定性问题的dp(如断定整除、断定可达性等)

<1>模K问题的dp

<2>特殊的模K问题，求最大(最小)模K的数

<3>变换数问题

5.单调性优化的动态规划

<1>1-SUM问题

<2>2-SUM问题

<3>序列划分问题(单调队列优化)

6.剖分问题(多边形剖分/石子合并/圆的剖分/乘积最大)

<1>凸多边形的三角剖分问题

<2>乘积最大问题

<3>多边形游戏(多边形边上是操做符,顶点有权值)

<4>石子合并(N^3/N^2/NLogN各类优化)

7.贪心的动态规划

<1>最优装载问题

<2>部分背包问题

<3>乘船问题

<4>贪心策略

<5>双机调度问题Johnson算法

8.状态dp

<1>牛仔射击问题(博弈类)

<2>哈密顿路径的状态dp

<3>两支点天平平衡问题

<4>一个有向图的最接近二部图

9.树型dp

<1>完美服务器问题(每一个节点有3种状态)

<2>小胖守皇宫问题

<3>网络收费问题

<4>树中漫游问题

<5>树上的博弈

<6>树的最大独立集问题

<7>树的最大平衡值问题

<8>构造树的最小环

先掌握搜索，动态规划，贪心这些思想方法

而后学习各类技巧

ACM基本算法分类

ACM基本算法分类、推荐学习资料和配套pku习题一.动态规划

参考资料：

刘汝佳《算法艺术与信息学竞赛》《算法导论》

推荐题目：

http://acm.pku.edu.cn/JudgeOnline/problem?id=1141

简单

http://acm.pku.edu.cn/JudgeOnline/problem?id=2288

中等，经典TSP问题

http://acm.pku.edu.cn/JudgeOnline/problem?id=2411

中等，状态压缩DP

http://acm.pku.edu.cn/JudgeOnline/problem?id=1112

中等

http://acm.pku.edu.cn/JudgeOnline/problem?id=1848

中等，树形DP。可参考《算法艺术与信息学竞赛》动态规划一节的树状模型

http://acm.zju.edu.cn/show_problem.php?pid=1234

中等，《算法艺术与信息学竞赛》中的习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1947

中等，《算法艺术与信息学竞赛》中的习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1946

中等，《算法艺术与信息学竞赛》中的习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1737

中等，递推

http://acm.pku.edu.cn/JudgeOnline/problem?id=1821

中等，须要减小冗余计算

http://acm.zju.edu.cn/show_problem.php?pid=2561

中等，四边形不等式的简单应用

http://acm.pku.edu.cn/JudgeOnline/problem?id=1038

较难，状态压缩DP，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1390

较难，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=3017

较难，须要配合数据结构优化（个人题目^_^）

http://acm.pku.edu.cn/JudgeOnline/problem?id=1682

较难，写起来比较麻烦

http://acm.pku.edu.cn/JudgeOnline/problem?id=2047

较难

http://acm.pku.edu.cn/JudgeOnline/problem?id=2152

难，树形DP

http://acm.pku.edu.cn/JudgeOnline/problem?id=3028

难，状态压缩DP，题目颇有意思

http://acm.pku.edu.cn/JudgeOnline/problem?id=3124

难

http://acm.pku.edu.cn/JudgeOnline/problem?id=2915

很是难

二.搜索

参考资料：

刘汝佳《算法艺术与信息学竞赛》

推荐题目：

http://acm.pku.edu.cn/JudgeOnline/problem?id=1011

简单，深搜入门题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1324

中等，广搜

http://acm.pku.edu.cn/JudgeOnline/problem?id=2044

中等，广搜

http://acm.pku.edu.cn/JudgeOnline/problem?id=2286

较难，广搜

http://acm.pku.edu.cn/JudgeOnline/problem?id=1945

难，IDA*，迭代加深搜索，须要较好的启发函数

http://acm.pku.edu.cn/JudgeOnline/problem?id=2449

难，可重复K最短路，A*。可参考解题报告:

http://acm.pku.edu.cn/JudgeOnline/showcontest?contest_id=1144

http://acm.pku.edu.cn/JudgeOnline/problem?id=1190

难，深搜剪枝，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1084

难，《算法艺术与信息学竞赛》习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=2989

难，深搜

http://acm.pku.edu.cn/JudgeOnline/problem?id=1167

较难，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1069

很难

三. 经常使用数据结构

参考资料：

刘汝佳《算法艺术与信息学竞赛》

《算法导论》

线段树资料：

http://home.ustc.edu.cn/~zhuhcheng/ACM/segment_tree.pdf

树状数组资料

http://home.ustc.edu.cn/~zhuhcheng/ACM/tree.ppt

关于线段树和树状数组更多相关内容可在网上搜到

后缀数组资料

http://home.ustc.edu.cn/~zhuhcheng/ACM/suffix_array.pdf

http://home.ustc.edu.cn/~zhuhcheng/ACM/linear_suffix.pdf

推荐题目

http://acm.pku.edu.cn/JudgeOnline/problem?id=2482

较难，线段树应用，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1151

简单，线段树应用矩形面积并，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=3225

较难，线段树应用，可参考解题报告

http://acm.pku.edu.cn/JudgeOnline/showcontest?contest_id=1233

http://acm.pku.edu.cn/JudgeOnline/problem?id=2155

难，二维树状数组。

http://acm.pku.edu.cn/JudgeOnline/problem?id=2777

中等，线段树应用。

http://acm.pku.edu.cn/JudgeOnline/problem?id=2274

难，堆的应用，《算法艺术与信息学竞赛》中有解答

http://acm.zju.edu.cn/show_problem.php?pid=2334

中等，左偏树，二项式堆或其余可合并堆的应用。

左偏树参考 http://www.nist.gov/dads/HTML/leftisttree.html

二项式堆参见《算法导论》相关章节

http://acm.pku.edu.cn/JudgeOnline/problem?id=1182

中等，并查集

http://acm.pku.edu.cn/JudgeOnline/problem?id=1816

中等，字典树

http://acm.pku.edu.cn/JudgeOnline/problem?id=2778

较难，多串匹配树

参考： http://home.ustc.edu.cn/~zhuhcheng/ACM/zzy2004.pdf

http://acm.pku.edu.cn/JudgeOnline/problem?id=1743

难，后缀数组

http://acm.pku.edu.cn/JudgeOnline/problem?id=2774

较难，最长公共子串，经典问题，后缀数组

http://acm.pku.edu.cn/JudgeOnline/problem?id=2758

很难，后缀数组

可参考解题报告

http://acm.pku.edu.cn/JudgeOnline/showcontest?contest_id=1178

http://acm.pku.edu.cn/JudgeOnline/problem?id=2448

很难，数据结构综合运用

四.图论基础

参考资料：

刘汝佳《算法艺术与信息学竞赛》《算法导论》《网络算法与复杂性理论》谢政

推荐题目:

http://acm.pku.edu.cn/JudgeOnline/problem?id=2337

简单，欧拉路

http://acm.pku.edu.cn/JudgeOnline/problem?id=3177

中等，无向图割边

http://acm.pku.edu.cn/JudgeOnline/problem?id=2942

较难，无向图双连通分支

http://acm.pku.edu.cn/JudgeOnline/problem?id=1639

中等，最小度限制生成树，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=2728

中等，最小比率生成树，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=3013

简单，最短路问题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1275

中等，差分约束系统，Bellman-Ford求解，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1252

简单，Bellman-Ford

http://acm.pku.edu.cn/JudgeOnline/problem?id=1459

中等，网络流

http://acm.pku.edu.cn/JudgeOnline/problem?id=2391

较难，网络流

http://acm.pku.edu.cn/JudgeOnline/problem?id=1325

中等，二部图最大匹配

http://acm.pku.edu.cn/JudgeOnline/problem?id=2226

较难，二部图最大匹配

http://acm.pku.edu.cn/JudgeOnline/problem?id=2195

中等，二部图最大权匹配

KM算法参考《网络算法与复杂性理论》

http://acm.pku.edu.cn/JudgeOnline/problem?id=2516

较难，二部图最大权匹配

http://acm.pku.edu.cn/JudgeOnline/problem?id=1986

中等，LCA（最近公共祖先）问题

参考Tarjan's LCA algorithm 《算法导论》第21章习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=2723

较难，2-SAT问题

参考：http://home.ustc.edu.cn/~zhuhcheng/ACM/2-SAT.PPT

http://acm.pku.edu.cn/JudgeOnline/problem?id=2749

较难，2-SAT问题

http://acm.pku.edu.cn/JudgeOnline/problem?id=3164

较难，最小树形图

参考《网络算法与复杂性理论》中朱-刘算法

五.数论及组合计数基础

http://acm.pku.edu.cn/JudgeOnline/problem?id=1811

简单，素数断定，大数分解

参考算法导论相关章节

http://acm.pku.edu.cn/JudgeOnline/problem?id=2888

较难，Burnside引理

http://acm.pku.edu.cn/JudgeOnline/problem?id=2891

中等，解模方程组

http://acm.pku.edu.cn/JudgeOnline/problem?id=2154

中等，经典问题，波利亚定理

http://cs.scu.edu.cn/soj/problem.action?id=2703

难，极好的题目，Burnside引理+模线性方程组

http://acm.pku.edu.cn/JudgeOnline/problem?id=2764

较难，须要数学方法，该方法在《具体数学》第七章有讲

http://acm.pku.edu.cn/JudgeOnline/problem?id=1977

简单，矩阵快速乘法

第01篇 ACM/ICPC竞赛之基础篇

1、ACM/ICPC竞赛的特色

ACM/ICPC（国际大学生程序设计竞赛）是以算法设计为主的程序设计竞赛，并不涉及具体的应用技术。

ACM/ICPC竞赛以组队形式参赛，每一个参赛队由三名队员组成，共同使用一台计算机解题。一般每场比赛的试题为6至10题，根据各队的完成题数和罚时进行排名。题目提交经过称为完成，从比赛开始到提交成功所用的时间为题目的基础罚时，另外，一道题目每提交失败一次，将增长20分钟罚时。也就是说，参赛队要尽量用最快的速度、最少的失败次数，解决最多的题目。

2、输入和输出处理

试题通常采用标准输入和输出方式读取输入和产生输出，在题目中会详细描述输入和输出的格式和值域范围，所写的程序必定要严格遵照题目指定的输入输出格式。

在比赛试题的输入和输出处理上，针对一些常见的情形，有一些经常使用的方法。

一、多测试用例的输入和输出

有些试题在一次输入中只包含一个测试用例，也就是说，程序每运行一次，只算一道题。也有些试题在一次输入中包含多个测试用例，也就是说，程序每运行一次，要计算多道题。

对多用例输入，一般会先输入要计算的用例的个数，而后依次输入每一个测试用例的输入数据，但程序并不须要等到全部的测试用例都计算完后再输出全部测试用例的计算结果，而是能够读入一个测试用例，输出一个结果，再读入一个测试用例，再输出一个结果。所以对多用例输入的试题，能够用这样的输入模式：

以C++为例：

int n;

cin >> n;

for (int i=0; i<n; i++)

{

读入测试用例数据

计算

输出计算结果

}

二、单测试用例输入的结束判断

对单用例输入，最主要的问题是如何知道输入何时结束。

有些试题会指定某种特殊的输入值做为输入的结束标志，这种状况比较容易处理，只须在读入后，判断一下读入的内容是否为约定结束值便可。

有些试题并不指定特殊的输入值，而是以EOF（文件结束标志）做为结束标志。若是从文件流读入，当读到文件尾时，输入返回EOF。若是从键盘读入时，在Windows的终端中，是以Ctrl+Z表示EOF。对于这种状况，能够用这样的输入模式：

以C++为例：

int m, n; // 假设要连续输入一组整数对

while (cin>>m>>n)

{

处理整数对(m, n)

}

以C语言为例：

int m, n;

while (scanf("%d%d", &m, &n)==2)

{

处理整数对(m, n)

}

3、数据结构的设计

不少试题中已经给出了数据量的上限，所以能够很方便地以数组的方式定义数据结构。但也要注意到有些题目中没有明确指出数据上限时，切不可盲目定义数组大小。

例如在题1070（多项式求和）中，并未说明输入多项式的项数，对这种状况就不宜用数组方式来表示多项式了——除非你的运气足够好，所开辟的数组大小可以经受全部的测试用例的考验。

除了使用通常的数组或链表结构外，对使用C++的选手来讲，STL也是一大利器，充分运用能够有效提升编程的效率和正确性。

4、测试用例的考虑

在试题中一般会给出测试用例的样例，这一般会被咱们用来测试本身的程序，并且不少选手每每在正确计算出测试用例样例时，会认为本身的程序是正确的。

其实测试用例的样例只是测试用例的个例，实际用于测试的测试用例每每会涵盖各类极限状况和边界状况，并且有时测试用例的数量还会比较大，甚至会重复测试同一个测试用例。所以咱们的程序可以经过样例测试，未必可以经过全部的测试用例的测试，一方面要全面考虑全部可能的极限状况和边界状况，一方面程序要有足够的效率。

2008-7-17 01:29 回复

狂晕的迷战士

14位粉丝

2楼

第03篇 ACM/ICPC竞赛之STL--pair

STL的<utility>头文件中描述了一个看上去很是简单的模板类pair，用来表示一个二元组或元素对，并提供了按照字典序对元素对进行大小比较的比较运算符模板函数。

例如，想要定义一个对象表示一个平面坐标点，则能够：

pair<double, double> p1;

cin >> p1.first >> p1.second;

pair模板类须要两个参数：首元素的数据类型和尾元素的数据类型。pair模板类对象有两个成员：first和second，分别表示首元素和尾元素。

在<utility>中已经定义了pair上的六个比较运算符：<、>、<=、>=、==、!=，其规则是先比较first，first相等时再比较second，这符合大多数应用的逻辑。

固然，也能够经过重载这几个运算符来从新指定本身的比较逻辑。

除了直接定义一个pair对象外，若是须要即时生成一个pair对象，也能够调用在<utility>中定义的一个模板函数：make_pair。make_pair须要两个参数，

分别为元素对的首元素和尾元素。

在题1067--Ugly Numbers中，就能够用pair来表示推演树上的结点，用first表示结点的值，用second表示结点是由父结点乘以哪个因子获得的。

#include <iostream>

#include <queue>

using namespace std;

typedef pair<unsigned long, int> node_type;

main()

{ unsigned long result[1500];

priority_queue< node_type, vector<node_type>, greater<node_type> > Q;

Q.push( make_pair(1, 2) );

for (int i=0; i<1500; i++)

{

node_type node = Q.top();

Q.pop();

switch(node.second)

{ case 2: Q.push( make_pair(node.first*2, 2) );

case 3: Q.push( make_pair(node.first*3, 3) );

case 5: Q.push( make_pair(node.first*5, 5) );

}

result[i] = node.first;

}

int n; cin >> n;

while (n>0)

{

cout << result[n-1] << endl;

cin >> n;

}

return 1;

}

<utility>看上去是很简单的一个头文件，可是<utility>的设计中却浓缩反映了STL设计的基本思想。有意深刻了解和研究STL的同窗，仔细阅读和体会这个简单的头文件，

不失为一种入门的途径。

2008-7-17 01:31 回复

狂晕的迷战士

14位粉丝

3楼

第04篇 ACM/ICPC竞赛之STL--vector

在STL的<vector>头文件中定义了vector（向量容器模板类），vector容器以连续数组的方式存储元素序列，能够将vector看做是以顺序结构实现的线性表。

当咱们在程序中须要使用动态数组时，vector将会是理想的选择，vector能够在使用过程当中动态地增加存储空间。

vector模板类须要两个模板参数，第一个参数是存储元素的数据类型，第二个参数是存储分配器的类型，其中第二个参数是可选的，若是不给出第二个参数，

将使用默认的分配器。

下面给出几个经常使用的定义vector向量对象的方法示例：

vector<int> s;

定义一个空的vector对象，存储的是int类型的元素。

vector<int> s(n);

定义一个含有n个int元素的vector对象。

vector<int> s(first, last);

定义一个vector对象，并从由迭代器first和last定义的序列[first, last)中复制初值。

vector的基本操做有：

s[i]

直接如下标方式访问容器中的元素。

s.front()

返回首元素。

s.back()

返回尾元素。

s.push_back(x)

向表尾插入元素x。

s.size()

返回表长。

s.empty()

当表空时，返回真，不然返回假。

s.pop_back()

删除表尾元素。

s.begin()

返回指向首元素的随机存取迭代器。

s.end()

返回指向尾元素的下一个位置的随机存取迭代器。

s.insert(it, x)

向迭代器it指向的元素前插入新元素val。

s.insert(it, n, x)

向迭代器it指向的元素前插入n个x。

s.insert(it, first, last)

将由迭代器first和last所指定的序列[first, last)插入到迭代器it指向的元素前面。

s.erase(it)

删除由迭代器it所指向的元素。

s.erase(first, last)

删除由迭代器first和last所指定的序列[first, last)。

s.reserve(n)

预分配缓冲空间，使存储空间至少可容纳n个元素。

s.resize(n)

改变序列的长度，超出的元素将会被删除，若是序列须要扩展（原空间小于n），元素默认值将填满扩展出的空间。

s.resize(n, val)

改变序列的长度，超出的元素将会被删除，若是序列须要扩展（原空间小于n），将用val填满扩展出的空间。

s.clear()

删除容器中的全部的元素。

s.swap(v)

将s与另外一个vector对象v进行交换。

s.assign(first, last)

将序列替换成由迭代器first和last所指定的序列[first, last)。[first, last)不能是原序列中的一部分。

要注意的是，resize操做和clear操做都是对表的有效元素进行的操做，但并不必定会改变缓冲空间的大小。

另外，vector还有其余一些操做如反转、取反等，再也不一下列举。

vector上还定义了序列之间的比较操做运算符(>, <, >=, <=, ==, !=)，能够按照字典序比较两个序列。

仍是来看一些示例代码。输入个数不定的一组整数，再将这组整数按倒序输出，以下所示：

#include <iostream>

#include <vector>

using namespace std;

main()

{

vector<int> L;

int x;

while (cin>>x) L.push_back(x);

for (int i=L.size()-1; i>=0; i--) cout << L[i] << " ";

cout << endl;

return 1;

}

2008-7-17 01:31 回复

狂晕的迷战士

14位粉丝

4楼

第04篇 ACM/ICPC竞赛之STL--vector

在STL的<vector>头文件中定义了vector（向量容器模板类），vector容器以连续数组的方式存储元素序列，能够将vector看做是以顺序结构实现的线性表。

当咱们在程序中须要使用动态数组时，vector将会是理想的选择，vector能够在使用过程当中动态地增加存储空间。

将使用默认的分配器。

下面给出几个经常使用的定义vector向量对象的方法示例：

vector<int> s;

定义一个空的vector对象，存储的是int类型的元素。

vector<int> s(n);

定义一个含有n个int元素的vector对象。

vector<int> s(first, last);

定义一个vector对象，并从由迭代器first和last定义的序列[first, last)中复制初值。

vector的基本操做有：

s[i]

直接如下标方式访问容器中的元素。

s.front()

返回首元素。

s.back()

返回尾元素。

s.push_back(x)

向表尾插入元素x。

s.size()

返回表长。

s.empty()

当表空时，返回真，不然返回假。

s.pop_back()

删除表尾元素。

s.begin()

返回指向首元素的随机存取迭代器。

s.end()

返回指向尾元素的下一个位置的随机存取迭代器。

s.insert(it, x)

向迭代器it指向的元素前插入新元素val。

s.insert(it, n, x)

向迭代器it指向的元素前插入n个x。

s.insert(it, first, last)

将由迭代器first和last所指定的序列[first, last)插入到迭代器it指向的元素前面。

s.erase(it)

删除由迭代器it所指向的元素。

s.erase(first, last)

删除由迭代器first和last所指定的序列[first, last)。

s.reserve(n)

预分配缓冲空间，使存储空间至少可容纳n个元素。

s.resize(n)

改变序列的长度，超出的元素将会被删除，若是序列须要扩展（原空间小于n），元素默认值将填满扩展出的空间。

s.resize(n, val)

改变序列的长度，超出的元素将会被删除，若是序列须要扩展（原空间小于n），将用val填满扩展出的空间。

s.clear()

删除容器中的全部的元素。

s.swap(v)

将s与另外一个vector对象v进行交换。

s.assign(first, last)

将序列替换成由迭代器first和last所指定的序列[first, last)。[first, last)不能是原序列中的一部分。

要注意的是，resize操做和clear操做都是对表的有效元素进行的操做，但并不必定会改变缓冲空间的大小。

另外，vector还有其余一些操做如反转、取反等，再也不一下列举。

vector上还定义了序列之间的比较操做运算符(>, <, >=, <=, ==, !=)，能够按照字典序比较两个序列。

仍是来看一些示例代码。输入个数不定的一组整数，再将这组整数按倒序输出，以下所示：

#include <iostream>

#include <vector>

using namespace std;

main()

{

vector<int> L;

int x;

while (cin>>x) L.push_back(x);

for (int i=L.size()-1; i>=0; i--) cout << L[i] << " ";

cout << endl;

return 1;

}

2008-7-17 01:32 回复

狂晕的迷战士

14位粉丝

5楼

第05篇 ACM/ICPC竞赛之STL--iterator简介

iterator(迭代器)是用于访问容器中元素的指示器，从这个意义上说，iterator(迭代器)至关于数据结构中所说的"遍历指针"，也能够把iterator(迭代器)看做是一种泛化的指针。

STL中关于iterator(迭代器)的实现是至关复杂的，这里咱们暂时不去详细讨论关于iterator(迭代器)的实现和使用，而只对iterator(迭代器)作一点简单的介绍。

简单地说，STL中有如下几类iterator(迭代器)：

输入iterator(迭代器)，在容器的连续区间内向前移动，能够读取容器内任意值；

输出iterator(迭代器)，把值写进它所指向的容器中；

前向iterator(迭代器)，读取队列中的值，并能够向前移动到下一位置(++p,p++)；

双向iterator(迭代器)，读取队列中的值，并能够向前向后遍历容器；

随机访问iterator(迭代器), 能够直接如下标方式对容器进行访问，vector的iterator(迭代器)就是这种iterator(迭代器)；

流iterator(迭代器)，能够直接输出、输入流中的值；

每种STL容器都有本身的iterator(迭代器)子类，下面先来看一段简单的示例代码：

#include <iostream>

#include <vector>

using namespace std;

main()

{

vector<int> s;

for (int i=0; i<10; i++) s.push_back(i);

for (vector<int>::iterator it=s.begin(); it!=s.end(); it++)

cout << *it << " ";

cout << endl;

return 1;

}

vector的begin()和end()方法都会返回一个vector::iterator对象，分别指向vector的首元素位置和尾元素的下一个位置（咱们能够称之为结束标志位置）。

对一个iterator(迭代器)对象的使用与一个指针变量的使用极为类似，或者能够这样说，指针就是一个很是标准的iterator(迭代器)。

再来看一段稍微特别一点的代码：

#include <iostream>

#include <vector>

using namespace std;

main()

{

vector<int> s;

s.push_back(1);

s.push_back(2);

s.push_back(3);

copy(s.begin(), s.end(), ostream_iterator<int>(cout, " "));

cout <<endl;

return 1;

}

这段代码中的copy就是STL中定义的一个模板函数，copy(s.begin(), s.end(), ostream_iterator<int>(cout, " "));的意思是将由s.begin()至s.end()(不含s.end())所指定的序列复制到标准输出流cout中，用" "做为每一个元素的间隔。也就是说，这句话的做用其实就是将表中的全部内容依次输出。

iterator(迭代器)是STL容器和算法之间的"胶合剂"，几乎全部的STL算法都是经过容器的iterator(迭代器)来访问容器内容的。只有经过有效地运用iterator(迭代器)，才可以有效地运用STL强大的算法功能。

2008-7-17 01:32 回复

狂晕的迷战士

14位粉丝

6楼

第05篇 ACM/ICPC竞赛之STL--iterator简介

STL中关于iterator(迭代器)的实现是至关复杂的，这里咱们暂时不去详细讨论关于iterator(迭代器)的实现和使用，而只对iterator(迭代器)作一点简单的介绍。

简单地说，STL中有如下几类iterator(迭代器)：

输入iterator(迭代器)，在容器的连续区间内向前移动，能够读取容器内任意值；

输出iterator(迭代器)，把值写进它所指向的容器中；

前向iterator(迭代器)，读取队列中的值，并能够向前移动到下一位置(++p,p++)；

双向iterator(迭代器)，读取队列中的值，并能够向前向后遍历容器；

随机访问iterator(迭代器), 能够直接如下标方式对容器进行访问，vector的iterator(迭代器)就是这种iterator(迭代器)；

流iterator(迭代器)，能够直接输出、输入流中的值；

每种STL容器都有本身的iterator(迭代器)子类，下面先来看一段简单的示例代码：

#include <iostream>

#include <vector>

using namespace std;

main()

{

vector<int> s;

for (int i=0; i<10; i++) s.push_back(i);

for (vector<int>::iterator it=s.begin(); it!=s.end(); it++)

cout << *it << " ";

cout << endl;

return 1;

}

vector的begin()和end()方法都会返回一个vector::iterator对象，分别指向vector的首元素位置和尾元素的下一个位置（咱们能够称之为结束标志位置）。

对一个iterator(迭代器)对象的使用与一个指针变量的使用极为类似，或者能够这样说，指针就是一个很是标准的iterator(迭代器)。

再来看一段稍微特别一点的代码：

#include <iostream>

#include <vector>

using namespace std;

main()

{

vector<int> s;

s.push_back(1);

s.push_back(2);

s.push_back(3);

copy(s.begin(), s.end(), ostream_iterator<int>(cout, " "));

cout <<endl;

return 1;

}

2008-7-17 01:33 回复

狂晕的迷战士

14位粉丝

7楼

第06篇 ACM/ICPC竞赛之STL--string

字符串是程序中常常要表达和处理的数据，咱们一般是采用字符数组或字符指针来表示字符串。STL为咱们提供了另外一种使用起来更为便捷的字符串的表达方式：string。string类的定义在头文件<string>中。

string类其实能够看做是一个字符的vector，vector上的各类操做均可以适用于string，另外，string类对象还支持字符串的拼合、转换等操做。

下面先来看一个简单的例子：

#include <iostream>

#include <string>

using namespace std;

main()

{

string s = "Hello! ", name;

cin >> name;

s += name;

s += '!';

cout << s << endl;

return 1;

}

再以题1064--Parencoding为例，看一段用string做为容器，实现由P代码还原括号字符串的示例代码片断：

int m;

cin >> m; // P编码的长度

string str; // 用来存放还原出来的括号字符串

int leftpa = 0; // 记录已出现的左括号的总数

for (int j=0; j<m; j++)

{

int p;

cin >> p;

for (int k=0; k<p-leftpa; k++) str += '(';

str += ')';

leftpa = p;

}

2008-7-17 01:33 回复

狂晕的迷战士

14位粉丝

9楼

看下面这个简单的示例：

#include <iostream>

#include <queue>

using namespace std;

class T

{

public:

int x, y, z;

T(int a, int b, int c):x(a), y(b), z?

{

}

};

bool operator < (const T &t1, const T &t2)

{

return t1.z < t2.z; // 按照z的顺序来决定t1和t2的顺序

}

main()

{

priority_queue<T> q;

q.push(T(4,4,3));

q.push(T(2,2,5));

q.push(T(1,5,4));

q.push(T(3,3,6));

while (!q.empty())

{

T t = q.top(); q.pop();

cout << t.x << " " << t.y << " " << t.z << endl;

}

return 1;

}

输出结果为(注意是按照z的顺序从大到小出队的)：

3 3 6

2 2 5

1 5 4

4 4 3

再看一个按照z的顺序从小到大出队的例子：

#include <iostream>

#include <queue>

using namespace std;

class T

{

public:

int x, y, z;

T(int a, int b, int c):x(a), y(b), z?

{

}

};

bool operator > (const T &t1, const T &t2)

{

return t1.z > t2.z;

}

main()

{

priority_queue<T, vector<T>, greater<T> > q;

q.push(T(4,4,3));

q.push(T(2,2,5));

q.push(T(1,5,4));

q.push(T(3,3,6));

while (!q.empty())

{

T t = q.top(); q.pop();

cout << t.x << " " << t.y << " " << t.z << endl;

}

return 1;

}

输出结果为：

4 4 3

1 5 4

2 2 5

3 3 6

若是咱们把第一个例子中的比较运算符重载为：

bool operator < (const T &t1, const T &t2)

{

return t1.z > t2.z; // 按照z的顺序来决定t1和t2的顺序

}

则第一个例子的程序会获得和第二个例子的程序相同的输出结果。

再回顾一下用优先队列实现的题1067--Ugly Numbers的代码：

#include <iostream>

#include <queue>

using namespace std;

typedef pair<unsigned long int, int> node_type;

main( int argc, char *argv[] )

{

unsigned long int result[1500];

priority_queue< node_type, vector<node_type>, greater<node_type> > Q;

Q.push( make_pair(1, 3) );

for (int i=0; i<1500; i++)

{

node_type node = Q.top();

Q.pop();

switch(node.second)

{

case 3: Q.push( make_pair(node.first*2, 3) );

case 2: Q.push( make_pair(node.first*3, 2) );

case 1: Q.push( make_pair(node.first*5, 1) );

}

result[i] = node.first;

}

int n;

cin >> n;

while (n>0)

{

cout << result[n-1] << endl;

cin >> n;

}

return 1;

}

2008-7-17 01:34 回复

狂晕的迷战士

14位粉丝

10楼

第09篇 ACM/ICPC竞赛之STL--algorithm

<algorithm>无疑是STL中最大的一个头文件，它是由一大堆模板函数组成的。

下面列举出<algorithm>中的模板函数：

adjacent_find / binary_search / copy / copy_backward / count / count_if / equal / equal_range / fill / fill_n / find / find_end / find_first_of / find_if / for_each / generate / generate_n / includes / inplace_merge / iter_swap / lexicographical_compare / lower_bound / make_heap / max / max_element / merge / min / min_element / mismatch / next_permutation / nth_element / partial_sort / partial_sort_copy / partition / pop_heap / prev_permutation / push_heap / random_shuffle / remove / remove_copy / remove_copy_if / remove_if / replace / replace_copy / replace_copy_if / replace_if / reverse / reverse_copy / rotate / rotate_copy / search / search_n / set_difference / set_intersection / set_symmetric_difference / set_union / sort / sort_heap / stable_partition / stable_sort / swap / swap_ranges / transform / unique / unique_copy / upper_bound

若是详细叙述每个模板函数的使用，足够写一本书的了。仍是来看几个简单的示例程序吧。

示例程序之一，for_each遍历容器：

#include <iostream>

#include <vector>

#include <algorithm>

using namespace std;

int Visit(int v) // 遍历算子函数

{

cout << v << " ";

return 1;

}

class MultInt // 定义遍历算子类

{

private:

int factor;

public:

MultInt(int f) : factor(f)

{

}

void operator()(int &elem) const

{

elem *= factor;

}

};

main()

{

vector<int> L;

for (int i=0; i<10; i++) L.push_back(i);

for_each(L.begin(), L.end(), Visit);

cout << endl;

for_each(L.begin(), L.end(), MultInt(2));

for_each(L.begin(), L.end(), Visit);

cout << endl;

return 1;

}

程序的输出结果为：

0 1 2 3 4 5 6 7 8 9

0 2 4 6 8 10 12 14 16 18

示例程序之二，min_element/max_element，找出容器中的最小/最大值：

#include <iostream>

#include <vector>

#include <algorithm>

using namespace std;

main()

{

vector<int> L;

for (int i=0; i<10; i++) L.push_back(i);

vector<int>::iterator min_it = min_element(L.begin(), L.end());

vector<int>::iterator max_it = max_element(L.begin(), L.end());

cout << "Min is " << *min_it << endl;

cout << "Max is " << *max_it << endl;

return 1;

}

程序的输出结果为：

Min is 0

Max is 9

示例程序之三，sort对容器进行排序：

#include <iostream>

#include <vector>

#include <algorithm>

using namespace std;

void Print(vector<int> &L)

{

for (vector<int>::iterator it=L.begin(); it!=L.end(); it++)

cout << *it << " ";

cout << endl;

}

main()

{

vector<int> L;

for (int i=0; i<5; i++) L.push_back(i);

for (int i=9; i>=5; i--) L.push_back(i);

Print(L);

sort(L.begin(), L.end());

Print(L);

sort(L.begin(), L.end(), greater<int>()); // 按降序排序

Print(L);

return 1;

}

程序的输出结果为：

0 1 2 3 4 9 8 7 6 5

0 1 2 3 4 5 6 7 8 9

9 8 7 6 5 4 3 2 1 0

示例程序之四，copy在容器间复制元素：

#include <vector>

#include <algorithm>

#include <iostream>

using namespace std;

main( )

{

// 先初始化两个向量v1和v2

vector <int> v1, v2;

for (int i=0; i<=5; i++) v1.push_back(10*i);

for (int i=0; i<=10; i++) v2.push_back(3*i);

cout << "v1 = ( " ;

for (vector <int>::iterator it=v1.begin(); it!=v1.end(); it++)

cout << *it << " ";

cout << ")" << endl;

cout << "v2 = ( " ;

for (vector <int>::iterator it=v2.begin(); it!=v2.end(); it++)

cout << *it << " ";

cout << ")" << endl;

// 将v1的前三个元素复制到v2的中间

copy(v1.begin(), v1.begin()+3, v2.begin()+4);

cout << "v2 with v1 insert = ( " ;

for (vector <int>::iterator it=v2.begin(); it!=v2.end(); it++)

cout << *it << " ";

cout << ")" << endl;

// 在v2内部进行复制，注意参数2表示结束位置，结束位置不参与复制

copy(v2.begin()+4, v2.begin()+7, v2.begin()+2);

cout << "v2 with shifted insert = ( " ;

for (vector <int>::iterator it=v2.begin(); it!=v2.end(); it++)

cout << *it << " ";

cout << ")" << endl;

return 1;

}

程序的输出结果为：

v1 = ( 0 10 20 30 40 50 )

v2 = ( 0 3 6 9 12 15 18 21 24 27 30 )

v2 with v1 insert = ( 0 3 6 9 0 10 20 21 24 27 30 )

v2 with shifted insert = ( 0 3 0 10 20 10 20 21 24 27 30 )

2008-7-17 01:37 回复

狂晕的迷战士

14位粉丝

11楼

第10篇 ACM/ICPC竞赛之算法策略

ACM/ICPC竞赛其实就是算法设计和编码的竞赛，熟悉各类经常使用算法和算法设计策略并能灵活运用是很是必要的。

这里对几种在竞赛中常常用到的算法设计策略作一简单的介绍。

一、穷举法

穷举法是最基本的算法设计策略，其思想是列举出问题全部的可能解，逐一进行判别，找出知足条件的解。

穷举法的运用关键在于解决两个问题：

如何列举全部的可能解；

如何判别可能解是否知足条件；

在运用穷举法时，容易出现的问题是可能解过多，致使算法效率很低，这就须要对列举可能解的方法进行优化。

以题1041--纯素数问题为例，从1000到9999均可以看做是可能解，能够经过对全部这些可能解逐一进行判别，找出其中的纯素数，但只要稍做分析，就会发现其实能够大幅度地下降可能解的范围。根据题意易知，个位只多是三、五、7，再根据题意可知，能够在三、五、7的基础上，先找出全部的二位纯素数，再在二位纯素数基础上找出三位纯素数，最后在三位纯素数的基础上找出全部的四位纯素数。

二、分治法

分治法也是应用很是普遍的一种算法设计策略，其思想是将问题分解为若干子问题，从而能够递归地求解各子问题，再综合出问题的解。

分治法的运用关键在于解决三个问题：

肯定分治规则，即如何分解问题。

肯定终结条件，即问题分解到什么状态时能够直接求解。

肯定概括方法，即如何由子问题的解获得原问题的解。这一步并不老是须要的，由于对某些问题来讲，并不须要对子问题的解进行复杂的概括。

咱们熟知的如汉诺塔问题、折半查找算法、快速排序算法等都是分治法运用的典型案例。

以题1045--Square Coins为例，先对题意进行分析，可设一个函数f(m, n)等于用面值不超过n2的货币构成总值为m的方案数，则容易推导出：

f(m, n) = f(m-0*n*n, n-1)+f(m-1*n*n, n-1)+f(m-2*n*n, n-1)+...+f(m-k*n*n, n-1)

这里的k是币值为n2的货币最多能够用多少枚，即k=m/(n*n)。

也很容易分析出，f(m, 1) = f(1, n) = 1

对于这样的题目，一旦分析出了递推公式，程序就很是好写了。因此在动手开始写程序以前，分析工做作得越完全，逻辑描述越准确、简洁，写起程序来就会越容易。

三、动态规划法

动态规划法多用来计算最优问题，动态规划法与分治法的基本思想是一致的，但处理的手法不一样。动态规划法在运用时，要先对问题的分治规律进行分析，找出终结子问题，以及子问题向父问题概括的规则，而算法则直接从终结子问题开始求解，逐层向上概括，直到概括出原问题的解。

动态规划法多用于在分治过程当中，子问题可能重复出现的状况，在这种状况下，若是按照常规的分治法，自上向下分治求解，则重复出现的子问题就会被重复地求解，从而增大了冗余计算量，下降了求解效率。而采用动态规划法，自底向上求解，每一个子问题只计算一次，就能够避免这种重复的求解了。

动态规划法还有另一种实现形式，即备忘录法。备忘录的基本思想是设立一个称为备忘录的容器，记录已经求得解的子问题及其解。仍然采用与分治法相同的自上向下分治求解的策略，只是对每个分解出的子问题，先在备忘录中查找该子问题，若是备忘录中已经存在该子问题，则不须再求解，能够从备忘录中直接获得解，不然，对子问题递归求解，且每求得一个子问题的解，都将子问题及解存入备忘录中。

例如，在题1045--Square Coins中，能够采用分治法求解，也能够采用动态规划法求解，即从f(m, 1)和f(1, n)出发，逐层向上计算，直到求得f(m, n)。

在竞赛中，动态规划和备忘录的思想还能够有另外一种用法。有些题目中的可能问题数是有限的，而在一次运行中可能须要计算多个测试用例，能够采用备忘录的方法，预先将全部的问题的解记录下来，而后输入一个测试用例，就查备忘录，直接找到答案输出。这在各问题之间存在父子关系的状况下，会更有效。例如，在题1045--Square Coins中，题目中已经指出了最大的目标币值不超过300，也就是说问题数只有300个，并且各问题的计算中存在重叠的子问题，能够采用动态规划法，将全部问题的解先所有计算出来，再依次输入测试用例数据，并直接输出答案。

四、回溯法

回溯法是基于问题状态树搜索的求解法，其可适用范围很广。从某种角度上说，能够把回溯法看做是优化了的穷举法。回溯法的基本思想是逐步构造问题的可能解，一边构造，一边用约束条件进行判别，一旦发现已经不可能构造出知足条件的解了，则退回上一步构造过程，从新进行构造。这个退回的过程，就称之为"回溯"。

回溯法在运用时，要解决的关键问题在于：

如何描述局部解。

如何扩展局部解和回溯局部解。

如何判别局部解。

回溯法的经典案例也不少，例如全排列问题、N后问题等。

五、贪心法

贪心法也是求解最优问题的经常使用算法策略，利用贪心法策略所设计的算法，一般效率较高，算法简单。贪心法的基本思想是对问题作出目前看来最好的选择，即贪心选择，并使问题转化为规模更小的子问题。如此迭代，直到子问题能够直接求解。

基于贪心法的经典算法例如：哈夫曼算法、最小生成树算法、最短路径算法等。

可是，贪心法的运用是有条件的，必须可以证实贪心选择可以导出最优解，且转化出的子问题与原问题是同性质的问题，才能使用贪心法求解。

一个比较经典的贪心法求解的问题就是找硬币问题：有一、二、五、十、20、50、100七种面值的硬币，要支付指定的金额，问怎么支付所用的硬币个数最少。这是一个很是平常化的问题，凭直觉咱们会想到，尽量先用大面值的硬币，这就是"贪心选择"，而在这个问题上，这个贪心选择也是正确的。

六、限界剪枝法

限界剪枝法是求解较复杂最优问题的一种算法策略，与回溯法相似的是，限界剪枝法也是在问题状态空间树上进行搜索，但回溯法是搜索通常解，而限界剪枝法则是搜索最优解。限界剪枝法的基本思想是经过找出权值函数的上下界函数，如下界函数来指导搜索的方向，以上界函数来帮助剪除一些不可能含有最优解的分枝。

关于算法和算法策略的讨论是一个很是庞大的话题，几乎每一个问题点都能扩展出一大堆可讨论的内容和案例。我实在不知道该怎样用简短的几篇文字就可以把这个话题说透，这里只能走马观花地对竞赛中常常用到的几种策略作一极为简略的介绍。

也许咱们能够在之后的文章中，针对具体的题目进行算法和策略的分析，效果可能会更好。

2008-7-17 01:37 回复

狂晕的迷战士

14位粉丝

12楼

第11篇 ACM/ICPC竞赛之调试

在写程序时，调试程序也是一个重要的环节。怎样才可以更有效地调试程序，发现并修正错误呢？

一、调试中的输入输出

为了调试程序，咱们可能须要反复执行程序，也就须要反复输入相同或不相同的测试数据。若是每次调试运行时都是以手工的方式输入测试数据，相信不少人都会以为不胜其烦。其实咱们能够用一些辅助的手段来简化这个过程。

方法一：使用剪贴板

能够将输入数据预先写好（用记事本、开发环境的编辑器或随便什么可以录入的东西

1. ACM学习计划
2. ACM计划
3. ACM进阶计划
4. ACM训练计划
5. 转载 ACM训练计划
6. 【转】ACM训练计划
7. ACM 进阶计划~~转
8. 学习计划
更多相关文章...
• 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
• 我们已经学习了 SQL，下一步学习什么呢？ - SQL 教程
• Tomcat学习笔记（史上最全tomcat学习笔记）
• 适用于PHP初学者的学习线路和建议