【程序设计竞赛】竞赛中的细节优化

必须强调下，以下的任意一种优化，都应该是在本身采用的算法没有任何问题情况下的“锦上添花”，而不是“雪中送炭”。
如果下面的说法存在误导，请专业大佬评论指正

读写优化

C++读写优化——解除流绑定

在ACM里，经常出现数据集超大造成 cin TLE的情况，其实cin效率之所以低，不是比C低级，而是因为需要与scanf的缓冲区同步，导致效率降低，而且是C++为了兼容C而采取的保守措施。
C++代码中添加 ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);这一段之后，读取速度即可无限趋近于scanf和printf。
如果代码首部没有using namespace std; 则要换成std::ios::sync_with_stdio(0),std::cin.tie(0),std::cout.tie(0);

#include <bits/stdc++.h>
using namespace std;int main()
{ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);// 未使用using namespace std;时使用下方写法// std::ios::sync_with_stdio(0),std::cin.tie(0),std::cout.tie(0);// 代码主体读取、操作、打印
}

std::ios::sync_with_stdio(0)

在 C++ 中，取消同步流（std::ios::sync_with_stdio）是一个常用的技巧，用来加快输入/输出流（I/O）的速度。默认情况下，C++ 的标准库（iostream）与 C 的标准库（stdio）之间是同步的，这意味着它们共享缓冲区，并且每次使用其中一个库的 I/O 功能时，都会刷新另一个库的缓冲区。这保证了数据的一致性，但也增加了性能开销。

通过调用 std::ios::sync_with_stdio(0)，你可以取消这种同步，这通常会导致 I/O 操作的速度显著提高。但是，一旦取消了同步，就不能再混用 C++ 和 C 的 I/O 函数（如 cin/cout 和 scanf/printf），因为这可能会导致输出顺序不确定或其他问题。

如果已经采用了C++的输入函数cin,就避免再使用C的scanf；同样的如果已经使用 cout 就避免再使用 printf

cin.tie(0)

在默认的情况下cin绑定的是cout，每次执行的时候都要调用flush，这样会增加IO负担。
这行代码解除了 cin（输入流）与 cout（输出流）之间的绑定。默认情况下，cin 与 cout 绑定在一起，这意味着在每次从 cin 读取之前，cout 的缓冲区都会被自动刷新。通过解除绑定，可以进一步提高 I/O 性能，但这也意味着在输出和输入操作之间不再自动刷新 cout 的缓冲区。

cout.tie(0)

这行代码通常不是必须的，因为 cout 默认情况下并不绑定到其他流。它的主要作用是确保 cout 不与任何其他流（例如 cin 或 cerr）绑定。但在大多数情况下，这行代码并不会改变默认行为。

C++换行输出

endl会输出’\n’（\n是转义字符，代表换行），然后立即刷新缓冲区并输出到屏幕上。由于要刷新缓冲区，endl会比\n慢一点，一般不建议使用。以下是endl实现：

template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
{__os.put(__os.widen('\n'));__os.flush();return __os;
}

C++中换行大多喜欢写 cout << endl;，然而据acmer和本人赛场亲身经历，这种写法比 cout << '\n; 输出速度要慢许多。当然这不乏出题人的原因，不过为了避免悲剧的发生希望大家还是使用如下两种方法。

在代码头部使用宏定义#define endl '\n' 替换endl
改掉使用endl的习惯

#include <bits/stdc++.h>
#define endl '\n'int main()
{ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);// 上方使用了宏定义,代码编译预处理阶段就将endl换成了'\n'cout << endl;// 直接输出'\n'cout << '\n';
}

C/C++自定义快读快写

本人没有亲自使用过，不过是看别人代码中有如此运用。据说C++17后getchar()/putchar()已经被负优化了，未知真假，个人选择使用。

inline int read()
{int x=0,f=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}return x*f;
}inline void write(int x)
{char F[200];int tmp=x>0?x:-x;if(x<0)putchar('-');int cnt=0;while(tmp>0){F[cnt++]=tmp%10+'0';tmp/=10;}while(cnt>0)putchar(F[--cnt]);
}

Java快读快写

大部分初学Java的人应该是使用如下代码进行Java的读写，不过下面这个代码的读写，在面对大量数据的情况下是比较慢的。

import java.util.Scanner;public class Main {public static void main(String[] args) {// java.util 包下的读取Scanner sc = new Scanner(System.in);int n = sc.nextInt();// JavaSystem.out.println(n);sc.close();}
}

下方的读写代码速度较快，经过实践检验，建议采用。该部分代码经过真实调试，应该是不存在什么问题。
特别提醒！！！如果使用了下方代码中的快速输出，代码最后必须使用out.flush(); 必须使用out.flush(); 必须使用out.flush();

快速读入的代码按需使用，写代码时不一定要全部写，如果在XCPC赛场上使用Java，可以提前写好该模板。

import java.io.*;/*** 自定义快读类*/
class Scanner {static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));// 字符串快速读入对象static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));public int nextInt() {try {st.nextToken();return (int) st.nval;} catch (IOException e) {throw new RuntimeException(e);}}public double nextDouble() {try {st.nextToken();} catch (IOException e) {throw new RuntimeException(e);}return st.nval;}public float nextFloat() {try {st.nextToken();} catch (IOException e) {throw new RuntimeException(e);}return (float) st.nval;}public long nextLong() {try {st.nextToken();} catch (IOException e) {throw new RuntimeException(e);}return (long) st.nval;}public String next() {try {st.nextToken();} catch (IOException e) {throw new RuntimeException(e);}return st.sval;}// 按行读入字符串public String readLine() {String s = null;try {s = br.readLine();} catch (IOException e) {e.printStackTrace();}return s;}
}
public class Main {// 快速输出对象static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));public static void main(String[] args) {// 创建自定义的Scanner类Scanner sc = new Scanner();/*** 快读使用案例*/int n = sc.nextInt();double d = sc.nextDouble();float f = sc.nextFloat();// 读入字符串(以空格、回车结尾)String str = sc.next();// 整行读入字符串(以回车换行结尾)String line = sc.readLine();/*** 快速输出使用案例*/out.println(n);out.println(d);out.println(f);out.println(str);out.println(line);// 快速输出必须要刷新缓冲区,否则无法输出out.flush();}
}

读写样例
在这里插入图片描述

其他玄学优化——自行试用

下方玄学，只是部分传言，有些优化的效果似乎并不显著;有时不妨一试。

常用函数优化

inline int abs(int x)
{int y=x>>31;return (x+y)^y;
}
inline int max(int x,int y)
{int m=(x-y)>>31;return (y&m)|(x&~m);
}
inline int min(int x,int y)
{int m=(x-y)>>31;return (y&m|x&~m)^(x^y);
}
inline void swap(int &x,int &y)
{x^=y,y^=x,x^=y;
}
inline int ave(int x,int y)
{return (x&y)+((x^y)>>1);
}

变量自增

++i快于i++

取模非常慢，尽量用减法代替

把函数中的循环变量在整个函数开头用register统一定义好

频繁使用的数用register，和inline一个用法，只不过有可能把变量存入CPU寄存器，来减少时间;某些生命周期不重叠的变量合并，减少创建变量空间的时间。

int main()
{register int i;for (i = 1; i <= n; ++i){// 逻辑部分}for (i = 1; i <= n; ++i){// 逻辑部分}/*下方循环多次使用i*/
}

减少使用STL，他们的常数特别大

现在大部分OJ平台都会自动开O2优化，所以可能STL常数问题可能也没那么严重，有时候也可以尝试手动开O2优化。据说有些时候可能会出现stl的map反而比自己手写map还快的情况…所以自己看情况吧

// 代码头部预处理指令手动打开O2
#pragma GCC optimize(2)

define比赋值更快

定义数组大小时尽量用奇数

尽量不要用bool,int是最快的

if()else() 语句比三元运算符慢;但if语句比三元运算符快

学会合理使用位运算

比如用它判奇偶性。n&1相当于n%2==1。还有一个操作：

inline void swap(int &x,int &y)
{x^=y^=x^=y;
}