C Kosaraju's Algorithm

Welcome to our deep dive into C Programming! Today, we'll be exploring Kosaraju's Algorithm, a powerful tool for finding the strongly connected components in a graph. Let's get started! 🎯

Understanding the Concept

Before we dive into the algorithm, let's first understand what we mean by a graph and strongly connected components.

Graph

A graph is a collection of nodes (or vertices) connected by edges. In a directed graph, the edges have a direction, meaning you can travel from one node to another but not necessarily the other way around.

Strongly Connected Components

Two nodes are said to be strongly connected if there's a path from one to the other, and a path from the other to the first, regardless of the direction of the edges. Strongly connected components are subsets of vertices where every vertex in one subset can reach every other vertex in the same subset, and no vertex in one subset can reach any vertex in another subset.

The Kosaraju's Algorithm

Now that we've established the basics, let's dive into the heart of the matter: Kosaraju's Algorithm. It works in two phases:

Forward graph: We first reverse the edges of the original graph and count the number of incoming edges for each vertex in the reversed graph. This gives us the number of strongly connected components in the original graph.
Backward graph: We then create a new graph where each vertex is connected to all the vertices it reaches in the original graph, and assign each vertex to a component based on the component it was connected to in the forward graph.

Implementation

Here's a step-by-step implementation of Kosaraju's Algorithm in C:

#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTICES 100

typedef struct {
    int vertex;
    struct edge *next;
} edge;

typedef struct {
    int visited;
    int component;
    edge *incoming;
} vertex_t;

vertex_t vertices[MAX_VERTICES];
edge edges[MAX_VERTICES * MAX_VERTICES];
int num_vertices, num_edges;

void add_edge(int u, int v) {
    edge *e = &edges[num_edges];
    e->vertex = v;
    e->next = vertices[u].incoming;
    vertices[u].incoming = e;
}

void reverse_graph() {
    for (int i = 0; i < num_vertices; ++i) {
        edge *e = vertices[i].incoming;
        vertex_t *v = &vertices[i];
        v->visited = 0;
        while (e != NULL) {
            int j = e->vertex;
            edge *tmp = e;
            e = e->next;
            vertices[j].outgoing = (edge *)realloc(vertices[j].outgoing, sizeof(edge) * (1 + v->component));
            vertices[j].outgoing[v->component] = tmp;
        }
        v->outgoing[v->component] = NULL;
    }
}

int strongly_connected_components() {
    int components = 0;
    for (int i = 0; i < num_vertices; ++i) {
        if (!vertices[i].visited) {
            dfs(i, -1);
            ++components;
        }
    }
    return components;
}

void dfs(int current, int parent) {
    vertex_t *v = &vertices[current];
    v->visited = 1;
    v->component = components;

    edge *e = v->incoming;
    while (e != NULL) {
        int j = e->vertex;
        if (!vertices[j].visited) {
            dfs(j, current);
        }
        e = e->next;
    }

    vertex_t *w;
    for (w = &vertices[0]; w < &vertices[num_vertices]; ++w) {
        if (w->component == 0 && v->outgoing != NULL) {
            for (edge *e = v->outgoing; e != NULL; e = e->next) {
                if (e->vertex == w->vertex) {
                    dfs(w->vertex, current);
                    break;
                }
            }
        }
    }
}

📝 Note: This implementation assumes that the graph is represented as an adjacency list, with each edge pointing from the vertex it is incident on to the vertex it points to.

Real-world Applications

Kosaraju's Algorithm finds practical applications in many areas, including:

Dependency analysis in software projects
Analyzing social networks
Solving systems of linear equations

Quiz

That's it for today! We've covered the basics of Kosaraju's Algorithm and its implementation in C. With practice, you'll be able to apply this powerful tool to real-world problems. Keep coding and happy learning! 💡