算法(cpp) -搜索与图论

HMM
69 阅读19分钟

搜索

DFS 与 BFS 区别

  • DFS：数据结构：stack 空间 ：O（n） 不具有最短程

    • 递归结束条件的选择+状态标记+递归后的恢复

    • 回溯：恢复现场，回到上一个状态

    • 剪枝：提前判断当前状态是否合法，提前结束开始回溯

  • BFS：数据结构 ：queue 空间：O（2^n） “最短路”

BFS

Flood Fill

  • 可以在线性时间的复杂度内，找到某个点的所在的连通块 搜索w的连通块数量
#include<bits/stdc++.h>

using namespace std;

int n,m;
const int N=1010;
typedef pair<int,int> PII;
char w[N][N];
int st[N][N];

int x[8]={1,0,-1,0,1,-1,-1,1};
int y[8]={0,1,0,-1,1,-1,1,-1};

void bfs(int i,int j)
{
    queue<PII>q;
    q.push({i,j});
    st[i][j]=1;
    while(q.size())
    {
        PII t=q.front();
        q.pop();
        int tx=t.first,ty=t.second;
       
        for(int k=0;k<8;k++)
        {
            int nx=tx+x[k],ny=ty+y[k];
            if(nx<0||ny<0||nx>=n||ny>=m||w[nx][ny]=='.'||st[nx][ny])continue;
            
            q.push({nx,ny});
            st[nx][ny]=1;
        }
    }
}
int main()
{
    cin>>n>>m;
    
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            cin>>w[i][j];
    
    int ans=0;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        {
            if(!st[i][j]&&w[i][j]=='W')
            {
                bfs(i,j);
                ans++;
            }
        }
    cout<<ans;
    return 0;
}

最短路模型

  • 权重相同的情况下，bfs 第一次搜到的点的距离是这个点到起点的最短距离，用线性时间可以搜到
求左上角到右上角最短路径，·1·不可走，输出最短的具体路径

#include<bits/stdc++.h>

using namespace std;

int n;
typedef pair<int,int> PII;
const int N=1010;
int st[N][N],w[N][N];
PII f[N][N];
int x[4]={1,0,0,-1};
int y[4]={0,1,-1,0};

void to(int i,int j)
{
    PII t=f[i][j];
    int tx=t.first,ty=t.second;
    if(!(tx==i&&ty==j))to(tx,ty);
    cout<<i<<" "<<j<<endl;
}
int main()
{
    cin>>n;
    
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            cin>>w[i][j];
    
    queue<PII>q;
    q.push({0,0});
    st[0][0]=1;

    
    while(q.size())
    {
        PII t=q.front();
        q.pop();
        int tx=t.first,ty=t.second;
        if(tx==n-1&&ty==n-1)break;
        
        for(int i=0;i<4;i++)
        {
            int nx=tx+x[i],ny=ty+y[i];
            
            if(nx<0||ny<0||nx>=n||ny>=n||st[nx][ny]||w[nx][ny])continue;
            
            q.push({nx,ny});
            st[nx][ny]=1;
            f[nx][ny]={tx,ty};
        }
    }
    
    to(n-1,n-1);
    return 0;
}

多源 BFS

  • 直接把所有起点放入队列即可
  • 可以假设一个虚拟起点，虚拟起点到所有起点的边权为 0，从虚拟起点出发即可；

最小步数模型

  • 将图当前状态当成一个点，给定最终的状态，求最少的步数能够达到最终状态
  • 状态用哈希表存储

双端队列广搜

  • 对于具有边权为 0 和 1 的图，将当前边权为 1 的路径放入队尾，边权为 0 的放入队头 双向广搜
  • 主要使用在最小步数模型
  • 从起点和终点开始 bfs，用两个队列进行 bfs，同时把两边的遍历的状态和步数用哈希表储存
  • 每次选择队列里元素最小的队列进行以层 bfs（每次 bfs 必须更新完整的一层才能确保最小步数的正确性）

A*

  • 引用在搜索空间非常大的情况
  • 优先队列存储，排序方式： 从起点到当前点的真实距离+从当前点到终点的估计距离
  • 只要保证估计距离一定小于其到终点的真实距离且大于等于 0，那当终点第一次出队的时候，其距离一定为最短距离
  • 只能保证终点路径上的点是最优解

DFS

连通性模型

  • 与 Flood Fill 算法使用场景一样，只不过用 dfs 来连通

搜索顺序

  • 考虑一个搜索顺序使得能够搜索所有的状态

剪枝与优化

  • 提前将搜索树的一些方案剪去，减少搜索分支
  1. 优化搜索顺序：大部分情况，应该优先搜索分支较少的节点(一般考虑从大到小搜索)
  2. 排除等效冗余：对于无顺序问题，尽量用组合方式搜索，减少重复(同一组无顺序情况，可以继承上一个节点搜索的位置）
  3. 可行性剪枝：当前状态不合法直接退出
  4. 最优性剪枝：当前问题已经不是最优解直接退出
  5. 记忆化搜索（DP）

迭代加深

  • 对于 dfs，当搜索树的某些分支特别的深，但实际上最终解在特别浅的位置时，使用迭代加深
  • 设置一个 max-depth，对于超过搜索超过 max-depth 的部分，先剪枝掉
  • 如果最后在当前的 max-depth 里没有解，那就继续扩展 max-depth while(dfs(k))k++;

双向 DFS

  • 折半搜索，先搜索前一半（k）的所有情况并且储存起来，在对后一半（N-k）的情况进行搜索并查表前一半的所有情况
  • 总的复杂度是 2^k+2^（N-k）*k；

IDA*

  • 与迭代加深一起使用
  • 如果当前的状态到达最终解的状态的估计答案已经超过了 max-depth，先将其剪枝
  • 估计值一定要小于真实值

图论

树与图的存储

  • 树是一种特殊的图，与图的存储方式相同。
  • 对于无向图中的边 a - b，存储两条有向边 a->b， b->a。
  • 因此我们可以只考虑有向图的存储。
  • 稠密图用领接矩阵来存，稀疏图用领接表

邻接矩阵

g[a][b] 存储边 a->b

邻接表

// 对于每个点k，开一个单链表，存储k所有可以走到的点。h[k]存储这个单链表的头结点
int h[N], e[N], ne[N], idx;

// 添加一条边a->b
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

// 初始化
idx = 0;
memset(h, -1, sizeof h);


vector<int>s[N];

void add(int a,int b)
{
    s[a].push_back(b);
}

树与图的遍历

  • 时间复杂度 O（n+m）， n 表示点数，m 表示边数

深度优先遍历

void dfs(int u)
{
    st[u] = true; // st[u] 表示点u已经被遍历过

    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j]) dfs(j);
    }
}

void dfs(int u)
{
    st[u] = true; // st[u] 表示点u已经被遍历过

    for (int i=0;i<s.size();i+)
    {
        if (!st[s[i]) dfs(s[i]);
    }
}

宽度优先遍历

queue<int> q;
st[1] = true; // 表示1号点已经被遍历过
q.push(1);

while (q.size())
{
    int t = q.front();
    q.pop();

    for (int i = h[t]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])
        {
            st[j] = true; // 表示点j已经被遍历过
            q.push(j);
        }  
    }
}

拓扑排序

  • 时间复杂度 O（n+m）， n 表示点数，m 表示边数
  1. 入度为 0 的点入队
  2. bfs 弹出队头 t，删除 t->j 的边，如果 j 的入度为 0，j 入队
  • 一个有效无环图，一定存在一个入度为 0 的点
bool topsort()
{
    int hh = 0, tt = -1;

    //d[i] 存储点i的入度，存入度数量
    for (int i = 1; i <= n; i ++ )//1
        if (!d[i])
            q[ ++ tt] = i;

    while (hh <= tt)
    {
        int t = q[hh ++ ];

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (-- d[j] == 0)
                q[ ++ tt] = j;
        }
    }

    // 如果所有点都入队了，说明存在拓扑序列；否则不存在拓扑序列。
    return tt == n - 1;
}

最短路

  • 单源最短路
    • 所有边的权重都是正数
      • 稠密图（m 与 n^2 一个级别）：朴素 DIjkstra O（n^2）
      • 稀疏图（m 与 n 一个级别）：堆优化 Dijkstra O（mlogn）
      • 点少，对应的就是稠密图，显然易见，稠密图的路径太多了，所以就用点来找，也就是把所有点到 1 号点的距离都比一遍；
      • 点很多，但是连线不是很多的时候，对应的就是稀疏图，稀疏图的路径不多，所以按照连接路径找最短路，这个过程运用优先队列，能确保每一次查找保留到更新到队列里的都是最小的，同时还解决了两个点多条路选择最短路的问题；
    • 存在负权边
      • 有边数限制的情况下只能用 Bellman-Ford
      • Bellman-Ford O(nm)
      • SPFA 一般：O（m） 最坏：O（nm）
  • 多源汇最短路
    • Floyd O(n^3)

朴素 dijkstra

  1. dist[ 1 ]=0,dist[ k ]= + 00
  2. 在还未确定最短路的点中，寻找距离最小的点 t
  3. 用 t 更新其他点的距离
  4. 从 t 出度的所有点都更新后，把 t 标为以确定
  • 时间复杂是 O（n^2+m）， n 表示点数，m 表示边数
    • 寻找路径最短的点：O（n^2）
    • 加入集合 S： O（n）
    • 更新距离：O（m）
    • 所以总的时间复杂度为 O（n^2+m）
  • 在没有负权边的情况下，每多经过一条边，就会增加距离，所以当前离节点中最短距离的点，是无法通过经过更多的点来减小距离，所以确定的点到 1 的距离是一定正确的
  • 所以，如果他是当前到 1 号点最短距离，那他就一定是最短路，拿他更新以他出度的所有点，然后标记他确定最短路
int g[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{ 
    //1
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    //不超过k条边，到每个点的最短距离，n个点最多走n-1条边
    for (int i = 0; i < n - 1 ; i ++ )
    {
        int t = -1;     // 2
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        // 3
        for (int j = 1; j <= n; j ++ )
            if(g[t][j])
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        //4
        st[t] = true;
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

堆优化版 dijkstra

  • 时间复杂是 O（mlogn）， n 表示点数，m 表示边数
    • 寻找路径最短的点：O（n）
    • 加入集合 S： O（n）
    • 更新距离：O（mlogn）
  1. dist[ 1 ]=0,dist[ k ]= + 00
  2. 在还未确定最短路的点中，寻找距离最小的点 t（堆优化）
  3. 因为在弹出 t 点之前，可能会有好几个点都更新了 t 的距离，只选最短的那个，剩下的标 true 后舍弃
  4. 用 t 的距离更新所有能去的点的距离，如果更新成功，就把更新的点加入到队列
typedef pair<int, int> PII;

int n;      // 点的数量
//w[]存权重
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边,

int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
    //1
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});      // first存储距离，second存储节点编号

    while (heap.size())
    {
        //2
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;//3
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])//4
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            { 
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

Bellman-Ford

  1. 迭代 n 次
  2. 遍历所有边 1. 更新所有的点到 1 号点的距离
  • Bellman-Foed 算法与 dijkstra 的区别在于，由于出现了负权边，在不遍历完所有点的情况下，无法确定最短路，所以要从经过一个点开始，每次更新完所有的最短路，直到遍历完全部点
  • 在明确要求限制最短路所经过的边数的情况下，需要一个 bakcup 数组来明确上一个迭代的结果 防止出现串联，每次迭代都先把 dist 复制给 backup，再开始更新 dist[b] > backup[a] + w
  • 时间复杂度 O（nm）， n 代表点数，m 表示边数
int n, m;       // n表示点数，m表示边数
int dist[N];        // dist[x]存储1到x的最短路距离
int backup[N]       //保存上一次迭代的结果，防止串联
struct Edge     // 边，a表示出点，b表示入点，w表示边的权重
{
    int a, b, w;
}edges[M];

// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    // 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，
    // 由抽屉原理，最短路路径中至少存在两个相同的点，说明图中存在负权回路。
    for (int i = 0; i < n; i ++ )//不超过k条边，到每个点的最短距离
    {
        for (int j = 0; j < m; j ++ )
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            if (dist[b] > dist[a] + w)//三角不等式
                dist[b] = dist[a] + w;//松弛操作
        }
    }

    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    return dist[n];
}

spfa

  • 队列优化的 Bellman-Ford 算法
  • 时间复杂度 平均情况下 O（m），最坏情况下 O（nm）， n 表示点数，m 表示边数 int n; // 总点数 int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N]; // 存储每个点到1号点的最短距离 bool st[N]; // 存储每个点是否在队列中
// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        auto t = q.front();
        q.pop();  

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

spfa 判断图中是否存在负环

  • 原理：如果某条最短路径上有 n 个点（除了自己），那么加上自己之后一共有 n+1 个点 由抽屉原理一定有两个点相同，所以存在环。
  • 不清楚负环是在哪个路径上的，所以所有点都以自己出发，每个点的 dist[x]=0；
  • 由于每个点都是以自己出发的，所以 dist 记录的是无法确定是哪个点到 x 点的最短距离，所以 dist[x]记录的是在某个点经过 cnt[x]个点，所用的最短距离
  • 无论怎么走，在没有负环的图的最长路径(也就是最多走n个点)一定是 1->n，所走的经过的点是 n-1 个，所以如果出现 cnt>=n，说明出现了负环
int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N], cnt[N];        
bool st[N];     // 存储每个点是否在队列中

// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
    queue<int> q;
    for (int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                // 如果能走n个点，则说明存在环
                if (cnt[j] >= n) return true;      
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}

floyd

  • 基于 dp
//初始化
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

// 算法结束后，d[a][b]表示a到b的最短距离
void floyd()
{
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

最小生成树

  • Prim
    • 稠密图：朴素 prim O（n^2）
    • 稀疏图：堆优化 prim O（mlogn） （不常用）
  • Kruskal
    • 稀疏图：O（mlogm）

Prim

  1. dist[x]=INF
  2. 迭代 n 次
    1. 找到集合外距离最近的点，并加入集合
    2. 用 t 更新其他点到集合 的距离
    3. st[t]=true
  • 集合的第一个 点随便取
  • 有可能出现负自环，所以要先进行res+=dist[t]再更新其他点
int n;      // n表示点数
int g[N][N];        // 邻接矩阵，存储所有边
int dist[N];        // 存储其他点到当前最小生成树的距离
bool st[N];     // 存储每个点是否已经在生成树中


// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim()
{
    memset(dist, 0x3f, sizeof dist);

    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        if (i && dist[t] == INF) return INF;//一开始集合为空，不判断

        if (i) res += dist[t]; 
        st[t] = true;

        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
    }

    return res;
}

Kruskal

  1. 将所有边按权重从小到大排序 O（mlogm）
  2. 枚举每条边 a->b，权重是 c
    1. a，b 不连通，将这条边加入集合中
int n, m;       // n是点数，m是边数
int p[N];       // 并查集的父节点数组

struct Edge     // 存储边
{
    int a, b, w;

    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[M];

int find(int x)     // 并查集核心操作
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int kruskal()
{
    sort(edges, edges + m);

    for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集

    int res = 0, cnt = 0;
    for (int i = 0; i < m; i ++ )
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        a = find(a), b = find(b);
        if (a != b)     // 如果两个连通块不连通，则将这两个连通块合并
        {
            p[a] = b;
            res += w;
            cnt ++ ;
        }
    }

    if (cnt < n - 1) return INF;
    return res;
}

二分图

  • 二分图：把图上所有点分为两个集合，集合内的点无边相连
    • 二分图的图中不含有奇数环
    • 没有奇数环的一定是二分图
  • 染色法
    • O(n+m)
  • 匈牙利算法
    • O（mn），实际运行时间远小于 O（mn）

染色法

int n;      // n表示点数
int h[N], e[M], ne[M], idx;     // 邻接表存储图
int color[N];       // 表示每个点的颜色，-1表示未染色，0表示白色，1表示黑色

// 参数：u表示当前节点，c表示当前点的颜色
bool dfs(int u, int c)
{
    color[u] = c;
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (color[j] == -1)
        {
            if (!dfs(j, !c)) return false;
        }
        else if (color[j] == c) return false;
    }

    return true;
}

bool check()
{
    memset(color, -1, sizeof color);
    bool flag = true;
    for (int i = 1; i <= n; i ++ )
        if (color[i] == -1)
            if (!dfs(i, 0))
            {
                flag = false;
                break;
            }
    return flag;
}

匈牙利算法

  • 真·绿帽算法
  • 寻找二分图的最大匹配数
  • 时间复杂度是 O（nm）， n 表示点数，m 表示边数
int n1, n2;     // n1表示第一个集合中的点数，n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx;     // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
int match[N];       // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
bool st[N];     // 表示第二个集合中的每个点是否已经被遍历过

bool find(int x)
{ 
    for (int i = h[x]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])
        {
            st[j] = true;
            //第二个集合没有匹配，或者已匹配的第一集合的点可以找到另外的第二集合点
            if (match[j] == 0 || find(match[j])
            {
                match[j] = x;
                return true;
            }
        }
    }

    return false;
}

// 求最大匹配数，依次枚举第一个集合中的每个点能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n1; i ++ )
{
    memset(st, false, sizeof st); 
    if (find(i)) res ++ ;
}

最近公共祖先

向上标记法 O（n）

  • 先从一个点向根节点遍历，将途径的所有点标记
  • 另一个点开始向根节点遍历，遇到第一个标记的点为最近公共祖先

倍增

  • fa[i,j]表示从i开始，向上走2^j步能走到的节点 0<= j <=log n
    • 对于fa[i,j],fa[i,j]=fa[[i,j-1],j-1]，2^6=2^5*2，所以从小到大，层数从高到低更新fa满足拓扑序
  • depth[i]表示深度
  • 步骤：
    1. 先将两个点跳到同一层
    2. 让两个点同时往上跳，一直跳到它们公共祖先的下一层
      • 对于两步骤，应该从大到小枚举步数，使得最后结果正确；
  • 预处理 O（nlogn）
  • 查询 O（logn）
#include<bits/stdc++.h>

using namespace std;

const int N=40010;
vector<int> s[N];
int fa[N][16],depth[N];

void add(int a,int b)
{
    s[a].push_back(b);
}
void bfs(int u)
{
    memset(depth,0x3f,sizeof depth);
    depth[u]=1,depth[0]=0;//跳出树根节点点为0，层数是0，根节点层数为1；
    
    queue<int>q;
    q.push(u);
    while(q.size())
    {
        int root=q.front();
        q.pop();
        for(int i=0;i<s[root].size();i++)
        {
            int t=s[root][i];
            if(depth[t]>depth[root]+1)
            {
                depth[t]=depth[root]+1;
                fa[t][0]=root;
                
                q.push(t);
                
                for(int i=1;i<=15;i++)
                    fa[t][i]=fa[fa[t][i-1]][i-1];
            }
        }
    }
}

int  lca(int a,int b)
{
    if(depth[b]<depth[a])swap(a,b);
    
    for(int i=15;i>=0;i--)
        if(depth[fa[b][i]]>=depth[a])b=fa[b][i];
        
    if(a==b)return a;
    
    for(int i=15;i>=0;i--)
    {
        if(fa[a][i]!=fa[b][i])
        {
            a=fa[a][i];
            b=fa[b][i];
        }
    }
    return fa[a][0];
}

int main()
{
    int n,m,root;
    cin>>n;
    
    for(int i=0;i<n;i++)
    {
        int a,b;
        cin>>a>>b;
        if(b==-1)root=a;
        else add(a,b),add(b,a);
    }
    
    bfs(root);
    
    cin>>m;
    
    for(int i=0;i<m;i++)
    {
        int a,b;
        cin>>a>>b;
        int t=lca(a,b);
        if(t==a)cout<<1<<endl;
        else if(t==b)cout<<2<<endl;
        else cout<<0<<endl;
    }
    return 0;
}

Tarjan

  • 离线求 LCA O(n+m）
  • 在 dfs 时，将所有的点分为三大类
    1. 已经遍历过，且回溯的点 （标记为 2）
    2. 正在搜索的点 （标记为 1）
    3. 还未搜索的点 （标记为 0）
  1. 在搜索回溯时，把已经搜索过的点用并查集合并，则最终会合并到正在搜索的分支上
  2. 对于正在搜索的点，看标记为 2 的点和 标记为 0 的点是否有查询有最近公共祖先，如果有那标记为 2 的点的 并查集的祖先则是这两点的最近公共祖先
#include<bits/stdc++.h>

using namespace std;

const int N=40010;
typedef pair<int,int> PII;
vector<int> s[N];//tree

vector<PII> f[N];//查询
PII q[N];

int p[N]; //并查集
int ans[N];//答案
int st[N];
int find(int x)
{
    if(p[x]!=x)p[x]=find(p[x]);
    return p[x];
}

void add(int a,int b)
{
    s[a].push_back(b);
}

void tarjan(int u)
{
    st[u]=1;//正在搜索的点标记为1
    
    for(int i=0;i<s[u].size();i++)
    {
        int t=s[u][i];
        if(!st[t])
        {
            tarjan(t);
            p[t]=u;//已经回溯的进并查集
        }
    }
    
    for(auto k:f[u])
    {
        int t=k.first,id=k.second;
        if(st[t]==2)ans[id]=find(t);
    }
    st[u]=2;//回溯点标记为2
}
int main()
{
    int n,root,m;
    cin>>n;
    
    for(int i=0;i<n;i++)
    {
        int a,b;
        cin>>a>>b;
        if(b==-1)root=a;
        else add(a,b),add(b,a);
    }
    
    cin>>m;
    for(int i=1;i<=m;i++)
    {
        int a,b;
        cin>>a>>b;
        f[a].push_back({b,i});
        f[b].push_back({a,i});
        q[i]={a,b};
    }
    
    for(int i=0;i<N;i++)p[i]=i;
    
    tarjan(root);
    for(int i=1;i<=m;i++)
    {
        if(ans[i]==q[i].first)cout<<1<<endl;
        else if(ans[i]==q[i].second)cout<<2<<endl;
        else cout<<0<<endl;
    }
    return 0;
}
avatar
文章
阅读
粉丝