编程优化与常见错误

Runtime error

一般为数组越界，开大一点

或主函数中局部变量数组内存过大，导致栈溢出a[1000][1000],改为全局变量

关于浮点数大整数什么要求原样输出问题

用string puts,gets等转换成字符输入输出！

 一行输出多个数的时候行末不能输出多余空格，平台会判成格式错误 

long long 

看到题目数据较大就直接用long long（2^63）int 最多到十位（有的编译器会比较小）

一维数组最多开八位

所以二维数组开到1000左右

超时问题（1s计算1~2000万次）

二重循环能算n到2000，而三重到200

ios::sync_with_stdio(false)

取消cin与stdin同步 cin会更快 但注意之后别和scanf混用可能会出现混乱

cin慢是有原因的，其实默认的时候，cin与stdin(标准输入，即从键盘输入，scanf)总是保持同步的，也就是说这两种方法可以混用，而不必担心文件指针混乱，同时cout和stdout也一样，两者混用不会输出顺序错乱。正因为这个兼容性的特性，导致cin有许多额外的开销，如何禁用这个特性呢？只需一个语句std::ios::sync_with_stdio(false);，这样就可以取消cin于stdin的同步了。

cin，cout之所以效率低，是因为先把要输出的东西存入缓冲区，再输出，导致效率降低，而这段语句可以来打消iostream的输入 输出缓存，可以节省许多时间，使效率与scanf与printf相差无几

1.  std::ios::sync_with_stdio(false);
2.  std::cin.tie(0);//解除cin与cout的绑定，效率更快

输入输出很多时用scanf,printf

如1e18,用cin,cout会超时

有的题目没说遇EOF结束，只说有多个输入数据可能要加scanf（）！=EOF，否则超时

 

优化

1、优化代码框架

个人觉得代码架构对性能的影响至关重要，就好骨架之于人，所以我把这个放在第一点。举个简单的例子：

优化前：

void main()
{
	while (isDone)
	{
		DoSomething1();
 
		DoSomething2();
	}
}
 
void DoSomething1()
{
	....;
}
 
void DoSomething2()
{
	....;
	
	if (...)
	{
		isDone = True;
	}
}

优化后：

void main()
{
	DoSomething1();
}
 
void DoSomething1()
{
	while (isDone)
	{
		....;
 
		DoSomething2();
	}
}
 
void DoSomething2()
{
	....;
 
	if (...)
	{
		isDone = True;
	}
}

优化前频繁的调用DoSomething1()和DoSomething2()，需要被调用函数频繁的入栈出栈，开销很大，可以合理的优化代码结构，减少函数调用层次和嵌套深度，甚至有些函数可以使用内联或define来定义，以减少函数调用所占时间。当然不能破坏程序的美观和可读性，要跟性能之间做一个平衡。

 

2、简化函数

1）充分理解函数所要实现的功能，用最简单的方式去实现，去掉冗余的逻辑。

2）优化循环，有些操作可以放到循环外做，不必每次都做

3、选取合适的算法和数据结构

选取合适的数据结构很重要，通常使用指针比数组要快很多；对于频繁插入删除的操作，使用链表要比使用数组快很多。一般使用指针比使用数组索引快。

使用数组：

1. for (int i = 0; i < len; i++)

2. {

3. A = array[i];

4. }

使用指针：

1. p = array;

2. for (int i = 0; i < len; i++)

3. {

        A = *p++;

4. }

 

4、减少运算强度

1）尽量使用位操作代替计算

1. a = a * 8;

2. a = a / 8;

3. a = a % 8;

修改成

1. a = a << 3;

2. a = a >> 3;

3. a = a & 0x7;

2 ）公共子表达式可以提前计算

1. c = a + b;

2. d = a + b + e;

3. f = a + b + g;

优化成：

1. c = a + b;

2. d = c + e;

3. f = c + g;

3）通过查表来换取时间

4）前缀改成后缀， i++改成++i

 

5、利用操作系统和CPU本身的优势

1）充分利用操作系统的位宽，尤其是拷贝等操作上，但这个地方要注意字节对齐

1. char *a, *b;

2. ...

3. for ( ; ; )

4. {

5. *a = *b;

6. a++;

7. b++;

8. }

假设操作系统64位，可优化成

1. for ( ; ; )

2. {

3. (long long *)a = (long long *)b;

4. a = a + 8;

5. b = b + 8;

6. }

2）充分利于CPU的流水

利用CPU的流水来做并行计算，比如：

1. for (int i = 0; i < len; i++)

2. {

3. sum += a[i];

4. }

优化后：

1. for (int i = 0; i < len; i = i + 4)

2. {

3. sum1 += a[i];

4. sum2 += a[i + 1];

5. sum3 += a[i + 2];

6. sum4 += a[i + 3];

7. }

8. sum + sum1 + sum2 + sum3 + sum4;

6、采用编译选项-O2

开启编译选项-O2，不仅会对代码的分支、常量、表达式进行优化，还会尝试更多寄存器和指令级的优化，编译期间会占用更多的内存和编译时间，但对于运行效率会有很大提升。当然也会带来一些麻烦，它会改变代码结构，比如对对分支的合并和消除，对公用子表达式的消除，对循环内load/store操作的替换和更改等，都会使目标代码的执行顺序变得面目全非，导致调试信息严重不足。

 

输入_第一类：输入不说明有多少个Input Block,以EOF为结束标志。

C语法：
while(scanf("%d %d",&a, &b) != EOF) 
{ .... } 

 

C++语法：
while( cin >> a >> b ) 
{ .... } 

 

说明：

Scanf函数返回值就是读出的变量个数，如：scanf( “%d %d”, &a, &b ); 如果只有一个整数输入，返回值是1，如果有两个整数输入，返回值是2，如果一个都没有，则返回值是-1。

EOF是一个预定义的常量，等于-1。

 

输入_第二类：输入一开始就会说有N个Input Block,下面接着是N个Input Block。

C语法：
scanf("%d",&n) ; 
for( i=0 ; i { .... } 
 

C++语法：
cin >> n; 
for( i=0 ; i { .... } 

输入_第三类：输入不说明有多少个Input Block,但以某个特殊输入为结束标志。

 

C语法：
while(scanf("%d",&n) && n!=0 ) 
{ .... } 
 C++语法：
while( cin >> n && n != 0 ) 
{ .... } 

输入_第四类：输入是一整行的字符串的

#include 
 #include 
 int main(void){
 int i;
 char a[15],b[205];
   while(1){
 gets(a);
 if(strcmp(a,"ENDOFINPUT")==0) 
 break;
 gets(b);
 gets(a);
   for(i=0;b[i]!='\0';i++){
   if(b[i]>=65&&b[i]<=90){
   b[i]-=5;
   if(b[i]<65) b[i]+=26;
   }
 printf("%c",b[i]);
 }
 printf("\n");
 }
 return 0;
 }
   while(1){
 gets(a);
 if(strcmp(a,"ENDOFINPUT")==0) 
 break;
 gets(b);
 gets(a);
   for(i=0;b[i]!='\0';i++){
   if(b[i]>=65&&b[i]<=90){
   b[i]-=5;
   if(b[i]<65) b[i]+=26;
   }
 printf("%c",b[i]);
 }
 printf("\n");
 }
 return 0;
 }

C语法：
char buf[20]; 
gets(buf); 

C++语法：
如果用string buf;来保存：getline( cin , buf ); 

如果用char buf[ 255 ]; 来保存：cin.getline( buf, 255 );