忘记初始化

写并查集时自作多情写了个Start()，然后……没调用。

合并并查集时不加find

事实上，我的并查集合并一直是这么写的

void merge(int a , int b){
    pre[a] = b;
}

但正确的写法应该是这样

void merge(int a , int b){
    if(find(a) != find(b)){
        pre[find(a)] = find(b);
    }
    return ;
}

排序时把n和m弄反

不多说，说多都是泪。

void Kruskal(){
    for(int i = 1; i <= n; i ++){
        pre[i] = i;
    }
    sort(EDGE + 1 , EDGE + 1 + n , cmp);    //Wrong!!!
    for(int i = 1; i <= m; i ++){
        if(find(EDGE[i].from) != find(EDGE[i].to)){
            merge(EDGE[i].from , EDGE[i].to);
            add_edge(EDGE[i].from , EDGE[i].to , EDGE[i].dis);
            add_edge(EDGE[i].to , EDGE[i].from , EDGE[i].dis);
        }
    }
}

写LCA不比较最后一步

在Luogu P1967 货车运输一题中，作者写了以下的LCA

int LCA(int x , int y){
    if(find(x) != find(y)){
        return -1;
    }
    ll ans = 2147483647;
    if(dep[x] > dep[y]){
        swap(x , y);
    }
    for(int i = 20; i >= 0; i --){
        if(dep[fa[y][i]] >= dep[x]){
            ans = min(ans , val[y][i]);   
            y = fa[y][i]; 
        }
    }
    if(x == y){
        return ans;
    }
    for(int i = 20; i >= 0; i --){
        if(fa[x][i] != fa[y][i]){
        	ans = min(ans , min(val[x][i] , val[y][i]));
            x = fa[x][i];
            y = fa[y][i];
        }
    }
    return ans;     \\Wrong!!!
}

但事实上，正确的写法是这样的

int LCA(int x , int y){
    if(find(x) != find(y)){
        return -1;
    }
    ll ans = 2147483647;
    if(dep[x] > dep[y]){
        swap(x , y);
    }
    for(int i = 20; i >= 0; i --){
        if(dep[fa[y][i]] >= dep[x]){
            ans = min(ans , val[y][i]);   
            y = fa[y][i]; 
        }
    }
    if(x == y){
        return ans;
    }
    for(int i = 20; i >= 0; i --){
        if(fa[x][i] != fa[y][i]){
        	ans = min(ans , min(val[x][i] , val[y][i]));
            x = fa[x][i];
            y = fa[y][i];
        }
    }
    return min(ans, min(val[x][0], val[y][0]));     //需要比较最后一步
}

不写retuen

考场上写Exgcd忘了return，导致死递归。

int x , y;

void exgcd(int a , int b){
    if(b == 0){
        x = 1;
        y = 0;
                        //Wrong!!
    }
    exgcd(b , a % b);
    int tx = x;
    x = y;
    y = tx - a / b * y;
}

邻接表不开两倍空间

经典错误，不解释。

离散化后不调用

ans_x[ans] = x.id;  //Wrong!!!
ans_y[ans] = y.id;  //Wrong!!!
ans_z[ans] = z.id;  //Wrong!!!

上面的写法等于没离散化，正确的写法是这样的

ans_x[ans] = b[x.id];
ans_y[ans] = b[y.id];
ans_z[ans] = b[z.id];

读错题目

在CF140C中，题目要求顺序输出，但我没看到……

于是……

比较时不加绝对值

在之前的一场考试中，作者在比较路程长度时没有加绝对值，导致走的路程出现了负数……

然后……就没有然后了……

读错题目 X 2

在打Codeforces Round #592 Div2时，作者再次读错题目，以为B题是一个类似于双端搜索的难题。

然后……就没有然后了……

开小数组

在记录从矩阵左上角到右下角的路径时，作者忘记开两倍数组……

于是乎……

100 -> 70
Rank 4 -> Rank 15

使用不关流的cin读入大数据

RT.

100 -> 50
Rank 3 -> Rank 9

~~自闭……~~

inf设小

RT.

100 -> 30
Rank 2 -> Rank 16

树剖最后一步写错

在某次比赛中，作者写了如下的树剖查询

void tree_opposite(int x , int y){
    while(tp[x] != tp[y]){
        if(dep[tp[x]] < dep[tp[y]]){
            swap(x , y);
        }
        Segment_tree :: range_opposite(1 , dfn[tp[x]] , dfn[x]);
        x = fa[tp[x]];
    }
    if(x != y){
        if(dep[tp[x]] > dep[tp[y]]) swap(x , y);    //Wrong!!!
        Segment_tree :: range_opposite(1 , dfn[x] + 1 , dfn[y]);
    }
}

而正确的写法是这样的

void tree_opposite(int x , int y){
    while(tp[x] != tp[y]){
        if(dep[tp[x]] < dep[tp[y]]){
            swap(x , y);
        }
        Segment_tree :: range_opposite(1 , dfn[tp[x]] , dfn[x]);
        x = fa[tp[x]];
    }
    if(x != y){
        if(dep[x] > dep[y]) swap(x , y);
        Segment_tree :: range_opposite(1 , dfn[x] + 1 , dfn[y]);
    }
}