Brandes-algoritmus

• IPA:

Brandes-algoritmus

1. (matematika)

A Brandes-algoritmus egy hatékony módszer a gráfok központossági mérőszámainak (betweenness centrality) kiszámítására. Ezt a metrikát gyakran használják a gráfok elemzésében, hogy meghatározzák, mely csúcsok vagy élek a legfontosabbak az információáramlás szempontjából.

Egy csúcs központosságát a rajta áthaladó **legrövidebb utak** száma alapján határozzák meg: $${\displaystyle C_{B}(v)=\sum _{s\neq v\neq t}{\frac {\sigma _{st}(v)}{\sigma _{st}}}}$$ ahol: - ${\textstyle \sigma _{st}}$: Az ${\textstyle s}$-ből ${\textstyle t}$-be vezető legrövidebb utak száma, - ${\textstyle \sigma _{st}(v)}$: Az ${\textstyle s}$-ből ${\textstyle t}$-be vezető azon legrövidebb utak száma, amelyek ${\textstyle v}$-n keresztül haladnak.

Az algoritmus egy hatékony ( O(V E) )-s időkomplexitású módszer, amely elkerüli az összes csúcspár közötti legrövidebb utak explicit kiszámítását.

1. Legrövidebb utak számítása:
   • Használj egy BFS-t (nem súlyozott gráfoknál) vagy egy Dijkstra-algoritmust (súlyozott gráfoknál) minden csúcsra, hogy meghatározd a legrövidebb utak számát.
2. Z-szám kiszámítása:
   • A legrövidebb utak számának és az elődök halmazának felhasználásával számítsd ki az egyes csúcsokra ható befolyást (központosságot).
3. Központosság frissítése:
   • A legrövidebb utak számából és az elődök halmazából számítsd ki a központosság hozzájárulását minden csúcsra.

Brandes(G):
    Initialize C_B(v) = 0 for all v in V
    for s in V:
        S = üres stack
        P = üres lista minden v ∈ V
        sigma = 0 minden v ∈ V; sigma = 1
        d = -1 minden v ∈ V; d = 0
        
        # BFS vagy Dijkstra
        Q = üres sor
        Q.push(s)
        while Q nem üres:
            v = Q.pop()
            S.push(v)
            for minden szomszéd w ∈ G:
                if d < 0:
                    Q.push(w)
                    d = d + 1
                if d == d + 1:
                    sigma += sigma
                    P.append(v)
        
        delta = 0 minden v ∈ V
        while S nem üres:
            w = S.pop()
            for v in P:
                delta += (sigma / sigma) * (1 + delta)
            if w != s:
                C_B += delta
    return C_B

• Nem súlyozott gráfok: ( O(V E) ), ahol ( V ) a csúcsok száma, ( E ) az élek száma.
• Súlyozott gráfok: ( O(V (E + V V)) ), mivel minden csúcsra Dijkstra-algoritmust használunk.

Az alábbi példa egy egyszerű, nem súlyozott gráf esetén mutatja be a Brandes-algoritmust:

from collections import defaultdict, deque

def brandes(graph):
    centrality = defaultdict(float)

    for s in graph:
        # BFS előkészítése
        stack = 
        pred = {v:  for v in graph}
        sigma = dict.fromkeys(graph, 0.0)
        dist = dict.fromkeys(graph, -1)
        sigma = 1
        dist = 0

        # BFS futtatása
        queue = deque()
        while queue:
            v = queue.popleft()
            stack.append(v)
            for w in graph:
                if dist < 0:  # w még nem látogatott
                    queue.append(w)
                    dist = dist + 1
                if dist == dist + 1:  # w egy szomszédos csúcs
                    sigma += sigma
                    pred.append(v)

        # Központosság kiszámítása
        delta = dict.fromkeys(graph, 0.0)
        while stack:
            w = stack.pop()
            for v in pred:
                delta += (sigma / sigma) * (1 + delta)
            if w != s:
                centrality += delta

    return centrality

# Példa gráf
graph = {
    'A': ,
    'B': ,
    'C': ,
    'D': 
}

centrality = brandes(graph)
for node, value in centrality.items():
    print(f"{node}: {value:.2f}")

Kimenet:

A: 0.00
B: 2.00
C: 2.00
D: 0.00

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
#include <stack>

using namespace std;

void brandes(const unordered_map<int, vector<int>>& graph, unordered_map<int, double>& centrality) {
    for (auto& pair : graph) {
        int s = pair.first;
        stack<int> S;
        unordered_map<int, vector<int>> pred;
        unordered_map<int, double> sigma, delta;
        unordered_map<int, int> dist;

        for (auto& p : graph) {
            sigma = 0.0;
            delta = 0.0;
            dist = -1;
        }

        sigma = 1.0;
        dist = 0;

        queue<int> Q;
        Q.push(s);

        while (!Q.empty()) {
            int v = Q.front();
            Q.pop();
            S.push(v);

            for (int w : graph.at(v)) {
                if (dist < 0) {
                    Q.push(w);
                    dist = dist + 1;
                }
                if (dist == dist + 1) {
                    sigma += sigma;
                    pred.push_back(v);
                }
            }
        }

        while (!S.empty()) {
            int w = S.top();
            S.pop();
            for (int v : pred) {
                delta += (sigma / sigma) * (1 + delta);
            }
            if (w != s) {
                centrality += delta;
            }
        }
    }
}

int main() {
    unordered_map<int, vector<int>> graph = {
        {1, {2, 3}},
        {2, {1, 3, 4}},
        {3, {1, 2, 4}},
        {4, {2, 3}}
    };

    unordered_map<int, double> centrality;
    brandes(graph, centrality);

    for (const auto& pair : centrality) {
        cout << "Csúcs " << pair.first << ": " << pair.second << endl;
    }

    return 0;
}

Kimenet:

Csúcs 1: 0
Csúcs 2: 2
Csúcs 3: 2
Csúcs 4: 0

1. Hatékony időbonyolultság:
   • Gyorsabb, mint a naiv módszerek, különösen nagy gráfokon.
2. Támogatja a súlyozott és nem súlyozott gráfokat.

1. Nagyméretű gráfok esetén memóriaigényes:
   • A gráf reprezentációja és az algoritmus táblái jelentős memóriát igényelhetnek.
2. Bonyolult implementáció:
   • A BFS és az adatszerkezetek kezelése komplex.

1. Hálózatkutatás:
   • Kulcsfontosságú csomópontok azonosítása.
2. Szociális hálózatok elemzése:
   • Befolyásos személyek azonosítása.
3. Hálózati biztonság:
   • Kritikus hálózati pontok védelme.
4. Informatikai rendszerek:
   • Adatáramlás optimalizálása.

A Brandes-algoritmus hatékony eszköz a gráfok központosságának kiszámítására, különösen nagy és összetett hálózatok esetén. Hatékonysága és széles körű alkalmazási lehetőségei miatt alapvető eszköz a hálózatelemzésben.

• Brandes-algoritmus - Értelmező szótár (MEK)
• Brandes-algoritmus - Etimológiai szótár (UMIL)
• Brandes-algoritmus - Szótár.net (hu-hu)
• Brandes-algoritmus - DeepL (hu-de)
• Brandes-algoritmus - Яндекс (hu-ru)
• Brandes-algoritmus - Google (hu-en)
• Brandes-algoritmus - Helyesírási szótár (MTA)
• Brandes-algoritmus - Wikidata
• Brandes-algoritmus - Wikipédia (magyar)