给ACM newer的编程技巧
一、复杂度
1.1什么是复杂度？
在设计满足问题要求的算法时，复杂度的估算是非常重要的。我们不可能把每个想到的算法实现一遍看看是否足够快。应当通过估计算法的复杂度来判断所想的算法是否足够高效。
1.2 时间复杂度
一、概念
时间复杂度是总运算次数表达式中受n的变化影响最大的那一项(不含系数)
比如：一般总运算次数表达式类似于这样：
a*2n+b*n3+c*n2+d*n*lg(n)+e*n+f
a ！ =0时，时间复杂度就是O(2n);
a=0,b<>0 =>O(n3);
a,b=0,c<>0 =>O(n2)依此类推
例子:
(1) for(i=1;i<=n;i++) //循环了n*n次，当然是O(n2)
for(j=1;j<=n;j++)
s++;
(2) for(i=1;i<=n;i++)//循环了(n+n-1+n-2+...+1)≈(n2)/2，因为时间复杂度是不考虑系数的，所以也是O(n2)
for(j=i;j<=n;j++)
s++;
(3) for(i=1;i<=n;i++)//循环了(1+2+3+...+n)≈(n^2)/2,当然也是O(n2)
for(j=1;j<=i;j++)
s++;
(4) i=1;k=0;//循环了n-1≈n次，所以是O(n)
while(i<=n-1){
k+=10*i;
i++; }
(5) for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
for(k=1;k<=j;k++)
x=x+1;
//
循环了(12+22+32+...+n2)=n(n+1)(2n+1)/6(这个公式要记住哦)≈(n3)/3，不考虑系数，自然是O(n3)
另外，在时间复杂度中，log2n与lg(n)(同lg10(n))是等价的，因为对数换底公式：
logab=logcb/logca
所以，log2n=log210 * lg(n),忽略掉系数，二者当然是等价的
二、计算方法
1.一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。
但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。
并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
2.一般情况下，算法的基本操作重复执行的次数是模块n的某一个函数f（n），
因此，算法的时间复杂度记做：T（n）=O（f（n））。随着模块n的增大，算法执行的时间的增长率和f（n）的增长率成正比，
所以f（n）越小，算法的时间复杂度越低，算法的效率越高。
在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，
再找出T（n）的同数量级（它的同数量级有以下：1，Log2n ，n ，nLog2n ，n的平方，n的三次方，2的n次方，n！），
找出后，f（n）=该数量级，若T(n)/f(n)求极限可得到一常数c，则时间复杂度T（n）=O（f（n））。
3.常见的时间复杂度
按数量级递增排列，常见的时间复杂度有：
常数阶O(1), 对数阶O(log2n), 线性阶O(n), 线性对数阶O(nlog2n), 平方阶O(n2)，
立方阶O(n3),...， k次方阶O(nk), 指数阶O(2n) 。
其中，
1.O(n)，O(n2)， 立方阶O(n3),...， k次方阶O(nk) 为多项式阶时间复杂度，分别称为一阶时间复杂度，二阶时间复杂度。。。。
2.O(2n)，指数阶时间复杂度，该种不实用
3.对数阶O(log2n), 线性对数阶O(nlog2n)，除了常数阶以外，该种效率最高
例：算法：
for（i=1;i<=n;++i）
{
for(j=1;j<=n;++j)
{
c[ i ][ j ]=0; //该步骤属于基本操作 执行次数：n2
for(k=1;k<=n;++k)
c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //该步骤属于基本操作 执行次数：n3
}
}
则有 T（n）= n2+n3，根据上面括号里的同数量级，我们可以确定 n3为T（n）的同数量级
则有f（n）= n3，然后根据T（n）/f（n）求极限可得到常数c
则该算法的 时间复杂度：T（n）=O（n3)
四、定义：
如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)，它是n的某一函数 T(n)称为这一算法的“时间复杂性”。
当输入量n逐渐加大时，时间复杂性的极限情形称为算法的“渐近时间复杂性”。
我们常用大O表示法表示时间复杂性，注意它是某一个算法的时间复杂性。大O表示只是说有上界，由定义如果f(n)=O(n)，那显然成立f(n)=O(n^2)，它给你一个上界，但并不是上确界，但人们在表示的时候一般都习惯表示前者。
此外，一个问题本身也有它的复杂性，如果某个算法的复杂性到达了这个问题复杂性的下界，那就称这样的算法是最佳算法。
“大O记法”：在这种描述中使用的基本参数是 n，即问题实例的规模，把复杂性或运行时间表达为n的函数。这里的“O”表示量级 (order)，比如说“二分检索是 O(logn)的”,也就是说它需要“通过logn量级的步骤去检索一个规模为n的数组”记法 O ( f(n) )表示当 n增大时，运行时间至多将以正比于 f(n)的速度增长。
这种渐进估计对算法的理论分析和大致比较是非常有价值的，但在实践中细节也可能造成差异。
例如，一个低附加代价的O(n2)算法在n较小的情况下可能比一个高附加代价的 O(nlogn)算法运行得更快。
当然，随着n足够大以后，具有较慢上升函数的算法必然工作得更快。
O(1)
Temp=i;i=j;j=temp;
以上三条单个语句的频度均为1，该程序段的执行时间是一个与问题规模n无关的常数。
算法的时间复杂度为常数阶，记作T(n)=O(1)。如果算法的执行时间不随着问题规模n的增加而增长，
即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。
O(n2)
1) 交换i和j的内容
sum=0； （一次）
for(i=1;i<=n;i++) （n次 ）
for(j=1;j<=n;j++) （n2次 ）
sum++； （n^2次 ）
解：T(n)=2n^2+n+1 =O(n^2)
2)
for (i=1;i<n;i++) {
y=y+1; //频度是n-1
for (j=0;j<=(2*n);j++)
x++; //频度是(n-1)*(2n+1)=2n2-n-1
}
f(n)=2n2-n-1+(n-1)=2n2-2 该程序的时间复杂度T(n)=O(n2).
O(n)
3)
a=0; b=1; //频度：2
for (i=1;i<=n;i++) //频度： n
{
s=a+b; //频度： n-1
b=a; //频度：n-1
a=s; //频度：n-1
}
T(n)=2+n+3(n-1)=4n-1=O(n).
O(log2n )
4)
i=1; //频度是1
while (i<=n)
i=i*2; //频度是f(n),
则：2f(n)<=n;f(n)<=log2n 取最大值f(n)= log2n, T(n)=O(log2n )
O(n3)
5)
for(i=0;i<n;i++) {
for(j=0;j<i;j++) {
for(k=0;k<j;k++)
x=x+2;
}
}
解：当i=m, j=k的时候,内层循环的次数为k当i=m时, j 可以取 0,1,...,m-1 , 所以这里最内循环共
进行了0+1+...+m-1=(m-1)m/2次所以,i从0取到n, 则循环共进行了: 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/6
所以时间复杂度为O(n3).
我们还应该区分算法的最坏情况的行为和期望行为。如快速排序的最坏情况运行时间是 O(n2)，
但期望时间是 O(nlogn)。通过每次都仔细 地选择基准值，我们有可能把平方情况 (即O(n2)情况)
的概率减小到几乎等于 0。在实际中，精心实现的快速排序一般都能以 (O(nlogn)时间运行。
下面是一些常用的记法：
访问数组中的元素是常数时间操作，或说O(1)操作。一个算法如 果能在每个步骤去掉一半数据元素，
如二分检索，通常它就取 O(logn)时间。用strcmp比较两个具有n个字符的串需要O(n)时间。
常规的矩阵乘算法是O(n3)，因为算出每个元素都需要将n对 元素相乘并加到一起，所有元素的个数是n2。
指数时间算法通常来源于需要求出所有可能结果。例如，n个元 素的集合共有2n个子集,所以要求出
所有子集的算法将是O(2n)的。指数算法一般说来是太复杂了，除非n的值非常小，因为，在 这个问题
中增加一个元素就导致运行时间加倍。不幸的是，确实有许多问题 (如著名的“巡回售货员问题” )，
到目前为止找到的算法都是指数的。如果我们真的遇到这种情况，通常应该用寻找近似最佳结果的算法替代之。1.3 空间复杂度
空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。
一个算法在计算机存储器上所占用的存储空间，
包括程序代码所占用的空间，输入数据所占用的空间和辅助变量所占用的空间这三个方面。
算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，
它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，
就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异，有的算法只需要占用少量的临时工作单元，
而且不随问题规模的大小而改变，我们称这种算法是“就地"进行的，是节省存储的算法，如这些介绍过的几个算法都是如此；
有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，
例如将在第九章介绍的快速排序和归并排序算法就属于这种情况。
分析一个算法所占用的存储空间要从各方面综合考虑。如对于递归算法来说，一般都比较简短，算法本身所占用的存储空间较少，但运行时需要一个附加堆栈，从而占用较多的临时工作单元；若写成非递归算法，一般可能比较长，算法本身占用的存储空间较多，但运行时将可能需要较少的存储单元。
一个算法的空间复杂度只考虑在运行过程中为局部变量分配的存储空间的大小，它包括为参数表中形参变量分配的存储空间和为在函数体中定义的局部变量分配的存储空间两个部分。若一个算法为递归算法，其空间复杂度为递归所使用的堆栈空间的大小，它等于一次调用所分配的临时存储空间的大小乘以被调用的次数(即为递归调用的次数加1，这个1表不开始进行的一次非递归调用)。算法的空间复杂度一般也以数量级的形式给出。如当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为0(log2n)；当一个算法的空I司复杂度与n成线性比例关系时，可表示为0(n).若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。
对于一个算法，其时间复杂度和空间复杂度往往是相互影响的。当追求一个较好的时间复杂度时，可能会使空间复杂度的性能变差，即可能导致占用较多的存储空间；反之，当=i自求一个较好的空间复杂度时，可能会使时间复杂度的性能变差，即可能导致占用较长的运行时间。另外，算法的所有性能之间都存在着或多或少的相互影响。因此，当设计一个算法(特别是大型算法)时，要综合考虑算法的各项性能，算法的使用频率，算法处理的数据量的大小，算法描述语言的特性，算法运行的机器系统环境等各方面因素，才能够设计出比较好的算法。
空间复杂度是程序运行所以需要的额外消耗存储空间,也用o()来表示
比如插入排序的时间复杂度是o(n2),空间复杂度是o(1)
而一般的递归算法就要有o(n)的空间复杂度了,因为每次递归都要存储返回信息
一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量，算法执行时间的度量不是采用算法执行的绝对时间来计算的，因为一个算法在不同的机器上执行所花的时间不一样，在不同时刻也会由于计算机资源占用情况的不同，使得算法在同一台计算机上执行的时间也不一样，所以对于算法的时间复杂性，采用算法执行过程中其基本操作的执行次数，称为计算量来度量。
算法中基本操作的执行次数一般是与问题规模有关的，对于结点个数为n的数据处理问题，用T(n)表示算法基本操作的执行次数.在评价算法的时间复杂性时，不考虑两算法执行次数之间的细小区别，而只关心算法的本质差别:
为此，引入一个所谓的O() 记号，则T1(n)=2n=O(n),T2(n)=n+1=O(n)。一个函数f(n)是O(g(n))的，则一定存在正常数c和m，使对所有的n>m，都满足f(n)<c*g(n)。常用的算法的时间复杂度和空间复杂度
| 排序法 | 最差时间分析 | 平均时间复杂度 | 稳定度 | 空间复杂度 |
|---|---|---|---|---|
| 冒泡排序 | O(n2) | O(n2) | 稳定 | O(1) |
| 快速排序 | O(n2) | O(n*log2n) | 不稳定 | O(log2n)~O(n) |
| 选择排序 | O(n2) | O(n2) | 稳定 | O(1) |
| 二叉树排序 | O(n2) | O(n*log2n) | 不一顶 | O(n) |
| 插入排序 | O(n2) | O(n2) | 稳定 | O(1) |
| 堆排序 | O(n*log2n) | O(n*log2n) | 不稳定 | O(1) |
| 希尔排序 | O | O | 不稳定 | O(1) |
1.4 关于运行时间
假设时间限制为1秒
| 复杂度 | 程度 |
|---|---|
| 1e6 | 游刃有余 |
| 1e7 | 勉勉强强 |
| 1e8 | 很悬，仅限循环体非常简单的情况 |
二、debug姿势
一般要做到50行以内的程序不用调试、100行以内的二分钟内调试成功.acm主要是考算法的
，主要时间是花在思考算法上，不是花在写程序与debug上。
2.1 几大错误
Compile Error ;
Run Time Error;
Time Limit Exceeded;
Wrong Answer ;
Presentation Error
Accepted
2.2 debug技巧
调试使用代码
/*hdu 1007
首先我们在建立线段树之前应该思考的是线段树的节点维护一个什么值，
在比赛过程中，我想到了维护a[i]的值但是时间复杂度太高，又想到维护a[i]/b[i]但是取下整，
这样的话无法更新∑的值。
在题解中，维护了b[i]的值，因为a[i]最初是0，所以在update过程中当a[i]>=b[i]时,a[i]/b[i]才>=1；
才会对sum有贡献，所以不妨维护b[i]的值，对每次区间更新，将区间中的b[i]减1，当b[i]减到0时，更新sum的值+1,然后b[i]更新回初始的b[i]的值
整个更新过程中需要维护lazy标志、numzero当前子树中0的个数（即sum+1的次数）、minx当前子树中最小的b[i]值、valb当前节点初始的b[i]值
*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int MAXN=10010;
struct
{
int minx,valb,numzero;
int lazy;
}sum[MAXN<<2];
int b[MAXN];
void push_up(int rt)
{
sum[rt].numzero=sum[rt<<1].numzero+sum[rt<<1|1].numzero;
sum[rt].minx=min(sum[rt<<1].minx,sum[rt<<1|1].minx);
}
void push_down(int rt,int l,int r)
{
sum[rt<<1].lazy+=sum[rt].lazy;
sum[rt<<1|1].lazy+=sum[rt].lazy;
sum[rt<<1].minx-=sum[rt<<1].lazy;
sum[rt<<1|1].minx-=sum[rt<<1|1].lazy;
sum[rt].lazy=0;
}
void build(int l,int r,int rt=1)
{
sum[rt].lazy=0;
sum[rt].numzero=0;
if(l==r)
{
sum[rt].lazy=0;
sum[rt].minx=b[l];
sum[rt].numzero=0;
sum[rt].valb=b[l];
}
int m=(l+r)>>1;
build(lson);
build(rson);
push_up(rt);
}
/*update操作
*/
void update(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=r&&sum[rt].minx>1)
{
sum[rt].lazy++;
sum[rt].minx--;
return;
}
if(l==r&&sum[rt].minx==1)
{
sum[rt].numzero++;
sum[rt].lazy++;
sum[rt].minx=sum[rt].valb;
return;
}
if(sum[rt].lazy>0)
push_down(rt,l,r);
int m=(l+r)>>1;
if(L<=m)update(L,R,lson);
if(m<R)update(L,R,rson);
push_up(rt);
}
/*query操作
求和操作，就是求子树中numzero和
*/
int query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
{
return sum[rt].numzero;
}
if(sum[rt].lazy>0)push_down(rt,l,r);
int m=(l+r)>>1;
int ret=0;
if(L<=m)ret+=query(L,R,lson);
if(R>m)ret+=query(L,R,rson);
return ret;
}
int main()
{
int n,m;
while(cin>>n>>m)
{
char ch[10],L,R;
for(int i=1;i<=n;i++)
scanf("%d",b+i);
while(m--)
{
scanf("%s%d%d",ch,L,R);
if(strcmp(ch,"add")==0)
{
update(L,R,1,n,1);
}
else if(strcmp(ch,"query")==0)
{
printf("%d\n",query(L,R,1,n,1));
}
}
}
return 0;
}
