C Programming: Strongly Connected Components 🎯

Welcome to this comprehensive guide on C Programming's Strongly Connected Components (SCC)! This lesson is designed for beginners and intermediate learners, aiming to explain the concept from the ground up. Let's dive in!

What are Strongly Connected Components? 📝

Strongly Connected Components (SCC) are a set of vertices in a directed graph that are reachable from each other. In other words, if we have a directed graph, SCCs are the subgraphs where you can reach any vertex from any other vertex, regardless of the direction of the edges.

Why are Strongly Connected Components important? 💡

SCCs have numerous applications in various domains, including computer science, artificial intelligence, and network analysis. They help in understanding the structure of the graph better, finding cycles, and even solving problems like scheduling tasks and managing dependencies.

Understanding the C Programming Approach 📝

In C programming, we will use Depth-First Search (DFS) algorithm to find the Strongly Connected Components. DFS helps explore the graph by visiting as far as possible along each branch before backtracking.

Prerequisites 📝

Before diving into the code, make sure you have a good understanding of the following topics:

Basics of C programming
Data Structures: Stack and Array
Graph Algorithms: Depth-First Search (DFS)

Coding Strongly Connected Components 🎯

Now, let's write a C program to find the Strongly Connected Components of a given directed graph.

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

#define MAX_VERTS 100

int visited[MAX_VERTS];
int stack[MAX_VERTS];
int component = 0;

void DFS(int vertex, int adjacency_list[][MAX_VERTS], int num_verts) {
    visited[vertex] = true;
    stack[component * MAX_VERTS + vertex] = vertex;

    for (int i = 0; i < num_verts; ++i) {
        if (adjacency_list[vertex][i] && !visited[i]) {
            DFS(i, adjacency_list, num_verts);
        }
    }
}

void SCC(int adjacency_list[][MAX_VERTS], int num_verts) {
    for (int i = 0; i < num_verts; ++i) {
        if (!visited[i]) {
            DFS(i, adjacency_list, num_verts);
            ++component;
        }
    }
}

void print_SCC(int adjacency_list[][MAX_VERTS], int num_verts) {
    SCC(adjacency_list, num_verts);

    for (int i = 0; i < component; ++i) {
        printf("SCC %d:", i + 1);

        int top = component * MAX_VERTS - 1;
        while (top >= 0) {
            int vertex = stack[top--];
            if (i * MAX_VERTS <= vertex && vertex < (i + 1) * MAX_VERTS)
                printf(" %d", vertex);
        }
        printf("\n");
    }
}

int main() {
    int num_verts = 6;
    int adjacency_list[MAX_VERTS][MAX_VERTS] = {
        {0, 1, 0, 0, 0, 0},
        {1, 0, 1, 0, 0, 0},
        {0, 0, 0, 1, 0, 0},
        {0, 0, 0, 0, 1, 0},
        {0, 0, 0, 0, 0, 1},
        {0, 0, 0, 0, 0, 0}
    };

    print_SCC(adjacency_list, num_verts);

    return 0;
}

📝 Note: The given code initializes an adjacency list representing a directed graph and performs Depth-First Search to find the Strongly Connected Components.

Test Your Knowledge 🎯

That's it for this lesson! With a good understanding of Strongly Connected Components and the C Programming approach, you're well on your way to mastering graph algorithms. Happy coding! 💡