卡常

转载自：https://blog.csdn.net/IOT_SONG/article/details/51477071

             https://blog.csdn.net/qq_33957603/article/details/79946680

　　　　https://blog.csdn.net/leader_one/article/details/78430083

　　　　https://blog.csdn.net/xuxiayang/article/details/81021585 

　　　　remarkable

传说中的神级快读fread:

　　#define getchar() (S==T&&(T=(S=BB)+fread(BB,1,1<<15,stdin),S==T)?EOF:*S++)
　　char BB[1<<15],*S=BB,*T=BB;;
　　IL LL read()
　　{
   　　 f=0;Re char c;
   　　 while(c=getchar(),c<=47||c>=58);f=(f<<3)+(f<<1)+c-48;
    　　while(c=getchar(),c>=48&&c<=57) f=(f<<3)+(f<<1)+c-48;
    　　return f;
　　}

快输慎用：

基本程序
void write(int x)
{
    /*在这一行你能够进行一些特殊处理和判断，例如处理负数等*/
    if(x>9) write(x/10);//能分解则分解
    putchar(x%10+48);//利用C++putchar速度快的因素加速输出
}
改造输出优化，需搭配上面的进行
1.输出后空格
void writespace(int x)
{
    write(x);putchar(32);return;//这里仍然利用了puchar速度快的优势
}
2.输出后换行
void writeln(int x)
{
    write(x);putchar(10);//依旧利用putchar快速的优势，达到十分快速的效果
}

0.位运算心法：（掌握粗体字）
&（与逻辑）：有0出0，全1出1；
|（或逻辑）：有1出1，全0出1；
~（非逻辑）：空便是色，色便是空；
^（异或）：相异出1，相同出0；
1. 若是乘上一个2的倍数数值，能够改用左移运算(Left Shift) 加速 300%
　　x = x * 2;
　　x = x * 64;
　　//改成:
　　x = x << 1; // 2 == 21
　　x = x << 6; // 64 == 26
2. 若是除上一个 2 的倍数数值，能够改用右移运算加速 350%
　　x = x / 2;
　　x = x / 64;
　　//改成:
　　x = x >> 1; // 2 == 21
　　x = x >> 6; // 64 == 26
3. 数值转整数加速 10%
　　x = int(1.232)
　　//改成:
　　x = 1.232 >> 0;
4. 交换两个数值(swap)，使用 XOR 能够加速20%
　　var t:int = a;
　　a = b;
　　b = t;
　　//equals:
　　a = a^b;
　　b = a^b;
　　a = a^b;
5. 正负号转换，能够加入 300%
　　i = -i;
　　//改成
　　i = ~i + 1; // NOT 写法
　　//或
　　i = (i ^ -1) + 1; // XOR 写法
6. 取余数，若是除数为 2 的倍数，可利用 AND 运算加速 600%
　　x=131 % 4;
　　//equals:
　　x=131 & (4 - 1);
7. 利用 AND 运算检查整数是否为 2 的倍数，能够加速 600%
　　isEven = (i % 2) == 0;
　　//equals:
　　isEven = (i & 1) == 0;
8. 加速 Math.abs 600% 的写法1，写法2 又比写法1加速 20%
　　//写法1
　　i = x < 0 ? -x : x;
　　//写法2
　　i = (x ^ (x >> 31)) - (x >> 31);
　　//写法3
　　i=x^(~(x>>31)+1)+(x>>31);
9. 比较两数值相乘以后是否拥有相同的符号，加速 35%
　　eqSign = a * b > 0;
　　//equals:
　　eqSign = a ^ b > 0;

10.if，else语句比三目运算符语句要慢，逗号运算符比分号运算符要快。

11.结构优化

      若是你要常常调用a[x],b[x],c[x]这样的数组，把她们写在同一个结构体里面会变快一些，好比f[x].a, f[x].b, f[x].c
      指针比下标快。

12.能少判断少判断 （if）

　　 Floyd初始化

for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)   gra[i][j]=inf
for(int i=1;i<=b;i++)   gra[i][i]=0
是比

for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    {
        if(i==j) gra[i][j]=0;
        else gra[i][j]=inf
    }     快80%以上的，，由于要每次去比较。

13.因为没有开O2优化，会致使一些原本没有区别的变得比较明显。
多维数组把大的数放前面：
例如 int f[10000][1000][100] 而不是 f[100][1000][10000]，跑起来差距0.Xs。
有时比算法的差距还大

14.循环内的问题
　　E.g1
　　for(int i = 0; i <= n; i++)
　　{
 　　 work1();
  　　work2();
　　}
　　E.g2
　　for(int i = 0; i <= n; i++) work1();
　　for(int i = 0; i <= n; i++) work2();
　　运行效率哪个快呢？
　　应该大多数人都以为是第一种快，由于它少了一遍变量枚举-
　　其实这是片面的，若是work1( )和work2( )运算量都比较大的话，是第二种更快 

15.对于运算量比较小的计算式，几个运算写在一条式子会更快（可能不是快一点）

　　x= a+b; x = x%mod; 是没有 x = (a+b)%mod 速度快的在循环量大时有奇效

16.听说主函数用signed比int更快

17.摘自remarkable

二.运算

mod定义成const

能乘不除，能加减别用魔法模法

能位运算就别用加减乘除··

x2^n改为<<n

/2^n改为>>n

swap(x,y)改为x^=y^=x^=y

模数若为2^n能够直接&(mod-1)

也能够先开unsigned int最后取模

两个小于模数相加用down(x)

(x%mod+mod)%mod改为up(x%mod)

18.自我心得：

　　a=b=***没有a=***,b=***快  在一些for循环中最好别写连等，尤为是多个连等。