This was the time when code was shared using a sacred object known as the Pen Drive.

The Plastic Era of Code Sharing

If you’re wondering how code was shared using a pendrive, it’s exactly like managing a group PPT submission in college. You’ve seen these filenames:

• Final_PPT

• Final_submission_ppt

• final_submission_latest.ppt

• final_REAL_submission_v2.ppt

Most of the time, the only actual change was the theme color from blue to orange. Yet somehow, we had ten “versions” of the same file.

That was version control. Sort of. If you squint hard enough.

How the Pendrive Workflow Actually Worked

The process was dead simple:

1. Write code on your machine

2. Copy it to a pendrive

3. Hand the pendrive to another developer

4. They make changes

5. Copy it back

That pendrive became the single source of truth. Whoever had it owned reality.

This system looked cute and cooperative until someone said:

“Why did you make changes in this file when I was working on it?”

When Things Started Breaking

Imagine this scenario.

• dev_1 is building Feature A and creates lib/utils.ts for some helper functions.

• dev_3 is building Feature C, completely unrelated.

• Irony hits. Both need a utility function.

• Both create lib/utils.ts.

• Both even name the function the same.

• Output interfaces differ slightly.

Now merge those changes using a pendrive.

Congratulations, you’ve unlocked confusion.

Now multiply this problem across 60% of your codebase.

At this point:

• You don’t know who wrote the function

• You don’t know where it’s used

• You don’t know which version is correct

• You don’t know who to blame

Peak productivity.

Why the Pendrive Was the Problem

The pendrive wasn’t evil. It was just extremely bad at its job.

Some core issues:

• Only one person could work at a time to avoid conflicts

• Development speed was painfully slow

• No credibility. Who wrote what? Who fixed what?

• No history. Once something broke, it broke permanently

• No version control, just vibes and backups

You might think, “Why not use final_v1, final_v2, etc.?”

Sure. But even a tiny change, like updating a theme color, required duplicating the entire project. Storage got wasted fast. Mental sanity even faster.

The First Obvious Fix: The Cloud

Next logical step: remove the physical object.

Instead of a pendrive:

• Store code on the cloud

• Developers download, modify, and upload again

This solved physical dependency, but not much else.

Problems still remained:

• Logs were weak or manual

• Versioning still meant duplicates

• Storage costs increased

• Collaboration conflicts still happened

So close. Still bad.

Enter Version Control Systems

Eventually, developers got tired of this nonsense and did what developers do best: build a system to fix it.

Version Control Systems (VCS) solved multiple problems at once:

• Track who changed what

• Maintain complete history

• Optimize storage

• Enable real collaboration

• Allow safe merging, even on the same file

Version control stopped being optional. It became mandatory for any serious software.

Merge conflicts still hurt, but now they’re like a bad breakfast. Annoying, survivable, and not career-ending.

How Version Control Actually Solves the Issues

1. A Clear Mechanism
   Files are organized and tracked systematically.

2. Collaboration and Credibility
   Developers work on branches. Every change has an owner.

3. Space Optimization
   Only changed files are stored as new versions. Everything else is referenced.

No unnecessary duplication. No guessing games.

Types of Version Control Systems

• Local Version Control Systems (LVCS)
  Changes are stored locally as patches on one machine.

• Centralized Version Control Systems (CVCS)
  One central server holds the repository. Developers check out and commit changes.

• Distributed Version Control Systems (DVCS)
  Every developer clones the full repository with complete history. This is where Git lives.

Conclusion

Version control exists because copying files is not collaboration.

The pendrive era taught developers a painful lesson:
code needs memory, ownership, and structure.

It all began with one random thought while I was procrastinating a deployment. I was sitting there wondering — is 512 MB of storage from Supabase or NeonDB’s free tier really enough for my project? Or should I host my own Postgres database on a VPS?

I had $200 worth of GitHub Student credits sitting in DigitalOcean, so that option was tempting. But then reality hit: what about security? Backups? If I self-hosted, I’d have to spin up the database manually, handle access rules, and somehow manage visualization too. Which meant firing up npx prisma studio every time after pasting the connection string into an .env file. Pain.

That’s when the lightbulb moment hit , why not build my own database provider platform? One place where I could spin up databases, manage IP rules, automate backups, and maybe even handle data visualization , all from a clean web interface. It sounded overkill at first, but also kind of fun.

Then the doubt crept in: is this even possible for me to build? am I good enough for that?

And that’s exactly how DataBridge was born: out of hesitation, caffeine, and curiosity.

Now let’s talk about how it evolved : the thought process, the challenges, and the very questionable decisions that somehow worked.

Project Skeleton and Architecture Initialization

Everything starts from a template. You first set up the basic utilities you know you’ll need before getting into the actual business logic. That’s exactly what I did.

For the backend, I started by setting up an Express app and attaching tRPC to it. Later, I integrated Passport.js for GitHub OAuth. After that, I configured middlewares for both Express and tRPC so authenticated routes would work smoothly.

I also extended the codebase to include a few base classes. One handled standardized responses for both Express and tRPC, so I could maintain a consistent response structure across the project. Another handled custom error classes, keeping error management predictable and debugging less painful later.

On the frontend side, I kept things simple. Just a clean layout with a sidebar and a Zustand store to maintain the user state. Nothing flashy yet, just enough to get the system moving.

Then came the more interesting part , the project-based database instance architecture.
Every time a user created a new project on my platform, I used a superuser credential to spin up a new PostgreSQL database. Each one came with a randomly generated username (unique per project) and a completely random password.

At this point, I had a small concern. If a user got their connection string, they might use it to spin up another database manually, which could cause issues. To prevent that, I added a simple clause to the PostgreSQL query: NOCREATEDB. This made sure users couldn’t create new databases on their own.

That felt like a solid fix… for a few minutes. Then I realized another problem.
In development mode, whenever Prisma applies schema changes, it creates a shadow database to track migrations. Since my project users didn’t have CREATEDB permission, Prisma immediately failed.

So I had to remove the NOCREATEDB restriction in development mode. It wasn’t ideal, but it let me move forward and keep building. I noted it down as something to revisit once the core system was stable.

Enabling Search, Batch Update, and Delete on Tables

I spent the next two days deep in PostgreSQL queries. The goal was to give users not just table visualization, but also the ability to perform full CRUD operations on their data. Every proper DBaaS does that, and I wanted DataBridge to feel complete.

So I decided to mimic that behavior. The idea was simple: for each table, I’d track its primary key, mark that column as non-editable, and allow users to modify only the other columns.

For example, suppose there’s a table called user with columns id, name, email, and age.
If a user wanted to update the name, I’d map the object using the primary key as the identifier and the updated values as the payload.

Here’s what it looked like in practice:

const dataToBeUpdated = {
  123456: {
    name: "Vineet"
  }
};

Using this structure, I could batch update multiple rows in one go. For each primary key, the system would map its corresponding updated data, transform it into an array, and then apply updates using a CTE (Common Table Expression).

This method made the update flow efficient and predictable while still giving users control over their table data.

After that, I also implemented the Delete functionality , allowing users to remove selected rows directly from the interface, again using the same safe query pattern.

Monitoring and Modified Access of User Databases

Live Monitoring Dashboard: https://monitoring.databridge.unknownbug.tech

Today was all about visibility. I integrated Prometheus, Loki, and Grafana into the platform to monitor everything happening inside the system, from query performance to server resource usage. The idea was to make sure I could see how every part of the infrastructure behaved under real workloads.

Until now, I was using the superuser credentials for almost every operation, including reading data from user project databases. That felt convenient but unsafe in the long run. So I changed the approach.

Now, every operation that reads or interacts with a user’s project data runs using the user’s own credentials. This separation prevents unnecessary privilege escalation and makes the system cleaner and more secure.

It was a small change in code, but a big one in design philosophy, from “make it work” to “make it reliable and accountable.”

Security 0.1 : Preventing SQL Injection

One of the first security layers I focused on was protecting the platform against SQL injection. Since most user actions , like searching, updating, or deleting rows , eventually ran raw SQL queries, it made sense to handle this properly before scaling further.

To fix this, I started using the pg-format package to parameterize every user input used in queries. Whether it was a search filter, a batch update, or a delete request, each input was sanitized and formatted safely through pg-format before execution.

This change eliminated the risk of malicious input sneaking through query strings and also made my query logic a lot cleaner. It was one of those small updates that quietly made the whole system feel more production-ready.

Security 1.0: Database Password Rotation

This was one of those features that started with a random thought and turned into a whole architecture lesson. I was thinking about how to automatically rotate database passwords every month, but I honestly had no clue how to manage recurring tasks like that without creating some messy loop or a bunch of cron jobs that would eventually break.

That’s when I stumbled into event-driven architecture and started learning about queues. It clicked instantly, queues could handle delayed jobs, retries, and scheduling without overcomplicating the main flow. So I decided to integrate it here.

Now, whenever a user creates a new project, a job is added to the queue for password rotation with a delay of 30 days.
When that delay finishes, the worker automatically triggers a password rotation using pg commands, updates the stored credentials in the system, and then pushes a new job into the same queue with another 30-day delay.

This loop keeps running forever, making sure every project gets a fresh database password every 30 days starting from its creation date. It’s all automated, secure, and event-driven — no manual work, no static schedules.

What started as a random “how the hell do I even do this” moment ended up being my first real use of event-driven design inside the platform.

Notification Management

Once the queue system was in place, it made sense to extend that logic to handle notifications too. I wanted the platform to automatically inform users about key events , like password rotations, database status changes, or upcoming deletions , without me wiring separate functions for each use case.

So I built a notification queue that manages all notifications and categorizes them by platform, such as email and discord.

And yes, I actually went ahead and implemented Discord integration by designing a custom bot for the platform. It was one of those fun side features that turned out to be surprisingly useful.

Each notification job pushed into the queue carries two key pieces of information:

1. A job name (like password_rotated, database_deleted, etc.) to identify which type of message needs to be sent.

2. An array of platform names indicating where the notification should go.

For example, when a password rotation happens, a job is inserted into the queue with something like:

{
  jobName: "password_rotated",
  platforms: ["mail", "discord"]
}

The worker picks up this job and routes it to the respective integrations. If the user has connected Discord, the message is also sent through the bot in addition to email.

This design kept the notification flow flexible and scalable , I could add new platforms later (like Slack or Telegram) without rewriting any of the core logic.

Platform Resource Optimization: Idle Database Detection

After building the core features, I started thinking about how to optimize platform resources. Databases sitting idle for weeks made no sense, they still consumed storage, memory, and compute. So I decided to automate the process of detecting and handling idle databases.

I created a cron job using the node-cron package to run daily checks. It scans all projects to see if any database has been inactive for the last 30 days. If it finds one, the platform automatically pauses that database and pushes a notification to the user through both mail and Discord by sending metadata into the notification queue.

After pausing the database, the system also inserts a new job into another queue named delete_database, this time with a delay of 7 days , basically a 7-day grace period.

When the worker eventually picks up that job, it fetches the project metadata again.
If the database is still inactive, it deletes it permanently.
If the user has resumed any activity on it during those 7 days, the deletion is skipped and the database stays active.

To make it user-friendly, I added a “Resume Database” button right on the dashboard so users can bring their paused databases back online anytime.

This feature saved both compute costs and clutter while keeping users in full control of their data , a good balance between automation and ownership.

Security 1.5: Encrypted User Database Credentials

After setting up password rotation, I realized another weak spot in the system , the database credentials themselves. Even if passwords were changing every 30 days, they were still stored in plain text at rest. That didn’t sit right with me.

So I built a small encryption service to handle credential security. It uses the AES-256-GCM algorithm to encrypt all database credentials before storing them anywhere inside the system.

Now, every time user credentials are written to the database, they’re first passed through this encryption layer. The decrypted version is only fetched at runtime, when absolutely required , for example, when establishing a database connection or performing rotation.

This way, even if someone somehow gained access to the database, all they’d see would be encrypted blobs instead of readable credentials. Simple idea, but it added a strong layer of safety without overcomplicating anything.

Database Backups

Once credentials were secured, the next step was to make sure no data was ever lost. I implemented another queue dedicated to generating database backups automatically.

Each project gets its own backup schedule starting from the day it’s created. The queue triggers a backup job every 7 days. These backups are stored for 30 days only after that, they’re automatically removed to save space.

To handle cleanup, I added a cron job that runs daily at midnight. It scans for backups older than 30 days and deletes them from the system.

On the frontend, users get a clean interface to view and download their backups directly from the dashboard.

Under the hood, each backup is generated using the pg_dump command. The dump file is stored temporarily on the server, compressed, and then uploaded to Cloudinary. I used signed URLs for secure access. Once the upload is complete, the local backup file is deleted from the server to avoid clutter.

When a user clicks “Download Backup,” the backend fetches the corresponding record, generates a temporary signed URL from Cloudinary, and returns it. That link stays valid for only 5 minutes , enough time to download, but short enough to stay safe.

It’s fully automated, lightweight, and reliable, the kind of system that just quietly works in the background while users sleep.

Security 2.0: IP Firewall Rules Per Project

This part felt like the final boss of security , IP rules. It ended up solving a bunch of platform and user issues in one go, but getting there was way harder than it looked.

The main problem was simple on paper: I wanted to let users whitelist IP addresses for their individual databases. The catch? Postgres doesn’t support per-database IP restrictions out of the box. If I restricted the entire server to one IP, no one else would be able to access their databases.

That sent me digging through Postgres docs until I discovered the pg_hba.conf file , the core file that controls host-based authentication. If I could edit it dynamically, I could configure custom IP rules for each user project directly from there.

At first, it wasn’t that easy. I was already using a Docker volume mounted at /var/lib/postgres/data to persist database data between container restarts. Luckily, that’s also where pg_hba.conf lives. My first idea was to mount another volume to copy an updated version of the file there, but the data volume kept overwriting it.

I needed both volumes , one for the main database data and another for the dynamic configuration , to coexist without stepping on each other. The breakthrough came when I realized I could modify the postgresql.conf file to change the reference path for pg_hba.conf.

So I reconfigured Postgres to look for it in /var/lib/postgres/conf instead of the default location. After that, everything finally worked the way I wanted.

Now, every time a project is created, the system automatically adds an entry for it in the pg_hba.conf file with 0.0.0.0/0 so it’s publicly accessible by default. When users add or modify IP rules from the dashboard, the file is updated dynamically, and the Postgres server reloads with the new configuration.

The best part is how it indirectly solved another issue:
If someone somehow managed to create a database manually using the connection string, it wouldn’t have a matching entry in the pg_hba.conf file. That means it wouldn’t be accessible from anywhere, and my automated cleanup system would detect and remove it on its own.

It was messy, painful, and required more Docker restarts than I’d like to admit, but once it worked, it made the entire security layer feel airtight.

Optimization of pg_hba.conf Updates

Once the dynamic IP rules started working, a new challenge appeared concurrent updates.

If one user added a new IP rule, the platform would immediately rewrite the pg_hba.conf file and trigger a Postgres reload. Doing this for a few users wasn’t a big deal, but I realized that if 100+ users tried adding or updating IP rules around the same time, it could start to hurt performance.

So instead of reloading the Postgres server instantly for every update, I implemented a smarter solution. I set up a cron job that runs every hour and rewrites all the IP rules directly from the database. This way, users might have to wait up to an hour for their new IP rule to become active, but it keeps the server stable and avoids unnecessary reloads.

Then came the second edge case. What if, in that one-hour window, no changes had been made at all? Running a reload for no reason would still waste resources.

To fix that, I added a simple dirty bit service. Every time an IP rule is added or removed, it marks a flag as “dirty.” When the hourly cron job runs, it checks that flag first.

• If it’s dirty, it knows something changed and proceeds to reload the IP rules.

• If it’s clean, it skips the update completely.

This small mechanism made the whole system more efficient and reliable , no redundant reloads, no downtime, and zero stress even under heavy usage.

Wrapping It Up

Looking back, DataBridge started from one random thought while I was procrastinating a deployment and somehow turned into a complete DBaaS platform with automation, monitoring, security, and event-driven systems holding it all together.

Every feature I built taught me something new. Half the time I was just figuring things out as I went learning how queues work, breaking Docker volumes, debugging pg_hba.conf reloads at 2 a.m., and accidentally discovering half the architecture through mistakes.

But that’s what made it fun. DataBridge isn’t just another side project. It’s the story of how curiosity, confusion, and a few bad ideas eventually evolved into something real , a system that builds, monitors, protects, and cleans itself.

And maybe that’s the whole point , you don’t always need to know where you’re going. Sometimes you just start building, and the architecture finds you.

Live Demo : https://databridge.unknownbug.tech

Source Code : https://github.com/MrVineetRaj/databridge

Object-Oriented Programming (OOP) is a programming paradigm (a style of writing code) based on the concept of objects which can contain data and code. The data is represented as fields (often called attributes or properties), and the code is represented as procedures (often called methods). Objects are instances of classes, which act as blueprints for creating objects.

It majorly consists of two things:

• Class: A class is a blueprint or template that defines the properties (attributes) and behaviors (methods) common to all objects of its type.

• Object: An object is an instance of a class, representing a specific entity with its own unique state (attribute values) and behavior.

Difference between procedural and Object oriented Programming language

Use-Cases of Object Oriented Programming

Modularity : The process of breaking down a complex problem into smaller, manageable, and reusable components (such as classes), enhancing code organization and maintainability.

Code Reusability: Refers to the ability to extend and reuse existing functionality, reducing the need to duplicate code and promoting maintainability.
Example: Vehicle class extended by Car and Bike*.*

Scalability: Refers to the ability to effortlessly add new features or functionality without modifying existing code, ensuring the system can grow and adapt without disruption.

Security: Using OOP, users can protect sensitive data by encapsulating it within objects and exposing only the necessary functionality through controlled access methods, ensuring data integrity and security.
Example: private balance in a Bank Account class.

» Due to above mentioned use-cases OOPs is better for large scale application

Classes

» class is the blueprint or template for creating an object.

It defines the set of attributes(data) and methods(function) that an object will have after being created from certain class

class Employee { 
private:
    int salary; // to store the salary of employee

public:
    string employeeName; // to store the name of employee

    // Method to set the employee name
    void setName(string s) { 
        employeeName = s;
    }

    // Method to set the salary
    void setSalary(int val) { // method
        salary = val;
    }

    // Method to get the salary
    int getSalary() {
        return salary;
    }
};

Objects

» It is the instance of certain class that holds data for attributes and method provided by that class

for above Employee class , object may look like

int main() {
    // Creating an object of Employee class
    Employee obj1;

    // Setting different attributes of object 1 using available methods
    obj1.setName("Raj"); // Set name to "Raj"
    obj1.setSalary(10000); // Set salary to 10,000

    // Creating another object of Employee class
    Employee obj2;

    // Setting different attributes of object 2 in a similar way
    obj2.setName("Rahul"); // Set name to "Rahul"
    obj2.setSalary(15000); // Set salary to 15,000

    // Accessing the attributes of different objects
    cout << "Salary of " << obj1.employeeName << " is " << obj1.getSalary() << endl;
    cout << "Salary of " << obj2.employeeName << " is " << obj2.getSalary() << endl;

    return 0;
}

/*
Output : 
Salary of Raj is 10000
Salary of Rahul is 15000
*/

Note :

• Class does not hold memory

• Each object created by a class holds separate allocated memory

Attributes

» Inside an object attributes are something that holds data or you can say characteristics of that particular object

Behaviours:

» also called methods or function

It exists only to manipulate or change data for attributes of an object

Constructor

» A special method in a class to initialize an object when it is created

Constructor name must math the name of class

» If there is no constructor written for the given class, the language by-default triggers the default constructor*.*

Purpose of Constructor

• Object Initialization

• Code Reusability

• Ensures Default value

Types of constructor

Non-parameterized Constructor : When a constructor does not take any arguments as the input, it is called a Non-parameterized Constructor.

Parameterized Constructor : It is a type of constructor that accepts arguments to initialize attributes with specific values

Copy Constructor : It enables the programmer to create a new object by copying the attributes of an existing object. Java doesn't have an explicit copy constructor like C++ does. However, a copy constructor can be implemented manually by creating a constructor that takes an object of the same class as a parameter and copies its attributes using Constructor Chaining. Here's an example:

class Employee {
public:
    string employeeName; // To store the name of the employee
    int salary;          // To store the salary of the employee

    // Parameterized constructor
    Employee(string name, int salary) {
        this->employeeName = name;
        this->salary = salary;
    }

    // Copy Constructor
    Employee(const Employee &employee) {
        // Calling another constructor
        this->employeeName = employee.employeeName;
        this->salary = employee.salary;
    }
};

// Main Class
int main() {
    /* Creating an object of Employee class and passing 
    values for the parameterized constructor */
    Employee obj("Raj", 10000);

    // Creating a copy of obj using Copy constructor
    Employee objCopy(obj);

    // Printing the attibutes of copied object
    cout << "Name of the copied employee: " << objCopy.employeeName << endl;
    cout << "Salary of the copied employee: " << objCopy.salary << endl;

    return 0;
}

» In java a constructor can also call other constructor with constructor chaining using this() keyword

» There also exist a concept called constructor overloading, that means creating multiple constructor with different number of arguments

LinkedList is one of the most important topic in DSA as it is used in almost every other important topic so it is really important to learn LinkedList from scratch with strong foundation

Why LinkedLists ?

first question that come in our mind why to even learn LinkedLists when we have array and even vectors with dynamic size, so no vectors aren’t sufficient as vectors look like they are but how they work is like

let say you have defined a vector and it got one element means size is 1 now now if you try to insert new element it’s size will be double of current size

means if you have a vector of size 50 and you try to insert 51st element your vector will get 100 size filled so while it is dynamic it wastes lot of memories when working with huge data

While linked list s truly dynamic and we can just increase size of linkedlist decrease it as well

And you know what it is also good for space optimization as array use contagious locations for it’s assignment linkedlist on other hand use non contagious memory

and non contagious memory means randomly located chunks around our primary memory or RAM

so to keep track of it we have to keep details about the next node as if we lost it’s address we will never be able to get it and will become garbage in memory

How LinkedLists ?

class Node {
private:
    int data; // value stored at current node 
    Node* next; // stores address of next node
};

Algorithm

Floyd's Tortoise and Hare algorithm

Problems

Traversal in Linked List [code]

Pattern : Linear traversal :

Intuition :

Linear traversal with a curr ptr until curr is not null

Logic :

• Initialize curr node intially pointing at head

• print value of node where curr node is pointing

• move curr pointer

• repeat till curr is not null

T.C : O(N)

S.C : O(1)

Deletion of the Kth element of LL [code]

Pattern : two pointer approach with one curr and a trailing prev pointer

Intuition :

keep track index or element which is to be deleted and for doing so use linear search with curr and prev pointers

Logic :

• initialize both pointers with pointing to head

• point prev to curr then move curr one step ahead

• if curr is the node to be mark prec→next as curr→next

• disconnect curr from LL and delete it

T.C : O(N)

S.C : O(1)

Insertion at the Kth position of LL [code]

Pattern : traversal with one pointer

Intuition :

Move curr till curr is just before the desired position where we have to insert

Logic :

• move curr till curr→next is pointing toward desired position

• now create newNode with desired value

• insert newNode as newNode→next = curr→next and curr→next = newNode

T.C : O(N)

S.C : O(1)

Add two numbers in LL [code]

» The digits are stored in reverse order with each node storing one digit.

Pattern : two pointer pointing to start of each LL

Intuition :

just move both pointers simultaneously while doing so keep adding there value and don’t forget the carry from previous sum store in the third LL which is supposed to be ans

Logic :

• initialize both pointers pointing to head of both list using curr1,curr2

• calculate the sum by adding value of both curr nodes don’t forget about carry

• if sum is more then 10 take module and store as sum node and update carry after deviding the sum with 10

• keep doing above steps until any one hit NULL

• at end just check if any curr is not NULL then append all the list in current directly

• » Keep in mind you always have to maintain carry

T.C : O(max(N,M)

S.C : O(max(N,M) + 1) » if has carry then may need additional 1

Segregate odd and even nodes in LL [code]

» 1 Indexed list

» Group all the nodes with odd indices followed by all the nodes with even indices and return the reordered list.

Pattern : two pointer : moving with node→next→next each

Intuition :

just keep track of head(given always) it will be head of odd indices element

mark evenHead for head→next if exist it will work as head of all the even indices element

now add other elements of odd and even indices to respective heads

finally point tail of odd indices list to evenHead and return head

Logic :

• as first element is from odd indices element → head of the odd indices elements : head

• as second element is from even indices element → head of the even indices elements : evenHead

• now use two new pointers odd and even pointing directly to the head of respect nodes → head and evenHead

• now move those pointers with node→next = node→next→next

• above step will make sure that for even indices node it says on even indices and on odd if node is at odd index

• » consider proper order if you broke the list you will lose it

T.C : O(N)

S.C : O(1)

Sort a LL of 0's, 1's and 2's [code]

» In case of LL it is always best to reorder the nodes to impress interviewer

Pattern : store required nodes in separate lists

Intuition :

Store all the 0s,1s and 2s in their respective list

Logic :

• create new nodes zeroHead,oneHead,twoHead and respective curr element

• traverse the list from head append various newHead based on the value of the curr<head> node and move curr<zero,one,two> accordingly

• and note that do not make newNodes just mark like currZero→next = curr and then currZero = currZero→next

• Attach tail of LL for zero, twos and ones accordingly and reurn zeroHead

T.C : O(N)

S.C : O(N)

Remove Nth node from the back of the LL [code]

Pattern : two pointer: similar constant window concept

Intuition :

Just like constant sliding window move the window till it’s end reaches the end of LL now delete the element where start of that window is pointing

Logic :

• Move a fast pointer to desired step ahead

• now point a slow pointer to start

• move slow and fast window simultaneously until next of fast pointer is null

• now create a new pointer(temp) and point it to next of slow

• point slow→next to temp→next

• disconnect temp and then delete it

T.C : O(N)

S.C : O(1)

Reverse a LL [code]

Pattern : three pointers : prev, curr,next : game of logic

Intuition :

It is just concept of pointers how to pint them and when to point them to remind order is also important as much as connect between nodes

T.C : O(N)

S.C : O(1)

Add one to a number represented by LL [code]

Pattern : Linear traversal and concept of LL traversal

Intuition :

it’s just when we add 1 we add it to right most digit of number and in LL it means to tail of of LL

Logic :

• Reverse the LL

• Perform addition of one

• Reverse back the LL

• return head

T.C : O(N)

S.C : O(1)

Find Middle of Linked List [code]

Pattern : Fast and slow pointers Floyd's Tortoise and Hare algorithm

Intuition :

if a pointer moves two step at a time it will reach the end of LL while a pointer moving one step at a time will only reach the center

Logic :

• Initialize slow to head and fast to head-next

• move fast like fast = fast→next→next

• simultaneously move slow = slow→next

• keep the loop till fast != NULL && fast->next != NULL

• return slow it will be pointing to middle of the LL

T.C : O(N)

S.C : O(N)

Delete the middle node in LL [code]

Pattern : Fast and slow pointers Floyd's Tortoise and Hare algorithm with a prev pointer

Intuition :

Same as finding middle of LL but do it with a prev pointer point node just before slow pointer

T.C : O(N)

S.C : O(N)

Problem Title [code]

Pattern :

Intuition :

Logic :

T.C : O(N)

S.C : O(N)

Introduction

What is DSA ?

Nothing but a contagious way to store data of similar datatype ( eg: int, string , char etc )

Ways to declare an Array ?

1. C-style Array (fixed-size on stack)

int arr[5];            // uninitialized
int arr2[5] = {1, 2};  // {1, 2, 0, 0, 0}
int arr3[] = {1, 2, 3}; // size inferred: 3

2. std::array (C++11+, fixed size, safer than C-array)

#include <array>

std::array<int, 5> arr;                 // default-initialized
std::array<int, 5> arr2 = {1, 2, 3};    // {1, 2, 3, 0, 0}

• Size is fixed at compile time

• Has .size(), .at(), .begin(), .end(), etc.

3. std::vector (dynamic size, most common in CP)

#include <vector>

std::vector<int> v;                         // empty
std::vector<int> v2(5);                     // {0, 0, 0, 0, 0}
std::vector<int> v3(5, 7);                  // {7, 7, 7, 7, 7}
std::vector<int> v4 = {1, 2, 3, 4};         // list initialization

• Size can grow/shrink

• Preferred in competitive programming / DSA

• Has .push_back(), .resize(), etc.

4. Dynamic Array via new/delete (Heap allocation)

int* arr = new int[5];       // uninitialized
delete[] arr;                // don't forget to delete

Problems

Basic Problems are

• Linear Search

• Largest Element

• Second Largest Element

• Maximum Consecutive Ones

• Left Rotate Array by One

• Left Rotate Array by k Places

» Other Problems are

Move Zeros to End code

Two Pointer approach

• Keep both pointer at start s = 0 , m = 0

• m scans all the elements

• s stays at index where next non-zero element should go

• and if m ptr is at some non-zero element then swap the element with s ptr

• and move both ptr by one

• if m ptr is at 0 then just move it further

• It will make sure that your

  • before s all the elements are non zero and s will be swiping out your zeros to end

  • and as your m ptr is not moving any zero, it is moving only non zero to ptr s so all zero will eventually be by handled s and will be [ushed to end

Remove duplicates from sorted array code

Two Pointer

Define two ptrs curr = 0 , next = 0

• curr stays at a index before which no duplicates exist

• next Scans the array and finds next distinct element to be placed after curr

How it works

• next ptr picks an element and compares it with element at curr i

  • if they are same next moves ahead by one step

  • if they are different moves curr by one step and and then swaps element at curr with element at next and moves next by one

• Return curr + 1 as length of subarray from 0 to curr

Find missing number code

math

• Just calculate sum of first n numbers

• calculate the sum of elements of array

• return their abs(difference)

Union of two sorted arrays code

two pointer

The union of two arrays is an array where all values are distinct and are present in either the first array, the second array, or both.

» Brute Force : using set

» Optimal : using two ptrs

How it works

» Will use power of arrays being sorted

• ptr1 = 0 for first array

• ptr2 = 0 for second array

• now run a loop till either of ptrs hit size of respective arrays

• and also make sure you skip all the duplicates in one array itself by internal while loops

• and keep inserting unique and distinct elements in ans array

• and if any array has elements that are not pushed in ans array just push it in ans array

• return ans

Intersection of two sorted arrays code

two ptr

The intersection of two arrays is an array where all values are present in both arrays.

Same as union of arrays but here duplicated elements are allowed as they have same number of copies in each array

• just push element to ans array if both array has it

Leaders in an Array code

Just as question says

A leader in an array is an element whose value is strictly greater than all elements to its right in the given array. The rightmost element is always a leader. The elements in the leader array must appear in the order they appear in the nums array.

Rearrange array elements by sign code

• define two arrays

  • one for positive elements

  • one for negative elements

• now place values from these two array to original array as requested in Problem statement

Other way would be

Create a new array<ans array> of same size and place elements in the ans array directly from given array using two pointers :

• one for positive elements at even indices

• one for negative elements at odd indices

Print the matrix in spiral manner code

Do just as question says

• will be solved using 4 ptrs

  • l = 0 , r = cols-1 , t=0 , b = rows- 1

• While moving pointers keep in mind about the bound or limit of how far a point can go

Pascal's Triangle

math

• The first row has one element with a value of 1.

• Each row has one more element in it than its previous row.

• The value of each element is equal to the sum of the elements directly above it when arranged in a triangle format.

For pascal triangle there are three type of questions

Print an Element at r rows and c cols of Pascal’s Triangle code

$$\text{required_ans} = \binom{r - 1}{c - 1}$$

» Brute : Find factorial multiple times

» Optimal : Use formula

$$(n/1 )* ((n-1)/2) * ...$$

example :

for n = 10 and r = 7

$$\binom{10}{7} = (10/1)((10 - 1)/2)((10 - 2)/3)$$

Print each element of rth row code

        for row 4 
        simulating

        1    1*3/1    (1 * 3 * 2)/( 1 * 2)     (1 * 3 * 2 *1)/(1 * 2 * 3)
        1    3         3                          1

• here first element is 1

• next element will be found by

  • if x is ith element

  • then (i+1)th element

  • and it is in nth row

  • then

$$\text{required_ans} = (1*(n-1)(n-2)...(n-i+1))/ (123...*i)$$

3. Print all n rows of pascal triangle from row 1 code

Just repeat 2nd problem solution for each row

or

just implement what it is

• The first row has one element with a value of 1.

• Each row has one more element in it than its previous row.

• The value of each element is equal to the sum of the elements directly above it when arranged in a triangle format

Rotate matrix by 90 degrees code

• Transpose → reverse each row

Two Sum code

• using map if order of element in ans has to be same

• can also use sort

Three Sum code

• Sorting is required

• Also as it is asking about unique combinations of elements to sum to 0 Think about using a set

• Here three pointers will be used

• one will be fixed at ith position (i = 0 → n-1)

• other two will apply two sum in remaining elements and will compare three sum by adding value of item at ith index

Four Sum code

Same as three sum

• Fix left most element and for rest elements apply three sum

Sort an array of 0's 1's and 2's : Dutch National Flag algorithm code

may have to use 3 pointers

• s = 0 : before which all zeroes will be present

• m = 0 : middle pointer responsible for placing 0s and 2s at their desired position

• e = n-1 : after which all twos will be present

Steps

for m → 0 to e

• arr[m] == 1 : m++ and continue

• arr[m] == 0 : swap element at m with elem at s and m++ and s++

• arr[m] == 2 : swap element at m with elem at e and m++ and e—

Kadane's Algorithm code

• assume maxSum is minimum possible value

• then iterate and keep adding every element to sum and compare it with maxSum

• if sum < 0 set sum = 0 and keep doing the same

Next Permutation code

The next permutation of an array of integers is the next lexicographically greater permutation of its integers.

More formally, if all the permutations of the array are sorted in lexicographical order, then the next permutation of that array is the permutation that follows it in the sorted order.

example :

for 1 3 2

next permutation is number strictly greater then this → 2 1 3

Steps

• Find the element for which arr[i] < arr[i+1] where i = n-2 → 0

• now pivot at that index i

• find the first element on right part of pivot which is greater then item at i

• swap it at i and with item found at previous step

• now reverse the right part of pivot excluding the ith element

Majority Element I : Moore's voting algorithm code

The majority element of an array is an element that appears more than n/2 times in the array. The array is guaranteed to have a majority element.

In this algorithm we keep track of

• ans : element which is desired

• cnt : freq of how many times ans repeated it self in the array

Steps

• for every value of i ; i = 0→ n-1

  • if cnt = 0 : we assume this is the ans

  • if cnt ≠ 0

    • if ans = arr[i] : cnt++

    • else : cnt—

now we will have a value in ans which is the possible ans as if element is appearing more than n/2 times means it will be the last one in ans variable

however it is possible that no item appear more that n/2 times ,

hence we count the freq of ans in complete array using for loop over complete array

• if it satisfies the condition of majority element: our ans

• else return -1

Majority Element-II code

all elements which appear more than n/3

Modification to moore voting element

• Only two possible ans will exist

Find the repeating and missing number code

A math problem always prefer it’s coding solution

solved using generation equations of sum of first n elements and sum of first n*n elements

Count Inversions code

Brute force: Generate all pairs by scanning all other elements for each selected elements and return count of such numbers

optimal : merge sort

Maximum product sub array in an Array code : todo

concept of prefix product and suffix product

• for even number of negative elements product of whole array will be positive

• for odd number of negative elements there will be a single negative element that will cause whole product to be negative.

  • hence ans would be either right part of that element

  • or left part of that element

• To handle case for zero just assign 1 to prefix product or suffix product if they get zero

• For each iteration compare and store the max of suffix or prefix product or if prev stored was already bigger then move on

• and return the final ans

Merge two sorted arrays without extra space code : todo

just make sure all them elements in one array are strictly smaller then all elements of other array

» Note : Array size of left array is given as total number of elements

Steps

• Consider two arrays left , right array

• point one ptr at end of left array

• point second ptr at start of right array

• traverse both such that elements in left always smaller then right

• push all the elements from right to left array

What is the Problem?

Imagine you're working on multiple projects:

• Project 1 needs Node.js version 18.x

• Project 2 needs Node.js v20.x

• Some projects need an older MongoDB version

• Others need the current MongoDB version

What would you do? Install and reinstall versions one by one? This approach is difficult because:

• Every version must be configured accordingly

• Installed versions may conflict with each other

• Managing dependencies becomes a nightmare

What is the Solution?

Virtual machines are one solution, but they're resource-heavy and difficult to manage. You'd need to:

• Spin VMs on and off

• Connect services between different VMs

• Connect VM services with your local machine

Docker changes everything! It can:

• Spin environments up and down in seconds

• Run services instantly

• Connect all services with your local machine out of the box

• Simply map ports to connect services

  

Docker Terminology

1. Docker Image: A blueprint or template containing the code and dependencies needed to run a service. Think of it as a program stored on your machine, not executing but ready to run.

2. Docker Container: A running instance of a Docker image. It's like a process - your program in execution. When you run a container, Docker creates a unique instance with its own environment.

Each container is unique by default through a container ID, even if you don't pass any variables. You can also pass environment variables to customize containers.

Prerequisites: If you don't have Docker installed, refer to this article: Docker installation guide

Docker Commands for Images

1. Download an Image

Browse Docker Hub to find the image you need:

docker pull <image_name>

Examples:

docker pull postgres          # Latest postgres version
docker pull postgres:16       # Specific postgres version
docker pull node:18-alpine    # Node.js 18 with Alpine Linux

2. List All Images

docker images

3. Remove an Image

docker rmi <image_id_or_name>

Example:

docker rmi postgres:16

Docker Commands for Containers

1. Run a Container

docker run <image_name>

Example:

docker run hello-world

2. Run with Interactive Terminal

docker run -it <image_name> /bin/bash

Example:

docker run -it ubuntu /bin/bash

3. Run in Background with Port Mapping

docker run -d --name <custom_container_name> -p <host_port>:<container_port> <image_name>

Examples:

# Redis server
docker run -d --name my-redis -p 6379:6379 redis

# PostgreSQL database
docker run -d --name my-postgres -p 5432:5432 -e POSTGRES_PASSWORD=mypassword postgres

# MongoDB
docker run -d --name my-mongo -p 27017:27017 mongo

Best Practice: Map host and container ports to the same number (e.g., 6379:6379) for consistency.

4. List Running Containers

docker ps

5. List All Containers (including stopped)

docker ps -a

6. Container Lifecycle Management

# Stop a running container
docker stop <container_id_or_name>

# Start a stopped container
docker start <container_id_or_name>

# Restart a container
docker restart <container_id_or_name>

# Remove a container (must be stopped first)
docker rm <container_id_or_name>

# Force remove a running container
docker rm -f <container_id_or_name>

Interacting with Active Containers

1. Execute Commands Inside a Container

docker exec -it <container_id_or_name> bash

Examples:

# Access PostgreSQL CLI
docker exec -it my-postgres psql -U postgres

# Access Redis CLI
docker exec -it my-redis redis-cli

# General bash access
docker exec -it my-container bash

2. View Container Logs

docker logs <container_id_or_name>

# Follow logs in real-time
docker logs -f <container_id_or_name>

# Show last 100 lines
docker logs --tail 100 <container_id_or_name>

3. Copy Files Between Container and Host

# Copy from container to host
docker cp <container_id>:/path/to/file ./local/path

# Copy from host to container
docker cp ./local/file <container_id>:/path/to/destination

Practical Examples

Setting up a Development Environment

# PostgreSQL database
docker run -d --name dev-postgres -p 5432:5432 -e POSTGRES_PASSWORD=dev123 postgres:16

# Redis cache
docker run -d --name dev-redis -p 6379:6379 redis:7-alpine

# MongoDB database
docker run -d --name dev-mongo -p 27017:27017 mongo:7

Cleanup Commands

# Stop all running containers
docker stop $(docker ps -q)

# Remove all stopped containers
docker rm $(docker ps -aq)

# Remove unused images
docker image prune

# Remove everything (use with caution!)
docker system prune -a

Next Steps

Now that you understand basic Docker commands, you're ready to:

• Set up development environments quickly

• Test different software versions without conflicts

• Share consistent environments with your team

Introduction

So here we are introduction to graph a non-linear data structure, or you can say non linear way to represent data

A graph consists of Nodes and Edges

Further graphs are categorized in multiple types

• Directed Graph : When edges are directed

• Weighted graph : When edges have a weight assigned to it

• Cyclic Graph : when nodes are connected such a way that when you start from one node you can reach that node again after traversing all the nodes

• Acyclic Graph : Opposite to cyclic one i.e when you can’t reach at initial node

In above image it’s shown types of graph along with components

Intuition

Consider it as a state now think of all the cities as node and roads as edge now

• If you can move on road from going cityX → cityY and cityY → cityX then it could mean graph is undirected graph because of those undirected edges

• If you can go from cityX → cityY but if cityY → cityX is not possible then it means it’s undirected graph

• Now if you have to pay taxes to travel on roads then it means a weighted edge or graph is a weighted graph

• And if you go like cityX → cityY → cityZ → cityX : it means you can reach back to cityX without touching other cities twice A cyclic graph is here ( in above figure there are cycles in undirected graph but for directed one it’s not forming a single cycle )

• If no cycles then Acyclic graph

So you can see whatever it name suggests just add that attribute to edge or node and graph becomes that

Degree of graph

$$graphDegree = \sum_{i=start}^{end} nodeDegree$$

So here nodeDegree means number of edges connected to ith node

For Directed Graph it could be said as

• Indegree : for incoming edge to node

• outdegree : for outgoing edge to node

Example :

How we take input and store graphs ?

Adjacency Matrix : when we store data in a 2d matrix of size n X n where n is number of nodes

 // For Weighted , undirected graph
{
  int numberOfNodes = 0;
  cin >> numberOfNodes;

  vector<int> adjMatrix[numberOfNodes];

  int numberOfEdges = 0;
  cin >> numberOfEdges;

  for (int i = 0; i < numberOfEdges; i++)
  {
    // input in format startingNodeOfEdge , ending node of edge , weight of edge
    int starting, ending, weight;  // for unweighted graph, edge weight is assumed 1
    cin >> starting >> ending >> weight;

    adjMatrix[starting][ending] = weight;
    adjMatrix[ending][starting] = weight; // if it is a directed graph then we will not do this
  }
}

Analysis

Time Complexity : O(E)

Space Complexity : O(N²) {best,avg,optimal case }

Adjacency Lists : Here we store a vector mapped to every node storing the info about which nodes are connected to which node

{
  // undirected and unweighted graph
  int numberOfNodes = 0;
  cin >> numberOfNodes;

  vector<vector<int>> adjList(numberOfNodes);

  int numberOfEdges = 0;
  cin >> numberOfEdges;

  for (int i = 0; i < numberOfEdges; i++)
  {
    // input in format startingNodeOfEdge , ending node of edge
    int starting, ending; 
    cin >> starting >> ending;

    adjList[starting].push_back(ending);
    adjList[ending].push_back(starting);  // if it is a directed graph then we will not do this
  }
}

Analysis

Time Complexity : O(E)

Space Complexity : O(N²) {worst case : when all the nodes are connected to each other }

Implement adjList for weighted graphs

Hint ????

For a weighted graph instead of mapping nodes with each node we could have mapped it with pair of node and it’s weight

Algorithms related to graphs

Note : Just remember if applying graph you would need an Array to track visited nodes a queue or a stack

Traversal Technique : Breadth First Search ( BFS )

Focus on word breadth !

It means

• if we arrive at any node then we will go through each and every neighbour node first say neighbours are at level 1

• then we get back to first neighbour

• Now we apply step one with assuming the first neighbour at level 1 is our starting node

• We travers all node at level 2 now when done

• when we traverse back we go back to the second neighbour of level 1

Implementation

   vector<int> bfsOfGraph(int V, vector<int> adj[]) {
        // to keep track of visited nodes
        vector<bool> visited(V,false);
        vector<int> ans;

        // this loop will take care of disconnetcted components
        for(int i = 0; i < V; i++){
            // if a node is not visited means there is one graph component is there which is not traversed
            if(!visited[i]){
                //to cover that one component
                queue<int> q;
                q.push(i); // assumed that one unvisited node as source node
                ans.push_back(i);
                visited[i] = true;

                // now traversing it's negihbouring nodes
                while(!q.empty()){
                    int currNode = q.front();
                    q.pop();

                    for(auto it:adj[currNode]){
                        if(!visited[it]){
                            q.push(it);
                            ans.push_back(it);
                            visited[it] = true;
                        }
                    }
                }
            }
        }

        return ans;
    }

Traversal Technique : Depth First Search

Focus on word Depth

It means we will do something like inorder traversal of tree, i.e

• Will take a source node

• go to it’s first neighbouring node which is not visited

• Will assume it is our source node and then will go to it’s first not visited neighbouring node

• and will keep going to depth till we don’t get neighbouring nodes

• and then when we don’t have any node to visit we trace back

• and try to cover other non visited nodes

    void dfs(
        int node,
        vector<int> adj[],
        vector<bool> &visited,
        vector<int> &traversal
    ){
        visited[node] = true;

        traversal.push_back(node);

        for(auto it:adj[node]){
            if(!visited[it]){
                // calling the recursionjust after finding , first unvisited node
                dfs(it,adj,visited,traversal);
            }
        }
    }

// got number of node and adj list as input to the function
    vector<int> dfsOfGraph(int V, vector<int> adj[]) {
        vector<bool> visited(V,false);
        vector<int> traversal;
        // traversing visited array to track unvisted graph nodes
        for(int i = 0; i < V;i++){
            if(!visited[i]){
                // for unvisted node 
                // taking it as a source and traversing the graph such that it visits all connected nodes
                dfs(i,adj,visited,traversal);
            }
        }
        return traversal;
    }

Topological Sorting : using DFS and stack

Topological order is in which if node u is connected to node v then u must appear before node v, no matter how earlier but must be earlier then node v

Note : It is only possible for a directed acyclic graph ( DAG ) , as for others it will not be possible to print the order

Here we are just

• using a stack that will keep track of nodes in which they are traversed

• Last or terminal node will be inserted into stack first as we are inserting node after DFS is complete

• Later will just omit the stack and will print their order in which stack popped the set of nodes

    void dfs(int node,vector<int> adj[],stack <int> &st,int vis[]){
        vis[node] = 1;
        for(auto it:adj[node]){
            if(!vis[it])  dfs(it,adj,st,vis);
        }
        // normal DFS with this additional stack call
        st.push(node);
    }
    vector<int> dfsTopo(int V,vector<int> adj[]){
        int vis[V] = {0};
        stack<int> st;

        // traversing like normal DFS but with additional argument of stack
        for(int i = 0; i < V; i++){
            if(vis[i] == 0){
                dfs(i,adj,st,vis);
            }
        }

        // storing ther order when Traversal is completed
        vector<int> order;
        while(!st.empty()){
            order.push_back(st.top());
            st.pop();
        }

        return order;
    }

Topological Sorting : Khan’s Algo. ( using BFS )

Topological order is in which if node u is connected to node v then u must appear before node v, no matter how earlier but must be earlier then node v

Note : It is only possible for a directed acyclic graph ( DAG ) , as for others it will not be possible to print the order

Here additional ideas are

• Store count of indegree edges as if it i zero means there are not any other node on which current node depends

• And if a node does not depends on any other node then it means

  • The node is root node

  • Parent nodes are already processed

• Hence we can start processing and recording those nodes with zero indegree

• rest is simple BFS

 vector<int> khansAlgo(int V,vector<int> adj[]){
        // to track indegree edges to track if a node is depends on other node
        int indegreeEdges[V] = {0};
        int vis[V] = {0};

        for(int i = 0; i < V;i++){
            for(auto node:adj[i]){
                indegreeEdges[node]++;
            }
        }

        vector<int> ans;

        // normal bfs with addition of indegreeEdges array 
        queue<int> q;
        for(int i = 0; i < V; i++){
            if(indegreeEdges[i] == 0){
                q.push(i);
                vis[i] = 1;
            }
        }

        while(!q.empty()){
            int currNode = q.front();

            ans.push_back(currNode);
            q.pop();

            for(int it:adj[currNode]){
                if(!vis[it]){
                    indegreeEdges[it]--;
                    if(indegreeEdges[it] == 0){
                        q.push(it);
                        vis[it]=1;
                    }
                }
            }
        }

        return ans;
    }

Disjoint Set Union

» Why ?

» Because , sometime we don’t have to print path between two nodes we just have to tell that if a path is possible or not. And BFS or DFS takes significant time for doing this like O(E+V) time complexity for processing each of the pair so if n pair then O(n*(E + V ) ) which is waste here because we just had to say yes or no for weather path exist or not

Here Comes the Disjoint Set Union in picture that takes constant time or O( 4 * alpha ) Time complxity where alpha is almost equal to 1 hence Constant Time

How it Works ?

It stores the parent or ultimate parent of each node and say if ultimate parent of both nodes is different than it says path not possible else it’s possible

And for parent it is decided based on rank of each node or size of each node like

• if size_u > size_v

  • u will be parent of v

• if size_u == size_v

  • any one can become anyone’s parent but

  • one that became parent , you must increase it’s rank or size by one.

» keep in mind that we never compare parent we compare parents of parent until node becomes parent of itself or you can say ultimate parent of node

» We can even store ultimate parent of node in our parent array as we don’t need to know direct parent we just want to know root of that cluster or tree or whatever data structure it’s forming, and when we store ultimate parent directly it is called Path Compression

How to use it ?

Basically it’s a class that comes with 5 function or methods

• DisjointSet(int n) : it initializes required arrays and fills in req. values

• findUPar(int u) : it returns ultimate parent of u

• find(int u, int v) : it returns a boolean value for weather u and v are connected by a path or not

• unionByRank(int u, int v) : it joins clusters whose roots are node u and node v based on there rank

• unionBySize(int u, int v) : it joins clusters whose roots are node u and node v based on there size

class DisjointSet {
    vector<int> rank,parent,size;

public:
    DisjointSet(int n) {
        rank.resize(n+1,0);
        parent.resize(n+1);       
        size.resize(n + 1, 1);
        for(int i = 0;i < n;i++){
            parent[i] = i;
        }
    }

    int findUPar(int node){
        if(node == parent[node])
            return node;

        return parent[node] = findUPar(parent[node]);
    }

    bool find(int u, int v) {
        return (findUPar(u) == findUPar(v));
    }

    void unionByRank(int u, int v) {
        int ulp_u = findUPar(u);
        int ulp_v = findUPar(v);

        if(ulp_u == ulp_v) return;

        if(rank[ulp_u] < rank[ulp_v]){
            parent[ulp_u] = ulp_v;
        }else if(rank[ulp_u] > rank[ulp_v]){
            parent[ulp_v] = ulp_u;
        }else{
            parent[ulp_v] = ulp_u;
            rank[ulp_u]++;
        }
    }

    void unionBySize(int u, int v) {
        int ulp_u = findUPar(u);
       int ulp_v = findUPar(v);

       if (ulp_u == ulp_v) return;

       if (size[ulp_u] < size[ulp_v]) {
           parent[ulp_u] = ulp_v;

           size[ulp_v] += size[ulp_u];
       }
       else {
           parent[ulp_v] = ulp_u;
           size[ulp_u] += size[ulp_v];

       }
    }
};

Spanning Tree

A spanning tree is a subset of a

• weighted graph

• in which there are N nodes(i.e. all the nodes present in the original graph) and

• N-1 edges and

• all nodes are reachable from each other.

Example

For above graph below is a possible spanning tree

» Note : If we draw all possible spanning trees and compared the sum of there edge weights then spanning tree with minimum sum of edge weights is called a Minimum Spanning Tree or MST

Minimum Spanning Tree : Prim’s Algo.

It is same as doing BFS on a connected graph as a Spanning tree exist only for connected graphs

Difference with BFS is

• Instead of queue we use priority queue ( min-heap )

• It helps us to visit a node only when reachable at minimum cost from certain node

 int primsMST(int V, vector<vector<int>> adj[]) {
        // your min heap that will record all the nodes with wt from parent 
       priority_queue<P,vector<P>,greater<P>> pq;  // {weight, node} 
       pq.push({0,0}); // inserted first node as it's wt from parent will be 0 as no parent initally

       int sum = 0;
       vector<bool> vis(V,false); // visited array to keep track of node taht are vsted once
       while(!pq.empty()){
            int wt = pq.top().first;
            int node = pq.top().second;

            pq.pop(); // popping element of smallest wt from it's parent

            // if node is visted previously means we recorded an edge with 
            // comarativly smaller weight and hence we will not record the current edge and will pop it out
            if(vis[node]) continue; 

            // if it was not recorded previously means it's the shortest edge weight possible
            vis[node] = true;
            sum+=wt; // record th weight

            // push neighbour node with wt according to dist between neighours and current node as it's parent
            for(auto it:adj[node]){
                if(!vis[it[0]]){
                    pq.push({it[1],it[0]}); // if neighbour is unvisted then push it in min-heap
                }
            }
       }

       return sum;
    }

Minimum Spanning Tree : Kruskal Algo.

• For this we use DisjointSet ( already discussed in article )

int kruskalMST(int V,vector<vector<int>> adj[]){
        vector<pair<int, pair<int, int>>> edges;
        for (int i = 0; i < V; i++) {
            for (auto it : adj[i]) {
                int v = it[0]; 
                int wt = it[1];
                int u = i;
                edges.push_back({wt, {u, v}});
            }
        }

        DisjointSet ds(V);
        sort(edges.begin(), edges.end());
        int sum = 0;

        for (auto it : edges) {
            int wt = it.first; 
            int u = it.second.first; 
            int v = it.second.second; 

            if (ds.findUPar(u) != ds.findUPar(v)) {
                sum += wt;
                ds.unionBySize(u, v);
            }
        }

        return sum;
    }

Problems

Number of provinces : code

Same as BFS or DFS

• Just with additional counter

• Increment counter when going to traverse new component

Number of islands : code

Simple traversal but with

• queue that show cell address like {row,col} means queue of pair<int,int>

• And it’s adj node would be based on delta values from below array

    int dRow[] = {-1, -1, -1, 0, 0, 1, 1, 1};
    int dCol[] = {-1, 0, 1, -1, 1, -1, 0, 1};

Flood fill algorithm : code

Simple traversal

• Here we don’t need any visited array

• just use given image matrix it self

• if given new color is same as initial color means already satisfied so we will just return

• Allowed directions

•           int dRow[] = {-1, -1, -1, 0, 0, 1, 1, 1}; 
            int dCol[] = {-1, 0, 1, -1, 1, -1, 0, 1};
  

Number of enclaves : code

Question asks return number of cells from which we can’t get on boundary for any number of steps in 4 direction

• Just apply BFS or DFS on possible boundary land cells

• And it will mark all the cell visited, where we can reach from boundary

• For cells that we can’t return their number

Rotten Oranges : code

Question says if an orange is rotten then it will rot other fresh oranges in horizontal and vertical direction in one minute so return the total time taken to rot all fresh oranges

• Must be a graph such that in all of his component atleast one rotten orange must exist

• BFS would be required with source node as rotten oranges at time t = 0

• It’s queue will be tracking time at which inserted orange was rotten

• And for BFS insert all the rotten oranges in the queue before processing BFS

• As every rotten orange at a moment will simultaneously rot other connected fresh oranges

• At every insertion of rotten orange you have to increment the time at which his parent was rotten

Distance of nearest cell having one : code

Same as Rotten Orange but instead of time here you have to store currDist

• Firstly insert all the available ones in queue and that’s done

• now just apply bfs with that queue and a visted array

Surrounded Regions : code

Question says return a matrix after converting all the ‘O’s as ‘X’ if the set from which that ’O’ belong is surrounded by ‘X’

Intiution

Just see boundary ‘O’s are not surrounded by ‘X’ so just consider those ‘O’s and traverse on matrix assuming those ‘O’s as source and for every other ‘O’ that could be approached will be marked as ‘O’s in set which not surrounded by ‘X’ and for other ‘O’s just convert them to ‘X’

Number of distinct Islands : code

In question it says distinct islands by which it means they must be distinct in their orientation too

example

Below matrix has only 3 distinct islands

Below matrix has only 1 distinct islands

Intiution

Unique → use set

• For Solving this question you can use BFS and insert the node to temp array

• insert that temp array into a set

• but before inserting that temp array make sure you converted it’s top - left element as base {2,3} → {0,0} and now relative address of othr cell of that island would be {2,4},{3,3},{3,4} to {0,1},{1,0} and {1,1}

• Now sort the temp array and then insert it to set

• return size of set as your ans

Detect a cycle in an undirected graph : code

In undirected graph it is really easy to detect a cycle

• as if a node going to visit a nnode [nnonde => neighbour node] but if that nnode says it’s already visited but if that nnode was not the parent of the node which means someone else visited the node so it is a cycle

Detect a cycle in an directed graph : code

Now here the confusion comes like if a node is visited and it’s not a parent to current node that does not mean it’s a cycle as here it’s directed from node to nnode right ?

So here we can apply DFS ( as it goes in straight line ( in depth ) )

• We will be also keeping a pathtraversed array that will keep track if a visited node is from same path on which i am running

• That is when i am going in depth i have to mark pathTraversed as 1 and when i am backtracking i have to keep converting pathTraversed back to 0

• and hence if i reach a node which is visited also for which pathTraversed is 1

• Means i did encountered that node in same path and again i am here so it is a cycle

• therefore return true

I am Vineet Raj on a journey to complete DSA in depth and I am writing such article for every topic so if you want to revise complete topic from single article you would love my articles !

Then you are at right place here in this article I will discuss these problems and why it might not be working for you and what’s the solution

I will be focusing on LINUX OS how ever if you are in virtual machine or may be trying to run on wsl and getting these errors then follow the article you are going to understand root cause of it and will be able to solve it

Docker Installation

There are many ways to install to docker as mentioned on there docs

• Docker Engine

• Docker Desktop

And many other option that you may want to install but for this article let’s focus on these two

After running commands from there official docs for installation you will find this one command

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl 
sudo install -m 0755 -d /etc/apt/keyrings 
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Now when you run this command you get the docker-engine for you OS mark that Point for your whole OS not just current user

Another method docker desktop you can download it from here

For Ubuntu Commands are

sudo apt install gnome-terminal

sudo apt-get update
sudo apt-get install ./docker-desktop-amd64.deb

You may get error like below at end and it’s normal just ignore it

N: Download is performed unsandboxed as root, as file '/home/user/Downloads/docker-desktop.deb' couldn't be accessed by user '_apt'. - pkgAcquire::Run (13: Permission denied)

Now Start you docker

systemctl --user start docker-desktop

Why sudo everytime ?

So when you download docker engine it’s for you Whole OS and If it is for you OS not just current user then to control it you must have to give permission to read and write at OS level with sudo keyword and when you install Docker Desktop it gets downloaded on user level.

And now as we know every image downloaded from docker must be visible on the Docker Desktop but you may end up with “not able to see my downloaded images in my Docker Desktop” yep because your docker is running on OS level not on User level

Now some of you say We are able to run with just docker and then our images are seen in Docker Desktop but when we run commands with sudo docker our docker images can’t be seen in docker desktop and may be you will not be able to run many commands with just docker and you might have to use sudo docker

So I experienced the same problem, tried many ways to solve the issue but failed again and again. One article which was most suitable and almost solved the problem is An article from Andrey Byhalenko

But still not able to get the solution that satisfied me and that sudo key word altogether and then I got to know about those contexts as mentioned earlier OS context for docker engine ( for which have to use sudo ) and other context that comes with docker desktop as it is not just a software it’s a bundle of complete docker ecosystem on user level not os level

means when you use sudo docker context for docker images are switched to OS level and when you use docker context remains docker desktop

Multiple context multiple ways and lot’s of confusion

So by giving it a thought I ended up like why do I even need 2 contexts of docker ?

So just remove one context that could be any one

• If you are fine working with sudo and do not need graphical interface and can work with docker cli go for OS level context or docker engine

• If you think that GUI is important can’t do it with CLI and want to live without sudo docker command just uninstall docker engine and install docker desktop

If you are going with Docker Desktop

You have to run commands after installation of docker desktop

systemctl --user status docker-desktop

It may prompt

○ docker-desktop.service - Docker Desktop
     Loaded: loaded (/usr/lib/systemd/user/docker-desktop.service; disabled; pr>
     Active: inactive (dead)

So what it says? it says that docker is not running currently and will not be running automatically after you login to you account ( as it’s an user level context so need to be user specific ) so you have to start docker desktop manually whenever you want to use it.

And if you think no I want my docker to start just after login to my account then run commands

systemctl --user start docker-desktop
systemctl --user enable docker-desktop

And now if you run command

systemctl --user status docker-desktop

You will get something like

● docker-desktop.service - Docker Desktop
     Loaded: loaded (/usr/lib/systemd/user/docker-desktop.service; enabled; pre>
     Active: active (running) since Wed 2025-05-07 06:47:28 IST; 1min 18s ago
   Main PID: 45142 (com.docker.back)
      Tasks: 149 (limit: 9289)
     Memory: 2.9G (peak: 2.9G)
        CPU: 2min 4.885s

So now you system will start docker every time you login into that context

And yeah that’s the process that i thought was easy and i ended up working with docker easily

User level context is amazing if you only have one user account on you linux OS

Hope It solves you problem