1. 比较世俗的方面，顶级软件公司笔试，面试会问到。别说你不想去谷歌，百度，微软，如果真的没想过，我希望你能想想自己是否具备进入的实力。如果还是没兴趣想，那就忘了这条，看看下面的原因吧。
2. 如果算法熟练，能显著提高看代码的速度，越是工作久了，越会发现很多时候是在读别人写的代码，然后在其基础上追加功能，或修改bug。所以这是很现实的技能。
3. 算法操练上手快，注意只是快，但不见得容易。因为练习省去了界面等操作，只利用编译器最基本的功能，非常适合初学者，编程环境不十分熟练的人来学习，别小看这一点，这能让你不论在家，在同学的电脑上，甚至在网吧，只要你想操练都是能迅速找到办法写程序实现的。
4. 难学，有区分度，正因为难，属于内功级别的学习，不是工具型的学习，所以她经久不衰，这项技能能让你不论什么时候都能作为一个亮点技能展示，并运用。比如眼下学python的人不少，但如果再出现更进步，高效的语言，而且这是完全有可能的，又需要重新学习，那什么才是被各种纷繁语言覆盖的，能让你拥有后在短时间能适应任何语言层面的转换工作，更为通用的技能呢？无疑，数据结构+算法是其中一个，而且是非常重要的一项技能。而更为重要的是，算法这种技能，最实实在在的在于他的优势持久性，周围的人如果没有经过大量算法编码训练，只是看过书写过简单算法的人是很难短期内超越你的。也就是说，这项技能越高越能保证你的能力、水平在社会上具有唯一性。即：稀缺人才。
5. 很多简单的UI操作，短期培训班出来的照着做也能做出来很炫的效果，要佩服微软的封装工作，把UI设计大大简化了。
6. 对编程语言的基本功能会得到大量强化，比如操作符重载，数组，指针的运用，类的构建，对字符串的操作，以及STL，泛型的理解、运用。这里我想你应该看到了学习算法的过程是如何与计算机应用建立起了联系，因为你肯定在写程序时无数次与这些内容打交道，当然，不深入学习算法，也同样可以获得这些知识，而且.NET,Java,已经封装了非常多的这类基础操作，使得字符串处理变得容易多了。这就要看你的风格，需求了。这里我只是介绍深入学习算法能带来的好处，至于不深入学习有没有坏处，我不做评价。注意"深入"二字的修饰作用，如果没学过基本的数据结构，甚至数组、链表都没搞懂区别的话，那做程序员一定是不行的。迟早会遇到瓶颈，而且很快。
7. 提供了足够的可扩展空间。对计算机科学的深层研究必备武器，比如操作系统，搜索引擎，编译器等等。要分析linux源代码，会发现，操作系统在内存管理，进程，线程管理，文件管理，协议栈中，运用了大量算法实现，如果基本算法都不理解，甚至不知道，很难说分析源代码能有多深入。因为看不懂啊。这时会有种遇到瓶颈的感觉。类似玩劲乐团的人，玩到一定程度，眼睛能跟上，但手速跟不上了。
8. 注意，算法虽然是内功，但不是全部，还有很多知识是非常重要的，值得学习的，跟算法关系不太大的。比如设计模式，面向对象思想。所以算法学习到什么程度，自己酌情处理。毕竟越深入，会发现数学知识可能遇到瓶颈，但我想大多数人，只要不是搞科学研究，是不必深入到写龙格-库塔，FFT等算法的地步的。
9. 总之深入学习算法的目的，对于程序员来说，是为了提高编程效率，提高解决问题的效率，能达到需要算法时，自己实现或找来能用的算法，很容易的嵌入到自己的程序中即可。

一般要做到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*算法，最小耗散优先. 

ACM(Association for Computing Machinery)国际计算机组织

通常说的ACM是指 ACM国际大学生程序设计竞赛
基本可以看作是写各种算法的比赛。

国内常用的ACM练习站：北大的比较有人气。http://acm.pku.edu.cn/JudgeOnline/
http://poj.org/

刚刚注册了下，体验了一下流程。

1 先Register一个账户，需要提交些个人信息，没啥顾虑就写真名吧。

2 到Problems里面查阅题目。可以先按1000的提示练习下。

3 在Submit Problem中写入解题代码，以C++格式提交。比如针对题目1000的，C++代码是

#include <iostream>
using namespace std;

int main(int argc, const char** argv)
{
   int a, b;
   cin >>a >> b;
   cout << a+b <<endl;
   return 0;
}

4 然后界面回显示你提交信息的状态，网站会自动刷新。如果有错，可以查看Compile Error。

   直到显示蓝色的Accepted表示通过。

5 你可以在User 栏中选择自己的ID，查看信息，比如我刚解决一道题目后，会显示。

Rank:	50702	Solved Problems List
Solved:	1	1000
Submissions:	2
School:	×××
Email:	×××@××.com

6 应该解决问题越多，排名越高，积分越多吧。挺有趣的。 据说练习的人都很上瘾，尝试了下发现确实在线的人很多，以后再做做。

另外国际上也有个网站比较适合练习算法， topcoder， 择日介绍下。
http://blog.csdn.net/midgard/article/details/4073319

RMQ（Range Minimum/Maximum Query），即区间最值查询，是指这样一个问题：对于长度为n的数列A，回答若干询问RMQ（A,i,j）(i,j<=n)，返回数列A中下标在i，j之间的最小/大值。这两个问题是在实际应用中经常遇到的问题，下面介绍一下解决这两种问题的比较高效的算法。当然，该问题也可以用线段树（也叫区间树）解决，算法复杂度为：O(N)~O(logN)，这里我们暂不介绍。

2.RMQ算法

对于该问题，最容易想到的解决方案是遍历，复杂度是O(n)。但当数据量非常大且查询很频繁时，该算法无法在有效的时间内查询出正解。

本节介绍了一种比较高效的在线算法（ST算法）解决这个问题。所谓在线算法，是指用户每输入一个查询便马上处理一个查询。该算法一般用较长的时间做预处理，待信息充足以后便可以用较少的时间回答每个查询。ST（Sparse Table）算法是一个非常有名的在线处理RMQ问题的算法，它可以在O(nlogn)时间内进行预处理，然后在O(1)时间内回答每个查询。

（一）首先是预处理，用动态规划（DP）解决。

设A[i]是要求区间最值的数列，F[i, j]表示从第i个数起连续2^j个数中的最大值。（DP的状态）

例如：

A数列为：3 2 4 5 6 8 1 2 9 7

F[1，0]表示第1个数起，长度为2^0=1的最大值，其实就是3这个数。同理 F[1,1] = max(3,2) = 3, F[1，2]=max(3,2,4,5) = 5，F[1，3] = max(3,2,4,5,6,8,1,2) = 8;

并且我们可以容易的看出F[i,0]就等于A[i]。（DP的初始值）

这样，DP的状态、初值都已经有了，剩下的就是状态转移方程。

我们把F[i，j]平均分成两段（因为f[i，j]一定是偶数个数字），从 i 到i + 2 ^ (j - 1) - 1为一段，i + 2 ^ (j - 1)到i + 2 ^ j - 1为一段(长度都为2 ^ (j - 1))。用上例说明，当i=1，j=3时就是3,2,4,5 和 6,8,1,2这两段。F[i，j]就是这两段各自最大值中的最大值。于是我们得到了状态转移方程F[i, j]=max（F[i，j-1], F[i + 2^(j-1)，j-1]）。

代码如下：

void RMQ(int num) //预处理->O(nlogn)
{
	for(int j = 1; j < 20; ++j)
		for(int i = 1; i <= num; ++i)
			if(i + (1 << j) - 1 <= num)
			{
				maxsum[i][j] = max(maxsum[i][j - 1], maxsum[i + (1 << (j - 1))][j - 1]);
				minsum[i][j] = min(minsum[i][j - 1], minsum[i + (1 << (j - 1))][j - 1]);
			}
}

这里我们需要注意的是循环的顺序，我们发现外层是j，内层所i，这是为什么呢？可以是i在外，j在内吗？

答案是不可以。因为我们需要理解这个状态转移方程的意义。

状态转移方程的含义是：先更新所有长度为F[i,0]即1个元素，然后通过2个1个元素的最值，获得所有长度为F[i,1]即2个元素的最值，然后再通过2个2个元素的最值，获得所有长度为F[i,2]即4个元素的最值，以此类推更新所有长度的最值。

而如果是i在外，j在内的话，我们更新的顺序就是F[1,0],F[1,1],F[1,2],F[1,3],表示更新从1开始1个元素，2个元素，4个元素，8个元素（A[0],A[1],....A[7]）的最值，这里F[1,3] = max(max(A[0],A[1],A[2],A[3]),max(A[4],A[5],A[6],A[7]))的值，但是我们根本没有计算max(A[0],A[1],A[2],A[3])和max(A[4],A[5],A[6],A[7])，所以这样的方法肯定是错误的。

为了避免这样的错误，一定要好好理解这个状态转移方程所代表的含义。

（二）然后是查询。

假如我们需要查询的区间为(i,j)，那么我们需要找到覆盖这个闭区间(左边界取i，右边界取j)的最小幂（可以重复，比如查询5，6，7，8，9，我们可以查询5678和6789）。

因为这个区间的长度为j - i + 1,所以我们可以取k=log2( j - i + 1)，则有：RMQ(A, i, j)=max{F[i , k], F[ j - 2 ^ k + 1, k]}。

举例说明，要求区间[2，8]的最大值，k = log2（8 - 2 + 1）= 2，即求max(F[2, 2]，F[8 - 2 ^ 2 + 1, 2]) = max(F[2, 2]，F[5, 2])；

在这里我们也需要注意一个地方，就是<<运算符和+-运算符的优先级。

比如这个表达式：5 - 1 << 2是多少？

答案是：4 * 2 * 2 = 16。所以我们要写成5 - (1 << 2)才是5-1 * 2 * 2 = 1。

http://www.mfn.unipmn.it/~manzini/lightweight

如果不会用,就下载本C++ 多串匹配程序包吧