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

Материал из Олимпиадное программирование в УлГТУ
Перейти к навигации Перейти к поиску
 
Строка 3: Строка 3:
 
* Корень дерева обхода в глубину (<tt>parent == -1</tt>) является точкой сочленения тогда и только тогда, когда у него более одного непосредственного потомка.
 
* Корень дерева обхода в глубину (<tt>parent == -1</tt>) является точкой сочленения тогда и только тогда, когда у него более одного непосредственного потомка.
  
  vector<vector<int>> graph(vertexCount);
+
  struct Graph {
vector<bool> visited(vertexCount);
+
    vector<vector<int>> g;
vector<int> depth(vertexCount); // глубина вершины в дереве обхода
+
    vector<int> visited, depth, upDepth;
vector<int> upDepth(vertexCount); // насколько высоко можно добраться из поддерева вершины, пройдя 1 раз по обратному ребру
+
    vector<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;
 
   
 
   
void dfs(int v, int parent) {
+
        for (int to : g[v]) {
    visited[v] = 1;
+
            if (to == p) {
    depth[v] = (parent == -1 ? 0 : depth[parent] + 1);
+
                continue;
    upDepth[v] = depth[v];
+
            } else if (!visited[to]) {
    int childrenCount = 0;
+
                dfs(to, v);
 +
                childrenCount++;
 +
                upDepth[v] = min(upDepth[v], upDepth[to]);
 +
                if (p != -1 && upDepth[to] >= depth[v])
 +
                    cutpoints.push_back(v);
 +
            } else {
 +
                upDepth[v] = min(upDepth[v], depth[to]);
 +
            }
 +
        }
 +
 +
        if (p == -1 && childrenCount > 1)
 +
            cutpoints.push_back(v);
 +
    }
 
   
 
   
     for (int to : graph[v]) {
+
     Graph(int vertexCount) {
         if (to == parent) {
+
         g.resize(vertexCount);
            continue;
+
         visited.resize(vertexCount);
         } else if (!visited[to]) {
+
        depth.resize(vertexCount);
            dfs(to, v);
+
         upDepth.resize(vertexCount);
            childrenCount++;
 
            upDepth[v] = min(upDepth[v], upDepth[to]);
 
            if (parent != -1 && upDepth[to] >= depth[v])
 
                /* v - точка сочленения */;
 
         } else {
 
            upDepth[v] = min(upDepth[v], depth[to]);
 
        }
 
 
     }
 
     }
 
   
 
   
     if (parent == -1 && childrenCount > 1)
+
     void addEdge(int a, int b) {
         /* v - точка сочленения */;
+
         g[a].push_back(b);
}
+
        g[b].push_back(a);
 +
    }
 
   
 
   
for (int v = 0; v < vertexCount; v++)
+
    vector<int> findCutpoints() {
    if (!visited[v])
+
        for (int v = 0; v < g.size(); v++)
        dfs(v, -1);
+
            if (!visited[v])
 +
                dfs(v, -1);
 +
        return cutpoints;
 +
    }
 +
};
  
 
== Ссылки ==
 
== Ссылки ==

Текущая версия на 18:47, 4 июня 2021

  • Для каждой вершины v будем подсчитывать глубину depth[v] и величину upDepth[v] — минимальную глубину некоторой вершины, достижимой из текущего поддерева переходом по одному обратному ребру.
  • Вершина v является точкой сочленения, если у неё имеется хотя бы один такой потомок to, что из поддерева этого потомка в дереве обхода в глубину нет обратных рёбер в предков вершины v (upDepth[to] >= depth[v]).
  • Корень дерева обхода в глубину (parent == -1) является точкой сочленения тогда и только тогда, когда у него более одного непосредственного потомка.
struct Graph {
    vector<vector<int>> g;
    vector<int> visited, depth, upDepth;
    vector<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 : g[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.push_back(v);
            } else {
                upDepth[v] = min(upDepth[v], depth[to]);
            }
        }

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

    Graph(int vertexCount) {
        g.resize(vertexCount);
        visited.resize(vertexCount);
        depth.resize(vertexCount);
        upDepth.resize(vertexCount);
    }

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

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

Ссылки

Теория:

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

Код:

Задачи: