8/15 缩点+割点(割顶)+桥（割边）+字符串哈希

最新推荐文章于 2024-09-12 19:02:20 发布
最新推荐文章于 2024-09-12 19:02:20 发布
阅读量187 收藏
点赞数 2
分类专栏： 22暑期ACM训练 文章标签： 哈希算法 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51934288/article/details/126342367
版权

P3387 【模板】缩点

分三部分：
1.使用tarjan缩点，将各个强连通分量(分量内各店可相互到达)看作一个点。
2.建立缩点后的拓扑图，这些连通分量间也存在连线。
3.由于tarjan的出栈操作，当dfn==low是出栈被标记，标记值是由小到大的。先被标记的值小。
因此要在拓扑图上逆序dp
在这里插入图片描述

#include<bits/stdc++.h>
#define endl '\n'
#define re register
#define int long long
#define ios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define maxn 1000000000LL
using namespace std;
const int N=7e5+10;
const int inf=0x3f3f3f3f;
const int mod=1e7+7;
vector<int>e[N],ne[N];
int dfn[N],low[N],tot;
int stk[N],instk[N],top;
int scc[N],siz[N],cnt;
int n,m,a[N],val[N],dp[N];
void tarjan(int x)
{
    //盖戳、入栈
    dfn[x]=low[x]=++tot;
    stk[++top]=x,instk[x]=1;
    for(int y:e[x])
    {
        if(!dfn[y])
        {
            tarjan(y);
            //回x时及时更新low
            low[x]=min(low[x],low[y]);
        }
        else if(instk[y]) //若x已访问且在栈中
            low[x]=min(low[x],dfn[y]);
    }
    if(dfn[x]==low[x]) //若x时SCC的根
    {
        int y;++cnt;
        do{
            y=stk[top--];instk[y]=0; //出栈
            scc[y]=cnt; //SCC编号
            ++siz[cnt];
            val[cnt]+=a[y];
        }while(y!=x);
    }
}
void solve()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    for(int i=1;i<=m;i++)
    {
        int u,v;cin>>u>>v;
        e[u].push_back(v);
    }
    for(int i=1;i<=n;i++)
        if(!dfn[i]) tarjan(i);
    //建立拓扑图
    for(int i=1;i<=n;i++)
    {
        for(int j:e[i])
        {
            int a=scc[i],b=scc[j];
            if(a!=b) ne[a].push_back(b);
        }
    }
    //在拓扑图上逆序dp
    for(int x=cnt;x;x--)
    {
        if(dp[x]==0) dp[x]=val[x];
        for(int y:ne[x])
            dp[y]=max(dp[y],dp[x]+val[y]);
    }
    int ans=0;
    for(int i=1;i<=cnt;i++)
        ans=max(ans,dp[i]);
    cout<<ans<<endl;
}
signed main()
{
    solve();
    return 0;
}

P3388 【模板】割点（割顶）

割点判定法则： low[y]>=dfn[x]
非根结点找到一颗子树，根节点至少需要两棵子树。

#include<bits/stdc++.h>
#define endl '\n'
#define re register
#define int long long
#define ios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define maxn 1000000000LL
using namespace std;
const int N=7e5+10;
const int inf=0x3f3f3f3f;
const int mod=1e7+7;
vector<int>e[N];
int dfn[N],low[N],tot;
int stk[N],instk[N],top;
int cut[N],root;
int n,m;
void tarjan(int x)
{
    //盖戳、入栈
    dfn[x]=low[x]=++tot;
    int child=0;
    for(int y:e[x])
    {
        if(!dfn[y])
        {
            tarjan(y);
            //回x时及时更新low,判断割点
            low[x]=min(low[x],low[y]);
            if(low[y]>=dfn[x])
            {
                child++;
                if(x!=root||child>1)
                    cut[x]=1;
            }
        }
        else  
            low[x]=min(low[x],dfn[y]);
    }
    
}
void solve()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int u,v;cin>>u>>v;
        e[u].push_back(v),e[v].push_back(u);
    }
    for(int i=1;i<=n;i++)
        if(!dfn[i]) 
            root=i,tarjan(i);
    int ans=0;
    for(int i=1;i<=n;i++)
        if(cut[i]) ans++;
    cout<<ans<<endl;
    for(int i=1;i<=n;i++)
        if(cut[i]) cout<<i<<" ";
    cout<<endl;
}
signed main()
{
    solve();
    return 0;
}

割边

https://www.bilibili.com/video/BV14g411Q7ze?spm_id_from=333.999.0.0&vd_source=91973ada1213cf6ba2cbb43a2bebd2e8
条件：low[y]>dfn[x] 不允许走x->y的反边更新low值

#include<bits/stdc++.h>
#define endl '\n'
#define re register
#define int long long
#define ios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define maxn 1000000000LL
#define ULL unsigned long long
using namespace std;
const int N=7e5+10;
const int inf=0x3f3f3f3f;
const int mod=1e7+7;
const int P=131;
struct edge
{
    int to,nxt;
}e[N];  //边集
int dfn[N],low[N],tot,cnt,idx=1;
struct bridge
{
    int x,y;
}bri[N];
void add(int to,int nxt)
{
    e[++idx]={to,head[from]};
    h[from]=idx;
}
void tarjan(int x,int in_edge)
{
    dfn[x]=low[x]=++tot;
    for(int i=head[x];i;i=e[i].nxt)
    {
        int y=e[i].to;
        if(!dfn[y])
        {
            tarjan(y,i);
            low[x]=min(low[x],low[y]);
            if(low[y]>dfn[x])
            bri[++cnt]={x,y};
        }
        else if(i!=(in_edge^1))
            low[x]=min(low[x],dfn[y]);
    }
}

void solve()
{
    
}
signed main()
{
    solve();
    return 0;
}

P7687 [CEOI2005] Critical Network Lines

#include<bits/stdc++.h>
#define endl '\n'
#define re register
#define int long long
#define ios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define maxn 1000000000LL
#define ULL unsigned long long
using namespace std;
const int N=7e6+10;
const int inf=0x3f3f3f3f;
const int mod=1e7+7;
const int P=131;
struct edge
{
    int to,nxt;
}e[N];  //边集
int dfn[N],low[N],tot,cnt,idx=1,head[N],a[N],b[N],n,m,k,l;
struct bridge
{
    int x,y;
}bri[N];
void add(int from,int to)
{
    e[++idx]={to,head[from]};
    head[from]=idx;
}
void tarjan(int x,int in_edge)
{
    dfn[x]=low[x]=++tot;
    for(int i=head[x];i;i=e[i].nxt)
    {
        int y=e[i].to;
        if(!dfn[y])
        {
            tarjan(y,i);
            low[x]=min(low[x],low[y]);
            if(low[y]>dfn[x])
            {
                if(!a[y]||!b[y]||a[y]==k||b[y]==l)
                    bri[++cnt]={x,y};
            }
            a[x]+=a[y],b[x]+=b[y];
        }
        else if(i!=(in_edge^1))
            low[x]=min(low[x],dfn[y]);
    }
}

void solve()
{
    cin>>n>>m>>k>>l;
    for(int i=1,x;i<=k;i++)
        cin>>x,a[x]=1;
    for(int i=1,x;i<=l;i++)
        cin>>x,b[x]=1;
    for(int i=1,u,v;i<=m;i++)
    {
        cin>>u>>v;add(u,v),add(v,u);
    }
    tarjan(1,2);
    cout<<cnt<<endl;
    for(int i=1;i<=cnt;i++)
        cout<<bri[i].x<<" "<<bri[i].y<<endl;
}
signed main()
{
    solve();
    return 0;
}

字符串哈希

P3370 【模板】字符串哈希

#include<bits/stdc++.h>
#define endl '\n'
#define re register
#define int long long
#define ios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define maxn 1000000000LL
#define ULL unsigned long long
using namespace std;
const int N=7e5+10;
const int inf=0x3f3f3f3f;
const int mod=1e7+7;
const int P=131;
ULL p[N],h[N];
int n,a[N];
char s[N];
int init(char s[])
{
    p[0]=1,h[0]=0;
    int len=strlen(s+1);
    for(int i=1;i<=len;i++)
    {
        p[i]=p[i-1]*P;
        h[i]=h[i-1]*P+s[i];
    }
    return h[len];
}
//计算s[l-r]之间的hash值
ULL get(int l,int r)
{
    return h[r]-h[l-1]*p[r-l+1];
}
//判断两子串是否相同
bool subs(int l1,int r1,int l2,int r2)
{
    return get(l1,r1)==get(l2,r2);
}

void solve()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        scanf("%s",s+1);
        a[i]=init(s);
    }
    int ans=1;
    sort(a+1,a+n+1);
    for(int i=2;i<=n;i++)
        if(a[i]!=a[i-1]) ans++;
    cout<<ans<<endl;
}
signed main()
{
    solve();
    return 0;
}
钟钟终
关注
专栏目录
ACM知识点+模板
qq_42024195的博客
05-01 500
基础算法 枚举 高精度 模拟 位运算 RMQ 贪心算法 区间选点问题 区间覆盖问题 选择不相交区间问题 哈夫曼树 查找算法 二分查找 分块查找 哈希查找 搜索算法 深度优先搜索（DFS） 广度优先搜索（BFS） 搜索剪枝（记忆搜索） 双向广搜 A*、IDA*搜索 启发式搜索 动态规划 背包问题 连续序列 高维状态dp 状态压缩dp 区间dp 环形dp...
leetcode[1763]最长的美好子字符串 python3实现（分治法）
zhang35的博客
02-01 589
# 当一个字符串 s 包含的每一种字母的大写和小写形式 同时 出现在 s 中，就称这个字符串 s 是 美好 字符串。比方说，"abABB" 是美好字符串，因为 # 'A' 和 'a' 同时出现了，且 'B' 和 'b' 也同时出现了。然而，"abA" 不是美好字符串因为 'b' 出现了，而 'B' 没有出现。 # # 给你一个字符串 s ，请你返回 s 最长的 美好子字符串 。如果有多个答案，请你返回 最早 出现的一个。如果不存在美好子字符串，请你返回一个空字符串。 # # # # 示例
无向图割点（割顶）、桥（边的双连通分量+缩点）
智障
08-15 7262
求割顶(割点)，主要的算法结构就是DFS，一个点是割点，当且仅当以下两种情况: (1)该节点是根节点，且有两棵以上的子树 (2)该节点的子节点中的任一个，没有到该节点祖先的反向边（就是说如果没有这个割顶，那么这个子节点和那个祖先之间就不能连通） 代码：（连通图） #define N 103 vector g[N]; int n, low[N], dfn[N], f[N]; bool v
tarjan模板
qq_39921637的博客
04-05 120
int head[maxn], dfn[maxn], low[maxn]; int st[maxn], ins[maxn], c[maxn]; vector<int>ssc[maxn]; int n, m, tot, num, top, cnt; struct node{ int v, to; }cc[eg]; void add(int u, int v) { tot++; cc...
24.7.28（tarjan 割点，割边，多重背包单调队列优化）
breath_of_yuan的博客
07-28 729
实际两边不需要全填-1，首先明确x和y的位置必填1，且y-1和x+1必填-1，此后-1和1交替填就行，若头尾是1，会出现错误吗，事实上是不会的，因为x严格大于y，故x至y的和即前后缀最大值>=2若头尾是-1，前后缀最大值>=1。思路：开始容易想到 y前和 x后全-1，y到x填1的构造，但对于 5 2 1，1 1 -1 -1 -1有问题，1和5的后缀值都为 -1，y判定为5。补 ABC344 F。补 ABC272 E。补 ABC225 F。补 ABC199 E。贴 ABC322 F。补 ABC156 D。
各种字符串Hash函数比较
chengfangang的专栏
10-15 1058
https://www.byvoid.com/blog/string-hash-compare/ 常用的字符串Hash函数还有ELFHash，APHash等等，都是十分简单有效的方法。这些函数使用位运算使得每一个字符都对最后的函数值产生影响。另外还有以MD5和SHA1为代表的杂凑函数，这些函数几乎不可能找到碰撞。 常用字符串哈希函数有BKDRHash，APHash，DJBHash，JSHash
洛谷or牛客数据结构+算法
weixin_62949374的博客
12-06 943
1.单调栈（p5788） 单调栈 求第一个大于的数模板 从右往左扫描 #include <cstdio> #include <stack> using namespace std; int a[10000000],f[10000000];//a存放输入，f存放答案 int main() { int n,i; stack<int> q; //栈 scanf("%d",&n); for(i=1;i<=n;i++) { scanf("%d"
知识点掌握情况
zhy_Learn的博客
07-20 359
数论 素数 最大公约数 欧拉函数(不熟) 筛法 欧拉定理 & 费马小定理(不熟) 类欧几里德算法 裴蜀定理 乘法逆元(不熟) 线性同余方程(不熟) 中国剩余定理 二次剩余 BSGS 原根 卢卡斯定理 莫比乌斯反演 杜教筛 Min_25 筛 分解质因数 字符串 字符串匹配 字符串哈希 字典树 (Trie) 前缀函数与 KMP 算法(不熟) Boyer-Moore算法 Z 函数（扩展 KMP） 自动机 AC 自动机(不熟) 后缀数组 (SA)
[luogu] 盘点当前的知识点任务
STJqwq的博客
12-01 2116
普及– 模板大全续表续表A 并查集A 快速幂-取余运算A 线性筛素数A 最小生成树A 堆A 快速排序A 字符串哈希普及/提高– 模板续表续表A 单调队列A 三分法A 矩阵快速幂A 树状数组 1A 乘法逆元A 最近公共祖先A 单源最短路径AA KMP字符串匹配A 树状数组 2A 线段树 1A&
2、省选＋NOI-第二部分 字符串_2020.09.04.pdf
11-25
- **Tarjan算法**：用于寻找强连通分量（SCC）、桥、割点等。 - **树的相关算法**： - **树上倍增**：用于快速查询LCA问题。 - **树的直径**：即树中最长的简单路径。 - **树的重心**：删除该节点后树被分割成...
6、省选＋NOI-第六部分 技巧与思想_2020.08.27.pdf
11-25
8. **字符串相关** - **哈希（自然溢出，双哈希）**。 - **KMP算法**：避免回溯的模式匹配。 - **AC自动机**：快速处理多个模式的字符串搜索。 - **后缀数组**、**Manacher算法**、**最小表示法**。 - **后缀...
7、省选＋NOI-第七部分 计算几何_2020.08.27.pdf
11-25
7. **Tarjan算法**：用于寻找强连通分量(SCC)、桥、割点等。 8. **树的相关算法**： - 树上倍增：用于求最近公共祖先(LCA)。 - 树的直径、树的重心：涉及到树的一些特殊性质。 - DFS序：深度优先搜索的一种应用。...
3、省选＋NOI-第三部分 树上问题_2020.08.27.pdf
11-25
18. **字符串处理** - Hash、KMP、AC自动机、后缀数组、Manacher算法、最小表示法、后缀自动机、回文自动机、后缀树等。 19. **数学知识** - 数论（GCD、LCM、筛法、模逆、快速幂）、线性筛、积性函数、容斥原理...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 448
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 257
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1146
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 293
试除法求约数、约数个数、约数之和、最大公约数
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 553
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
字符串哈希+滑动窗口
08-24
- *1* [String （字符串哈希+滑动窗口）](https://blog.csdn.net/weixin_43872264/article/details/107571742)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值