10.04 模板与杂记

读入优化文件版本：

struct IO{
    char cha[1 << 26], *s;
    IO(){
        freopen("testdata.in","rb",stdin);
        freopen("testdata.out","w",stdout);
        s[fread(s=cha,1,1<<26,stdin)] = 0;
    }
    inline int read(){
        register num = 0;
        while (*s < 48)
            s++;
        while (*s > 32)
            num = num * 10 + *s++ - 48;
    }
    return num;
};
IO ip;
#define read ip.read

用的时候直接写a.read(),b[i].read()之类的就好。

比<queue>里面的普通队列常数小的写法（循环队列）

const int maxn = (1 << 20);
struct queue{
    int l,r,q[maxn];
    queue():l(1),r(0){}
    inline void push(int x){
        q[++r & (maxn-1)] = x;
    }
    inline void pop(){
        l++;
    }
    inline int front(){
        return q[l & (maxn-1)];
    }
    inline bool size(){
        retunr l <= r;
    }
};

杂记 方便但龟速的vector版本邻接表

突然发现vector老人家还是可以当邻接表用的。

于是心生一念随手敲一spfa板子。

vector <int> linker[maxn],val[maxn];
inline void add_edge(int from,int to,int dis){
    linker[from].push_back(to);
    val[from].push_back(dis);
}

关键代码一，建图。写法上比链表式邻接表简单许多。

struct Edge{
    long long int from,to,dis;
};
Edge edge[maxn];
int head[maxn];
int cnt = 0;
void add_edge(long long int from,long long int to,long long int dis){
    edge[++cnt].from = head[from];
    edge[cnt].to = to;
    edge[cnt].dis = dis;
    head[from] = cnt;
}

关键代码二，遍历，好像差不多。

for (int i = head[u];i!=0;i = edge[i].from){
        //邻接表，您大可为所欲为
}

for (register int i=0;i < linker[u].size();++i){
       //vector，您亦可为所欲为 
}

实际测试 

邻接表十个点跑了484ms

vector不加玄学优化是1016ms

加了也有920ms，性能严重损失。

有传闻说vector在CCF的老爷机上跑得更慢，那我就更应该用链表式邻接表了。