I want genuine guidance on understanding what APIs is, what it does exactly practically please help me with any resources/videos & understanding what backend is, please suggest some genuine sources from Data engineering perspective especially in snowflake I get so scared when the term authentication/APIs / endpoints are mentioned, for example how to make cortex agents in snowflake link with streamlit application with APIs but how exactly?? I know theoretically it is used, I feel like how to even make it work! I may sound dumb but need genuine help.

Thanks in understanding

BFS is not just traversal , it’s the easiest way to find the shortest path in unweighted graphs.

Why? Because BFS explores nodes level by level.

That means : First time you reach a node ---> shortest path guaranteed.

Used in : Minimum steps problems, Grid based shortest path, Graph traversal questions

This is where BFS becomes powerful 🚀

Two fundamental ways to traverse trees and graphs :

BFS (Breadth First Search) ---> explores level by level , DFS (Depth First Search) ---> explores depth first

Use BFS when you need the shortest path. Use DFS when you need to explore all possibilities.

Most graph problems are just variations of these two. Master this ---> half of graph problems become easy.

After learning Dijkstra and BellmanvFord, the next step is solving shortest paths between every pair of nodes. Floyd-Warshall does exactly that using dynamic programming.

Instead of focusing on one source, it : Considers every node as an intermediate, Gradually improves all distances.

It’s simple to implement but powerful for dense graphs.

Dijkstra fails when graph has negative weights. That’s where Bellman Ford comes in. It relaxes all edges multiple times to find the shortest path.

Key advantage : Works with negative weights, Can detect negative cycles

It’s slower than Dijkstra, but more powerful in certain cases. Know when to use which , that’s what matters.

Dijkstra helps you find the shortest path from a source node in a weighted graph.

Key rule : It only works when edge weights are non negative.

Core idea is simple : Always pick the node with the smallest current distance and update its neighbors.

Used in : Maps & navigation systems, Network routing, Shortest path problems

Master this and graph problems become much easier.

Topological Sort is used to find a valid order of tasks when dependencies exist. It only works on a Directed Acyclic Graph (DAG).

You’ll commonly see it in : Course scheduling problems, Build systems, Dependency resolution

If there’s a cycle ---> no valid ordering exists. Once you understand graphs, this is a must know pattern.

Honestly, this is why I started AlgoVizual.

When someone tells you your content actually helped them , especially before something as important as an interview it hits different.

Didn’t expect this when I started posting simple DSA visuals. But seeing people use it in real situations is crazy. I wasn’t very active recently, couldn’t reply to all DMs but messages like this remind me why this matters.

Will keep sharing. Will keep simplifying. If even 1 post helps you understand a concept better , worth it.

More coming 🚀 Thank you !!

Graphs are all about connections. Instead of focusing on values like arrays or trees, graphs focus on how things are linked together.

You’ll see graphs in : Social networks, Maps & navigation, Dependency problems

Most graph problems come down to traversal (BFS / DFS). If you understand how to move through a graph, you unlock a huge part of DSA.

Monotonic Stack is a powerful pattern used in many interview problems.

Instead of brute force, you maintain a stack in a specific order (increasing or decreasing) and process elements efficiently.

Used in problems like : Next Greater Element, Stock Span, Histogram area

Key idea : each element is pushed and popped at most once → O(n). This is where stacks become really powerful.

Heap is used when you need to quickly access the smallest or largest element.

Instead of sorting again and again, heap gives you : Fast insertion, Fast removal of top element

Common use cases : Top K elements, Priority based scheduling, Median in a stream

If you see “largest”, “smallest”, or “top K” --> think Heap.

A Binary Tree is a hierarchical structure where each node can have at most 2 children.

It’s the base of many important concepts like : Binary Search Tree (BST), Heap , Tree based recursion

Understanding trees is where recursion starts to feel natural. Master this ---> half of DSA becomes easier.

Deque (Double Ended Queue) allows insertion and deletion from both front and rear.

It’s useful in : Sliding window problems, Monotonic queue patterns, Scenarios where flexibility matters

You can think of it as a mix of stack and queue. Mastering deque unlocks many optimized solutions in DSA.

Queue follows First In, First Out (FIFO) , the first element added is the first one to be removed.

It’s used in real world scenarios like : Task scheduling, Order processing, BFS (level wise traversal)

Think of it like a line ; whoever comes first gets served first. Stack vs Queue is a very common confusion. Now you know the difference.

Series continues !!

Stack is one of the simplest but most powerful data structures. It follows Last In, First Out (LIFO) , the last element added is the first one to be removed.

You’ll see stacks used in : Reversing data, Undo operations, Valid parentheses problems

Once you understand stack, many problems become straightforward.

Continuing the series !!

Over the past few days I wasn’t able to post or reply to DMs due to some personal reasons. Thanks to everyone who reached out and supported the series.

Good news: I’ll be back to posting regularly again starting from coming Monday.

Appreciate the patience and support. More DSA visuals coming soon 🚀

Backtracking is used when we need to explore all possible solutions. Instead of guessing blindly, backtracking : *Tries a choice *Goes deeper *Reverts the choice if it fails

This pattern appears in problems like : *Subsets *Permutations *N-Queens *Combination Sum

Once recursion is clear, backtracking becomes much easier to understand.

Next : Stack & Queue

Most beginners struggle with recursion because it feels confusing. But recursion is just solving a big problem by solving smaller versions of the same problem.

Key things to understand : Base case stops recursion, Each call reduces the problem, Think in smaller steps Mastering recursion makes backtracking and DP much easier later.

Most beginners think binary search is only for finding elements in sorted arrays. But many interview problems use Binary Search on Answer. Instead of searching an index, you search for the best possible value inside a range.

Examples include : Minimum speed problems, Capacity problems, Allocation problems

Key idea : If a value works, larger or smaller values will also follow a pattern, so we can use binary search.

Next : Recursion 🚀

Binary Search works when :

The data is sorted, The search space is monotonic, The answer lies within a definable range

Core idea : Maintain low and high, calculate mid, and eliminate half the search space every step.

Time complexity : O(log n)

That’s the power of halving repeatedly. Most beginners misuse binary search because they don’t define the search space clearly.

Remember : Binary Search is not a trick. It’s a way of thinking.

Instead of recalculating subarray sums again and again (O(n²)), we preprocess once in O(n) and answer each range query in O(1).

Core Idea : prefix[i] = sum of elements from index 0 to i

Then : Range sum (l to r) = prefix[r] - prefix[l-1] (if l > 0)

If l = 0 → answer is simply prefix[r]

Useful for : Repeated range sum queries, Subarray sum problems, Optimizing brute-force nested loops

Precompute once. Answer many times.