Точки сочленения. Компоненты вершинной двусвязности: различия между версиями

Материал из Олимпиадное программирование в УлГТУ
Перейти к навигации Перейти к поиску
Нет описания правки
Нет описания правки
 
Строка 2: Строка 2:
* Вершина <tt>v</tt> является точкой сочленения, если у неё имеется хотя бы один такой потомок to, что из поддерева этого потомка в дереве обхода в глубину нет обратных рёбер в предков вершины v (<tt>upDepth[to] >= depth[v]</tt>).
* Вершина <tt>v</tt> является точкой сочленения, если у неё имеется хотя бы один такой потомок to, что из поддерева этого потомка в дереве обхода в глубину нет обратных рёбер в предков вершины v (<tt>upDepth[to] >= depth[v]</tt>).
* Корень дерева обхода в глубину (<tt>parent == -1</tt>) является точкой сочленения тогда и только тогда, когда у него более одного непосредственного потомка.
* Корень дерева обхода в глубину (<tt>parent == -1</tt>) является точкой сочленения тогда и только тогда, когда у него более одного непосредственного потомка.
* Одна и та же вершина может быть признана точкой сочленения несколько раз, поэтому результат следует складывать в множество, а не в вектор.


  struct Graph {
  struct Graph {
     vector<vector<int>> g;
     vector<vector<int>> graph;
     vector<int> visited, depth, upDepth;
     vector<int> visited, depth, upDepth;
     vector<int> cutpoints;
     set<int> cutpoints;
     void dfs(int v, int p) {
     void dfs(int v, int p) {
         visited[v] = 1;
         visited[v] = 1;
Строка 14: Строка 15:
         int childrenCount = 0;
         int childrenCount = 0;
   
   
         for (int to : g[v]) {
         for (int to : graph[v]) {
             if (to == p) {
             if (to == p) {
                 continue;
                 continue;
Строка 22: Строка 23:
                 upDepth[v] = min(upDepth[v], upDepth[to]);
                 upDepth[v] = min(upDepth[v], upDepth[to]);
                 if (p != -1 && upDepth[to] >= depth[v])
                 if (p != -1 && upDepth[to] >= depth[v])
                     cutpoints.push_back(v);
                     cutpoints.insert(v);
             } else {
             } else {
                 upDepth[v] = min(upDepth[v], depth[to]);
                 upDepth[v] = min(upDepth[v], depth[to]);
Строка 29: Строка 30:
   
   
         if (p == -1 && childrenCount > 1)
         if (p == -1 && childrenCount > 1)
             cutpoints.push_back(v);
             cutpoints.insert(v);
     }
     }
   
   
     Graph(int vertexCount) {
     Graph(int vertexCount) :
         g.resize(vertexCount);
         graph(vertexCount), visited(vertexCount), depth(vertexCount), upDepth(vertexCount) {}
        visited.resize(vertexCount);
        depth.resize(vertexCount);
        upDepth.resize(vertexCount);
    }
   
   
     void addEdge(int a, int b) {
     void addEdge(int a, int b) {
         g[a].push_back(b);
         graph[a].push_back(b);
         g[b].push_back(a);
         graph[b].push_back(a);
     }
     }
   
   
     vector<int> findCutpoints() {
     set<int> getCutpoints() {
         for (int v = 0; v < g.size(); v++)
         for (int v = 0; v < graph.size(); v++)
             if (!visited[v])
             if (!visited[v])
                 dfs(v, -1);
                 dfs(v, -1);

Текущая версия от 12:24, 17 марта 2023

  • Для каждой вершины v будем подсчитывать глубину depth[v] и величину upDepth[v] — минимальную глубину некоторой вершины, достижимой из текущего поддерева переходом по одному обратному ребру.
  • Вершина v является точкой сочленения, если у неё имеется хотя бы один такой потомок to, что из поддерева этого потомка в дереве обхода в глубину нет обратных рёбер в предков вершины v (upDepth[to] >= depth[v]).
  • Корень дерева обхода в глубину (parent == -1) является точкой сочленения тогда и только тогда, когда у него более одного непосредственного потомка.
  • Одна и та же вершина может быть признана точкой сочленения несколько раз, поэтому результат следует складывать в множество, а не в вектор.
struct Graph {
    vector<vector<int>> graph;
    vector<int> visited, depth, upDepth;
    set<int> cutpoints;

    void dfs(int v, int p) {
        visited[v] = 1;
        depth[v] = (p == -1 ? 0 : depth[p] + 1);
        upDepth[v] = depth[v];
        int childrenCount = 0;

        for (int to : graph[v]) {
            if (to == p) {
                continue;
            } else if (!visited[to]) {
                dfs(to, v);
                childrenCount++;
                upDepth[v] = min(upDepth[v], upDepth[to]);
                if (p != -1 && upDepth[to] >= depth[v])
                    cutpoints.insert(v);
            } else {
                upDepth[v] = min(upDepth[v], depth[to]);
            }
        }

        if (p == -1 && childrenCount > 1)
            cutpoints.insert(v);
    }

    Graph(int vertexCount) :
        graph(vertexCount), visited(vertexCount), depth(vertexCount), upDepth(vertexCount) {}

    void addEdge(int a, int b) {
        graph[a].push_back(b);
        graph[b].push_back(a);
    }

    set<int> getCutpoints() {
        for (int v = 0; v < graph.size(); v++)
            if (!visited[v])
                dfs(v, -1);
        return cutpoints;
    }
};

Ссылки

Теория:

Демонстрация:

Код:

Задачи: