【零零碎碎的knowledge】

 

for(int i = 1; i <= n; ++i) //预先算出log_2(i)+1的值，用的时候直接调用就可以了
      lg[i] = lg[i-1] + (1 << lg[i-1] == i);  //看不懂的可以手推一下
for(int i = 1; i <= n; ++i){ //约等于
    if((1<<lg[i-1])==i) lg[i]=lg[i-1]+1;  
    else lg[i]=lg[i-1];
}

int add(int U,int V,int val){
    a[++N].to=V;
    a[N].edge=val;
    a[N].next=last[U];
    last[U]=N;
}

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")

struct node{
    int value,num;
    friend bool operator < (node a, node b){
        if(a.value==b.value) return a.num>b.num;
        else return a.value>b.value;
    }//升序排序(从小到大)
};
priority_queue<node> q;
/*
    empty(); 队列为空返回1
    pop();   出队
    push();  入队
    top();   返回队列中优先级最高的元素
    size();  返回队列中元素的个数
*/

long long ksm(long long a,int n,long long Mod){
    long long ans=1;
    while(n){
        if(n&1) ans=(ans*a)%Mod;
        a=(a*a)%Mod;
        n>>=1;
    }
    return ans;
}

sort(a,a+n);//一定要先排序 
n=unique(a,a+n)-a;//去重！n为去重后的长度 

long long ksm(long long ds,long long zs){
    int ans=1;
    for(long long i=zs;i;i>>=1,ds=ds*ds%Mod)
        if(i&1) ans=ans*ds%Mod;
    return ans;
}

inv[1]=1;
for(int i=1;i<=n;i++)
     inv[i]=( (mod-mod/i)*inv[mod%i] +mod ) %mod;

 

//快读
inline long long read(){
    register long long s=(long long)0,w=(long long)1;
    register char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-') w=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        s=(s<<1)+(s<<3)+(ch^48);
        ch=getchar();
    }
    return s*w;
}

 

 

· 2的逆元为（n/2）+1；

·约数和定理：约数之和[（p1^α1）-1 ] /（p1-1） * [（p2^α2）-1 ] / （p2-1） * .....  *[（pk^αk）-1 ]/（pk-1)

　　　　　　 约数个数之和=（a1+1）*(a2+1)*…（αk+1 ）

 ·三目运算符

if(a<b) min=a;
else min=b;
可以用下面的条件运算符来处理
min=(a<b)?a:b;

 

for(int i=0;i<a.size();i++){
}←这样十分耗时间，每次都要计算一遍a的长度

n=a.size();
for(int i=0;i<n;i++){
}←GOOD

字符串转int
#include<sstream>

int _num(string shu){
    int sh;
    stringstream strr;
    strr<<shu;
    strr>>sh;
    strr.clear();
    return sh;
}

有多少个1
int _bitcount(int x){
    return x==0 ? 0 : _bitcount(x/2)+(x&1);
}

 cout<<endl 比 cout<<'\n' 慢 很 多

关于const这个奇奇怪怪的东西