退役划水二诈尸记录（春季赛前打打板子）

图论

存图

链式前向星

C o d e

$Code$

 struct Graph{
    int cnt;
    int head[MAXN];
 
    Graph(){
        cnt = 0;
        memset(head, 0, sizeof(head));
    }
 
    struct Edge{
        int to, next, dis;
    }e[MAXN];
 
    inline void Add(int u, int v, int w){
        e[++cnt].to = v;
        e[cnt].dis = w;
        e[cnt].next = head[u];
        head[u] = cnt;
    }
}G;

最短路

$\mathit{Floyed}$

C o d e

$Code$

 void Floyed(){
    for(register int k = 1; k <= n; k++){
        for(register int i = 1; i <= n; i++){
            for(register int j = 1; j <= n; j++){
                if(k == i || k == j || i == j) continue;
                if(map[i][j] > map[i][k] + map[k][j]) map[i][j] = map[i][k] + map[k][j];
            }
        }
    }
}

$\mathit{SPFA}$

C o d e

$Code$

 void Spfa(int u){
    queue<int> q;
    memset(dis, 0x3f, sizeof(dis));
 
    q.push(u), dis[u] = 0, vis[u] = true;
    while(!q.empty()){
        int t = q.front();
        for(register int i = G.head[t]; i; i = G.e[i].next){
            int v = G.e[i].to;
            if(dis[v] > dis[t] + G.e[i].dis){
                dis[v] = dis[t] + G.e[i].dis;
                if(!vis[v]) q.push(v), vis[v] = true;
            }
        }
        vis[t] = false;
        q.pop();
    }
}

堆优化 $\mathit{Dijkstra}$

C o d e

$Code$

 struct Road{
    int pos, dis;
 
    bool operator < (const Road &a) const{
        return dis > a.dis;
    }
};
 
priority_queue< Road, vector<Road>, greater<Road> > q;
 
void Dijkstra(int u){
    memset(dis, 0x3f, sizeof(dis));
 
    dis[u] = 0, q.push((Road){u, 0});
    while(!q.empty()){
        int t = q.top().pos;
        q.pop();
 
        if(vis[t]) continue;
        vis[t] = true;
        for(register int i = G.head[t]; i; i = G.e[i].next){
            int v = G.e[i].to;
            if(dis[v] > dis[t] + G.e[i].dis){
                dis[v] = dis[t] + G.e[i].dis;
                if(!vis[v]) q.push((Road){v, dis[v]});
            }
        }
    }
}

最小生成树

$\mathit{Prim}$ 算法

C o d e

$Code$

 struct Road{
    int pos, dis;
 
    bool operator < (const Road &a) const{
        return dis > a.dis;
    }
};
 
priority_queue< Road, vector<Road>, greater<Road> > q;
 
void Prim(){
    memset(dis, 0x3f, sizeof(dis));
    dis[1] = 0;
    q.push((Road){1, dis[1]});
 
    while(!q.empty() && tot < n){
        int k = q.top().pos;
        q.pop();
 
        if(used[k]) continue;
        tot++;
        sum += dis[k];
        used[k] = true;
        for(register int i = head[k]; i; i = e[i].next){
            int v = e[i].to;
            if(dis[v] > e[i].dis){
                dis[v] = e[i].dis;
                q.push((Road){v, dis[v]}); 
            }
        }
    }
}

$\mathit{Kruskal}$ 算法

C o d e

$Code$

 struct Line{
    int from, to, dis;
}line[MAXM];
 
bool cmp(const Line &a, const Line &b){
    return a.dis < b.dis;
}
 
struct Union_Set{
    int fa[MAXN];
 
    void init(int n){
        for(register int i = 1; i <= n; i++) fa[i] = i;
    }
 
    int Find(int x){
        return fa[x] == x ? x : fa[x] = Find(fa[x]);
    }
}U;
 
void Kruskal(){
    U.init(n);
    sort(line + 1, line + 1 + m, cmp);
 
    for(register int i = 1; i <= m; i++){
        int u = line[i].from, v = line[i].to;
        int fa_u = U.Find(u), fa_v = U.Find(v);
        if(fa_u != fa_v){
            ++tot;
            U.fa[fa_u] = fa_v;
            G.Add(u, v, line[i].dis), G.Add(v, u, line[i].dis);
        }
        if(tot == n - 1) break;
    } 
}

$\mathit{Tarjan}$

求强连通分量及缩点

C o d e

$Code$

 void Tarjan(int u){
    low[u] = dfn[u] = ++num;
    vis[u] = true;
    stk[++top] = u;
 
    for(register int i = G.head[u]; i; i = G.e[i].next){
        int v = G.e[i].to;
        if(!dfn[v]){
            Tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(vis[v]) low[u] = min(low[u], dfn[v]);
    }
 
    if(low[u] == dfn[v]){
        ++tot; int t;
        do{
            t = stk[top--];
            vis[t] = false;
            belong[t] = tot;
        }while(t != u);
    }
}
 
void Rebuild(){
    G.cnt = 0;
    memset(G.head, 0, sizeof(G.head));
 
    for(register int i = 1; i <= m; i++){
        int u = from[i], v = to[i];
        if(belong[u] != belong[v]) G.Add(u, v);
    }
}

求割点

C o d e

$Code$

 void Tarjan(int u){
    dfn[u] = low[u] = ++num;
    int son = 0;
    for(register int i = G.head[u]; i; i = G.e[i].next){
        int v = G.e[i].to;
        if(!dfn[v]){
            ++son;
            Tarjan(v);
            low[u] = min(low[u], low[v]);
            if(dfn[u] <= low[v]){
                if(son > 1 || u != root) cut[u] = true;
            }
        }
        else low[u] = min(low[u], dfn[v]);
    }
}

求点双联通分量

C o d e

$Code$

 void Tarjan(int u, int fa){
    dfn[u] = low[u] = ++num;
    vis[u] = true, stk[++top] = u;
    int son = 0; bool first = true;
 
    for(register int i = G.head[u]; i; i = G.e[i].next){
        int v = G.e[i].to;
        if(first && v == fa){
            first = false;
            continue;
        }
        if(!dfn[v]){
            ++son;
            Tarjan(v, u);
            low[u] = min(low[u], low[v]);
 
            if(dfn[u] <= low[v]){
                cut[u] = true;
                ++tot;
                point[tot].push_back(u);
                int t;
                do{
                    t = stk[top--];
                    point[tot].push_back(u);
                }while(t != u);
            }
        }
        else low[u] = min(low[u], dfn[v]);
    }
 
    if(!fa && son == 1) cut[u] = false;
}

二分图

匈牙利算法

C o d e

$Code$

 bool dfs(int u){
    for(register int i = G.head[u]; i; i = G.e[i].next){
        int v = G.e[i].to;
        if(!vis[v]){
            vis[v] = true;
            if(!match[v] || dfs(match[v])){
                match[v] = u;
                return true;
            }
        }
    }
 
    return false;
}
 
int Hungary(){
    int ans = 0;
 
    for(register int i = 1; i <= n; i++){
        memset(vis, 0, sizeof(vis));
        if(dfs(i)) ++ans;
    }
 
    return ans;
}

$\mathit{Kruskal}$ 重构树

C o d e

$Code$

 struct Line{
    int from, to, dis;
}line[MAXM];
 
bool cmp(const Line &a, const Line &b){
    return a.dis < b.dis;
}
 
struct Union_Set{
    int fa[MAXN];
 
    void init(int n){
        for(register int i = 1; i <= n; i++) fa[i] = i;
    }
 
    int Find(int x){
        return fa[x] == x ? x : fa[x] = Find(fa[x]);
    }
}U;
 
void Kruskal(){
    int tot = 0; sum = n, G.cnt = 0;
    memset(G.head, 0, sizeof(G.head));
 
    U.init(n << 1);
    sort(line + 1, line + 1 + m, cmp);
 
    for(register int i = 1; i <= m; i++){
        int u = line[i].from, v = line[i].to;
        int fa_u = U.Find(u), fa_v = U.Find(v);
 
        if(fa_u != fa_v){
            ++tot;
            val[++sum] = line[i].dis;
            G.Add(fa_u, sum), G.Add(sum, fa_u);
            G.Add(fa_v, sum), G.Add(sum, fa_v);
            U.fa[fa_u] = U.fa[fa_v] = sum;
        }
        if(tot == n - 1) break;
    }
}

字符串

哈希

不用写。

$\mathit{KMP}$ 算法

不会真有人到退役也搞不清楚 $KMP$ 吧，不会吧不会吧。😋

$\mathit{Trie}$ 树

字典树

C o d e

$Code$

 struct Trie{
    int sz;
    bool val[MAXN];
    int ch[MAXN][SIZE];
 
    Trie(){
        sz = 0;
        memset(ch, 0, sizeof(ch));
        memset(val, 0, sizeof(val));
    }
 
    void Insert(char *s){
        int u = 0, len = strlen(s + 1);
        for(register int i = 1; i <= len; i++){
            int v = s[i] - 'a';
            if(!ch[u][v]) ch[u][v] = ++sz;
            u = ch[u][v];
        }
        val[u] = true;
    }
 
    bool Search(char *s){
        int u = 0, len = strlen(s + 1);
        for(register int i = 1; i <= len; i++){
            int v = s[i] - 'a';
            if(!ch[u][v]) return false;
            u = ch[u][v];
        }
        if(val[u]) return true;
        else return false;
    }
}T;

$01Trie$

C o d e

$Code$

 struct Trie{
    int sz;
    bool val[MAXN];
    int ch[MAXN][2];
 
    Trie(){
        sz = 0;
        memset(ch, 0, sizeof(ch));
        memset(val, 0, sizeof(val));
    }
 
    void Insert(int num){
        int u = 0;
        for(register int i = 31; i >= 0; i--){
            int v = (num >> i) & 1;
            if(!ch[u][v]) ch[u][v] = ++sz;
            u = ch[u][v];
        }
        val[u] = true;
    }
 
    int Search(int num){
        int u = 0, ans = 0;
        for(register int i = 31; i >= 0; i--){
            int v = (num >> i) & 1;
            if(ch[u][v ^ 1]) ans += 1 << i, u = ch[u][v ^ 1];
            else u = ch[u][v];
        }
 
        return ans;
    }
}T;

$\mathit{AC}$ 自动机

树论

树链剖分

C o d e

$Code$

 struct Graph{
    int cnt;
    int head[MAXN];
 
    struct Edge{
        int to, next;
    }e[MAXN << 1];
 
    void Add(int u, int v){
        e[++cnt].to = v;
        e[cnt].next = head[u];
        head[u] = cnt;
    }
}G;
 
void dfs_deep(int rt, int father, int depth){
    size[rt] = 1, fa[rt] = father, deep[rt] = depth;
 
    int max_son = -1;
    for(register int i = G.head[rt]; i; i = G.e[i].next){
        int v = G.e[i].to;
        if(v == father) continue;
 
        dfs_deep(v, rt, depth + 1);
        size[rt] += size[v];
        if(size[v] > max_son) son[rt] = v, max_son = size[v];
    }
}
 
void dfs_top(int rt, int top_fa){
    dfn[rt] = ++num, top[rt] = top_fa, val[num] = data[rt];
    if(!son[rt]) return;
 
    dfs_top(son[rt], top_fa);
 
    for(register int i = G.head[rt]; i; i = G.e[i].next){
        int v = G.e[i].to;
        if(!dfn[v]) dfs_top(v, v);
    }
}
 
struct Segment_Tree{
    struct Tree{
        int l, r;
        LL sum;
        LL lazy;
    }tr[MAXN << 2];
 
    inline int lson(int rt){
        return rt << 1;
    }
 
    inline int rson(int rt){
        return rt << 1 | 1;
    }
 
    inline void Pushup(int rt){
        tr[rt].sum = 1LL * (tr[lson(rt)].sum + tr[rson(rt)].sum) % p;
    }
 
    void Build(int rt, int l, int r){
        tr[rt].l = l, tr[rt].r = r;
        if(l == r){
            tr[rt].sum = val[l] % p;
            return;
        }
 
        int mid = (l + r) >> 1;
        Build(lson(rt), l, mid);
        Build(rson(rt), mid + 1, r);
 
        Pushup(rt);
    }
 
    inline void Pushdown(int rt){
        if(tr[rt].lazy){
            tr[lson(rt)].lazy = 1LL * (tr[lson(rt)].lazy + tr[rt].lazy) % p;
            tr[rson(rt)].lazy = 1LL * (tr[rson(rt)].lazy + tr[rt].lazy) % p;
            tr[lson(rt)].sum = 1LL * (tr[lson(rt)].sum + (tr[lson(rt)].r - tr[lson(rt)].l + 1) % p * tr[rt].lazy % p) % p;
            tr[rson(rt)].sum = 1LL * (tr[rson(rt)].sum + (tr[rson(rt)].r - tr[rson(rt)].l + 1) % p * tr[rt].lazy % p) % p;
            tr[rt].lazy = 0;
        }
    }
 
    void Update_Add(int rt, int l, int r, int data){
        if(tr[rt].l >= l && tr[rt].r <= r){
            tr[rt].lazy = 1LL * (tr[rt].lazy + data) % p;
            tr[rt].sum = 1LL * (tr[rt].sum + (tr[rt].r - tr[rt].l + 1) % p * data % p) % p;
            return;
        }
 
        Pushdown(rt);
 
        int mid = (tr[rt].l + tr[rt].r) >> 1;
        if(l <= mid) Update_Add(lson(rt), l, r, data);
        if(r > mid) Update_Add(rson(rt), l, r, data);
 
        Pushup(rt);
    }
 
    LL Query_Sum(int rt, int l, int r){
        if(tr[rt].l >= l && tr[rt].r <= r) return tr[rt].sum;
 
        Pushdown(rt);
 
        LL ans = 0;
        int mid = (tr[rt].l + tr[rt].r) >> 1;
        if(l <= mid) ans = 1LL * (ans + Query_Sum(lson(rt), l, r)) % p;
        if(r > mid) ans = 1LL * (ans + Query_Sum(rson(rt), l, r)) % p;
 
        return ans;
    }
}S;
 
void Update_Tree_Add(int x, int y, int data){
    while(top[x] != top[y]){
        if(deep[top[x]] < deep[top[y]]) swap(x, y);
        S.Update_Add(1, dfn[top[x]], dfn[x], data);
        x = fa[top[x]];
    }
    if(deep[x] > deep[y]) swap(x, y);
    S.Update_Add(1, dfn[x], dfn[y], data);
}
 
LL Query_Tree_Sum(int x, int y){
    LL ans = 0;
 
    while(top[x] != top[y]){
        if(deep[top[x]] < deep[top[y]]) swap(x, y);
        ans = 1LL * (ans + S.Query_Sum(1, dfn[top[x]], dfn[x])) % p;
        x = fa[top[x]];
    }
    if(deep[x] > deep[y]) swap(x, y);
    ans = 1LL * (ans + S.Query_Sum(1, dfn[x], dfn[y])) % p;
 
    return ans;
}

posted @ 2023-02-20 21:37 TSTYFST 阅读(88) 评论(4) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 【学习笔记】线段树优化建图

· 【学习笔记】树链剖分系列一 ——重链剖分——我是不是应该写一篇重链剖分呢

· 退役诈尸（NOIP春季赛赛前复习）

· 模板 - 图论

· 九下五月上旬日记

公告

昵称： TSTYFST
园龄： 2年7个月
粉丝： 82
关注： 103

+加关注

2025年3月

日

一

二

三

四

五

六

	struct Graph{
	int cnt;
	int head[MAXN];

	Graph(){
	cnt = 0;
	memset(head, 0, sizeof(head));
	}

	struct Edge{
	int to, next, dis;
	}e[MAXN];

	inline void Add(int u, int v, int w){
	e[++cnt].to = v;
	e[cnt].dis = w;
	e[cnt].next = head[u];
	head[u] = cnt;
	}
	}G;

	void Floyed(){
	for(register int k = 1; k <= n; k++){
	for(register int i = 1; i <= n; i++){
	for(register int j = 1; j <= n; j++){
	if(k == i \|\| k == j \|\| i == j) continue;
	if(map[i][j] > map[i][k] + map[k][j]) map[i][j] = map[i][k] + map[k][j];
	}
	}
	}
	}

	void Spfa(int u){
	queue<int> q;
	memset(dis, 0x3f, sizeof(dis));

	q.push(u), dis[u] = 0, vis[u] = true;
	while(!q.empty()){
	int t = q.front();
	for(register int i = G.head[t]; i; i = G.e[i].next){
	int v = G.e[i].to;
	if(dis[v] > dis[t] + G.e[i].dis){
	dis[v] = dis[t] + G.e[i].dis;
	if(!vis[v]) q.push(v), vis[v] = true;
	}
	}
	vis[t] = false;
	q.pop();
	}
	}

	struct Road{
	int pos, dis;

	bool operator < (const Road &a) const{
	return dis > a.dis;
	}
	};

	priority_queue< Road, vector<Road>, greater<Road> > q;

	void Dijkstra(int u){
	memset(dis, 0x3f, sizeof(dis));

	dis[u] = 0, q.push((Road){u, 0});
	while(!q.empty()){
	int t = q.top().pos;
	q.pop();

	if(vis[t]) continue;
	vis[t] = true;
	for(register int i = G.head[t]; i; i = G.e[i].next){
	int v = G.e[i].to;
	if(dis[v] > dis[t] + G.e[i].dis){
	dis[v] = dis[t] + G.e[i].dis;
	if(!vis[v]) q.push((Road){v, dis[v]});
	}
	}
	}
	}

	struct Line{
	int from, to, dis;
	}line[MAXM];

	bool cmp(const Line &a, const Line &b){
	return a.dis < b.dis;
	}

	struct Union_Set{
	int fa[MAXN];

	void init(int n){
	for(register int i = 1; i <= n; i++) fa[i] = i;
	}

	int Find(int x){
	return fa[x] == x ? x : fa[x] = Find(fa[x]);
	}
	}U;

	void Kruskal(){
	U.init(n);
	sort(line + 1, line + 1 + m, cmp);

	for(register int i = 1; i <= m; i++){
	int u = line[i].from, v = line[i].to;
	int fa_u = U.Find(u), fa_v = U.Find(v);
	if(fa_u != fa_v){
	++tot;
	U.fa[fa_u] = fa_v;
	G.Add(u, v, line[i].dis), G.Add(v, u, line[i].dis);
	}
	if(tot == n - 1) break;
	}
	}

	void Tarjan(int u){
	low[u] = dfn[u] = ++num;
	vis[u] = true;
	stk[++top] = u;

	for(register int i = G.head[u]; i; i = G.e[i].next){
	int v = G.e[i].to;
	if(!dfn[v]){
	Tarjan(v);
	low[u] = min(low[u], low[v]);
	}
	else if(vis[v]) low[u] = min(low[u], dfn[v]);
	}

	if(low[u] == dfn[v]){
	++tot; int t;
	do{
	t = stk[top--];
	vis[t] = false;
	belong[t] = tot;
	}while(t != u);
	}
	}

	void Rebuild(){
	G.cnt = 0;
	memset(G.head, 0, sizeof(G.head));

	for(register int i = 1; i <= m; i++){
	int u = from[i], v = to[i];
	if(belong[u] != belong[v]) G.Add(u, v);
	}
	}

	void Tarjan(int u){
	dfn[u] = low[u] = ++num;
	int son = 0;
	for(register int i = G.head[u]; i; i = G.e[i].next){
	int v = G.e[i].to;
	if(!dfn[v]){
	++son;
	Tarjan(v);
	low[u] = min(low[u], low[v]);
	if(dfn[u] <= low[v]){
	if(son > 1 \|\| u != root) cut[u] = true;
	}
	}
	else low[u] = min(low[u], dfn[v]);
	}
	}

	void Tarjan(int u, int fa){
	dfn[u] = low[u] = ++num;
	vis[u] = true, stk[++top] = u;
	int son = 0; bool first = true;

	for(register int i = G.head[u]; i; i = G.e[i].next){
	int v = G.e[i].to;
	if(first && v == fa){
	first = false;
	continue;
	}
	if(!dfn[v]){
	++son;
	Tarjan(v, u);
	low[u] = min(low[u], low[v]);

	if(dfn[u] <= low[v]){
	cut[u] = true;
	++tot;
	point[tot].push_back(u);
	int t;
	do{
	t = stk[top--];
	point[tot].push_back(u);
	}while(t != u);
	}
	}
	else low[u] = min(low[u], dfn[v]);
	}

	if(!fa && son == 1) cut[u] = false;
	}

	bool dfs(int u){
	for(register int i = G.head[u]; i; i = G.e[i].next){
	int v = G.e[i].to;
	if(!vis[v]){
	vis[v] = true;
	if(!match[v] \|\| dfs(match[v])){
	match[v] = u;
	return true;
	}
	}
	}

	return false;
	}

	int Hungary(){
	int ans = 0;

	for(register int i = 1; i <= n; i++){
	memset(vis, 0, sizeof(vis));
	if(dfs(i)) ++ans;
	}

	return ans;
	}

	struct Trie{
	int sz;
	bool val[MAXN];
	int ch[MAXN][SIZE];

	Trie(){
	sz = 0;
	memset(ch, 0, sizeof(ch));
	memset(val, 0, sizeof(val));
	}

	void Insert(char *s){
	int u = 0, len = strlen(s + 1);
	for(register int i = 1; i <= len; i++){
	int v = s[i] - 'a';
	if(!ch[u][v]) ch[u][v] = ++sz;
	u = ch[u][v];
	}
	val[u] = true;
	}

	bool Search(char *s){
	int u = 0, len = strlen(s + 1);
	for(register int i = 1; i <= len; i++){
	int v = s[i] - 'a';
	if(!ch[u][v]) return false;
	u = ch[u][v];
	}
	if(val[u]) return true;
	else return false;
	}
	}T;

TSTYFST

神必 + 缝合怪 + 乐子人 + 垃圾人 = 100%的TSTYFST

退役划水二 诈尸记录（春季赛前打打板子）

图论

存图

链式前向星

最短路

FloyedFloyed\mathit{Floyed}

SPFASPFA\mathit{SPFA}

堆优化 DijkstraDijkstra\mathit{Dijkstra}

最小生成树

PrimPrim\mathit{Prim} 算法

KruskalKruskal\mathit{Kruskal} 算法

TarjanTarjan\mathit{Tarjan}

求强连通分量及缩点

求割点

求点双联通分量

二分图

匈牙利算法

KruskalKruskal\mathit{Kruskal} 重构树

字符串

哈希

KMPKMP\mathit{KMP} 算法

TrieTrie\mathit{Trie} 树

字典树

01Trie01Trie01Trie

ACAC\mathit{AC} 自动机

树论

树链剖分

公告

搜索

常用链接

我的标签

积分与排名

随笔分类 (86)

随笔档案 (71)

相册 (39)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

退役划水二诈尸记录（春季赛前打打板子）

$\mathit{Floyed}$

$\mathit{SPFA}$

堆优化 $\mathit{Dijkstra}$

$\mathit{Prim}$ 算法

$\mathit{Kruskal}$ 算法

$\mathit{Tarjan}$

$\mathit{Kruskal}$ 重构树

$\mathit{KMP}$ 算法

$\mathit{Trie}$ 树

$01Trie$

$\mathit{AC}$ 自动机