Create app.py

app.py

@@ -0,0 +1,700 @@
+import gradio as gr
+import json
+from typing import Dict, List, Tuple, Set
+
+class DSALearningRoadmap:
+    def __init__(self):
+        self.topics_data = {
+            "Arrays": {
+                "difficulty": "Beginner",
+                "prerequisites": [],
+                "description": "Linear data structure storing elements in contiguous memory locations",
+                "key_concepts": ["Indexing", "Traversal", "Insertion", "Deletion", "Searching"],
+                "learning_path": [
+                    "Understand array basics and memory layout",
+                    "Learn array operations (CRUD)",
+                    "Practice basic array problems",
+                    "Master array traversal patterns",
+                    "Solve sliding window problems"
+                ],
+                "time_estimate": "1-2 weeks",
+                "connects_to": ["Strings", "Sorting", "Searching", "Dynamic Programming", "Two Pointers"],
+                "important_problems": [
+                    "Two Sum", "Maximum Subarray", "Rotate Array", "Merge Sorted Arrays", "Find Duplicates"
+                ]
+            },
+            "Strings": {
+                "difficulty": "Beginner",
+                "prerequisites": ["Arrays"],
+                "description": "Sequence of characters, often implemented as character arrays",
+                "key_concepts": ["String manipulation", "Pattern matching", "Substring operations", "String comparison"],
+                "learning_path": [
+                    "Learn string basics and operations",
+                    "Practice string manipulation problems",
+                    "Master substring and pattern matching",
+                    "Learn string algorithms (KMP, Rabin-Karp)",
+                    "Solve advanced string problems"
+                ],
+                "time_estimate": "2-3 weeks",
+                "connects_to": ["Arrays", "Hashing", "Tries", "Dynamic Programming"],
+                "important_problems": [
+                    "Valid Palindrome", "Longest Substring Without Repeating Characters", "Group Anagrams", "String to Integer", "Implement strStr()"
+                ]
+            },
+            "Linked Lists": {
+                "difficulty": "Beginner",
+                "prerequisites": ["Arrays"],
+                "description": "Linear data structure where elements are stored in nodes connected via pointers",
+                "key_concepts": ["Pointers", "Node operations", "Traversal", "Insertion", "Deletion"],
+                "learning_path": [
+                    "Understand pointers and node structure",
+                    "Learn basic linked list operations",
+                    "Practice traversal and manipulation",
+                    "Master different types (singly, doubly, circular)",
+                    "Solve complex linked list problems"
+                ],
+                "time_estimate": "2-3 weeks",
+                "connects_to": ["Stacks", "Queues", "Trees", "Graphs", "Hashing"],
+                "important_problems": [
+                    "Reverse Linked List", "Merge Two Sorted Lists", "Detect Cycle", "Remove Nth Node", "Intersection of Two Linked Lists"
+                ]
+            },
+            "Stacks": {
+                "difficulty": "Beginner",
+                "prerequisites": ["Arrays", "Linked Lists"],
+                "description": "LIFO (Last In First Out) data structure",
+                "key_concepts": ["Push", "Pop", "Peek", "Stack overflow", "Applications"],
+                "learning_path": [
+                    "Learn stack concept and operations",
+                    "Implement stack using arrays and linked lists",
+                    "Practice basic stack problems",
+                    "Learn stack applications (expression evaluation, parsing)",
+                    "Master advanced stack problems"
+                ],
+                "time_estimate": "1-2 weeks",
+                "connects_to": ["Queues", "Recursion", "Trees", "Graphs", "Dynamic Programming"],
+                "important_problems": [
+                    "Valid Parentheses", "Min Stack", "Evaluate Reverse Polish Notation", "Largest Rectangle in Histogram", "Daily Temperatures"
+                ]
+            },
+            "Queues": {
+                "difficulty": "Beginner",
+                "prerequisites": ["Arrays", "Linked Lists"],
+                "description": "FIFO (First In First Out) data structure",
+                "key_concepts": ["Enqueue", "Dequeue", "Front", "Rear", "Circular queue"],
+                "learning_path": [
+                    "Learn queue concept and operations",
+                    "Implement queue using arrays and linked lists",
+                    "Practice basic queue problems",
+                    "Learn different types (circular, priority, deque)",
+                    "Master BFS and queue applications"
+                ],
+                "time_estimate": "1-2 weeks",
+                "connects_to": ["Stacks", "Trees", "Graphs", "BFS", "Priority Queues"],
+                "important_problems": [
+                    "Implement Queue using Stacks", "Sliding Window Maximum", "Design Circular Queue", "Rotting Oranges", "First Unique Character"
+                ]
+            },
+            "Recursion": {
+                "difficulty": "Intermediate",
+                "prerequisites": ["Arrays", "Stacks"],
+                "description": "Problem-solving technique where a function calls itself",
+                "key_concepts": ["Base case", "Recursive case", "Call stack", "Memoization", "Tail recursion"],
+                "learning_path": [
+                    "Understand recursion concept and base cases",
+                    "Practice simple recursive problems",
+                    "Learn recursive patterns and techniques",
+                    "Master backtracking using recursion",
+                    "Optimize recursive solutions"
+                ],
+                "time_estimate": "2-3 weeks",
+                "connects_to": ["Dynamic Programming", "Trees", "Graphs", "Backtracking", "Divide and Conquer"],
+                "important_problems": [
+                    "Fibonacci Sequence", "Factorial", "Tower of Hanoi", "Generate Parentheses", "Permutations"
+                ]
+            },
+            "Sorting": {
+                "difficulty": "Intermediate",
+                "prerequisites": ["Arrays", "Recursion"],
+                "description": "Algorithms to arrange elements in a specific order",
+                "key_concepts": ["Comparison sorting", "Time complexity", "Space complexity", "Stability", "In-place sorting"],
+                "learning_path": [
+                    "Learn basic sorting algorithms (bubble, selection, insertion)",
+                    "Master efficient sorting algorithms (merge, quick, heap)",
+                    "Understand time and space complexity analysis",
+                    "Practice sorting-based problems",
+                    "Learn specialized sorting techniques"
+                ],
+                "time_estimate": "2-3 weeks",
+                "connects_to": ["Arrays", "Divide and Conquer", "Heaps", "Searching", "Trees"],
+                "important_problems": [
+                    "Merge Intervals", "Sort Colors", "Kth Largest Element", "Meeting Rooms", "Largest Number"
+                ]
+            },
+            "Searching": {
+                "difficulty": "Intermediate",
+                "prerequisites": ["Arrays", "Recursion", "Sorting"],
+                "description": "Algorithms to find specific elements in data structures",
+                "key_concepts": ["Linear search", "Binary search", "Search space", "Invariants", "Applications"],
+                "learning_path": [
+                    "Learn linear search and its applications",
+                    "Master binary search and its variants",
+                    "Practice search in rotated/modified arrays",
+                    "Learn search in 2D arrays and matrices",
+                    "Solve complex search problems"
+                ],
+                "time_estimate": "2-3 weeks",
+                "connects_to": ["Arrays", "Sorting", "Trees", "Graphs", "Two Pointers"],
+                "important_problems": [
+                    "Binary Search", "Find First and Last Position", "Search in Rotated Array", "Find Peak Element", "Search 2D Matrix"
+                ]
+            },
+            "Trees": {
+                "difficulty": "Intermediate",
+                "prerequisites": ["Linked Lists", "Recursion", "Stacks", "Queues"],
+                "description": "Hierarchical data structure with nodes connected by edges",
+                "key_concepts": ["Root", "Leaves", "Height", "Depth", "Traversals", "Binary trees"],
+                "learning_path": [
+                    "Learn tree terminology and concepts",
+                    "Master tree traversals (inorder, preorder, postorder)",
+                    "Practice binary tree problems",
+                    "Learn binary search trees (BST)",
+                    "Solve advanced tree problems"
+                ],
+                "time_estimate": "3-4 weeks",
+                "connects_to": ["Graphs", "Heaps", "Tries", "Dynamic Programming", "DFS", "BFS"],
+                "important_problems": [
+                    "Maximum Depth of Binary Tree", "Validate Binary Search Tree", "Lowest Common Ancestor", "Binary Tree Level Order Traversal", "Serialize and Deserialize Binary Tree"
+                ]
+            },
+            "Graphs": {
+                "difficulty": "Advanced",
+                "prerequisites": ["Trees", "Queues", "Stacks", "Recursion"],
+                "description": "Non-linear data structure consisting of vertices and edges",
+                "key_concepts": ["Vertices", "Edges", "Directed/Undirected", "Weighted/Unweighted", "Representation"],
+                "learning_path": [
+                    "Learn graph terminology and representation",
+                    "Master graph traversals (DFS, BFS)",
+                    "Practice basic graph problems",
+                    "Learn shortest path algorithms",
+                    "Solve complex graph problems"
+                ],
+                "time_estimate": "4-5 weeks",
+                "connects_to": ["Trees", "DFS", "BFS", "Dynamic Programming", "Greedy Algorithms"],
+                "important_problems": [
+                    "Clone Graph", "Number of Islands", "Course Schedule", "Shortest Path in Binary Matrix", "Word Ladder"
+                ]
+            },
+            "Dynamic Programming": {
+                "difficulty": "Advanced",
+                "prerequisites": ["Arrays", "Recursion", "Trees"],
+                "description": "Optimization technique using memoization to solve overlapping subproblems",
+                "key_concepts": ["Optimal substructure", "Overlapping subproblems", "Memoization", "Tabulation", "State transitions"],
+                "learning_path": [
+                    "Understand DP concepts and when to use",
+                    "Learn basic DP patterns (fibonacci, climbing stairs)",
+                    "Practice 1D DP problems",
+                    "Master 2D DP problems",
+                    "Solve complex DP problems"
+                ],
+                "time_estimate": "4-6 weeks",
+                "connects_to": ["Arrays", "Strings", "Trees", "Graphs", "Greedy Algorithms"],
+                "important_problems": [
+                    "Climbing Stairs", "House Robber", "Coin Change", "Longest Common Subsequence", "Edit Distance"
+                ]
+            },
+            "Hashing": {
+                "difficulty": "Intermediate",
+                "prerequisites": ["Arrays", "Strings"],
+                "description": "Technique for fast data retrieval using hash functions",
+                "key_concepts": ["Hash functions", "Hash tables", "Collision resolution", "Load factor", "Applications"],
+                "learning_path": [
+                    "Learn hash function concepts",
+                    "Understand hash table implementation",
+                    "Practice basic hashing problems",
+                    "Learn collision resolution techniques",
+                    "Master advanced hashing applications"
+                ],
+                "time_estimate": "2-3 weeks",
+                "connects_to": ["Arrays", "Strings", "Sets", "Maps", "Caching"],
+                "important_problems": [
+                    "Two Sum", "Group Anagrams", "First Non-Repeating Character", "Longest Substring Without Repeating Characters", "Design HashSet"
+                ]
+            },
+            "Heaps": {
+                "difficulty": "Advanced",
+                "prerequisites": ["Trees", "Arrays", "Sorting"],
+                "description": "Complete binary tree with heap property (min-heap or max-heap)",
+                "key_concepts": ["Heap property", "Heapify", "Priority queue", "Heap operations", "Applications"],
+                "learning_path": [
+                    "Learn heap concepts and properties",
+                    "Implement heap operations",
+                    "Practice basic heap problems",
+                    "Master priority queue applications",
+                    "Solve complex heap problems"
+                ],
+                "time_estimate": "2-3 weeks",
+                "connects_to": ["Trees", "Sorting", "Graphs", "Greedy Algorithms", "Priority Queues"],
+                "important_problems": [
+                    "Kth Largest Element", "Merge K Sorted Lists", "Top K Frequent Elements", "Find Median from Data Stream", "Task Scheduler"
+                ]
+            },
+            "Tries": {
+                "difficulty": "Advanced",
+                "prerequisites": ["Trees", "Strings"],
+                "description": "Tree-like data structure for storing strings efficiently",
+                "key_concepts": ["Prefix tree", "Autocomplete", "Word search", "Memory optimization", "Applications"],
+                "learning_path": [
+                    "Learn trie structure and operations",
+                    "Implement basic trie functionality",
+                    "Practice word-based problems",
+                    "Master prefix matching applications",
+                    "Solve complex trie problems"
+                ],
+                "time_estimate": "2-3 weeks",
+                "connects_to": ["Trees", "Strings", "DFS", "Backtracking"],
+                "important_problems": [
+                    "Implement Trie", "Word Search II", "Design Add and Search Words", "Longest Word in Dictionary", "Replace Words"
+                ]
+            },
+            "Two Pointers": {
+                "difficulty": "Intermediate",
+                "prerequisites": ["Arrays", "Strings", "Sorting"],
+                "description": "Technique using two pointers to solve problems efficiently",
+                "key_concepts": ["Left-right pointers", "Fast-slow pointers", "Sliding window", "Meet in middle", "Optimization"],
+                "learning_path": [
+                    "Learn two-pointer technique basics",
+                    "Practice left-right pointer problems",
+                    "Master fast-slow pointer technique",
+                    "Learn sliding window applications",
+                    "Solve complex two-pointer problems"
+                ],
+                "time_estimate": "2-3 weeks",
+                "connects_to": ["Arrays", "Strings", "Linked Lists", "Sorting", "Searching"],
+                "important_problems": [
+                    "Two Sum II", "3Sum", "Container With Most Water", "Trapping Rain Water", "Longest Substring Without Repeating Characters"
+                ]
+            },
+            "Greedy Algorithms": {
+                "difficulty": "Advanced",
+                "prerequisites": ["Sorting", "Arrays", "Graphs"],
+                "description": "Problem-solving technique making locally optimal choices",
+                "key_concepts": ["Greedy choice", "Local optimization", "Proof techniques", "Activity selection", "Optimization"],
+                "learning_path": [
+                    "Learn greedy algorithm concepts",
+                    "Practice basic greedy problems",
+                    "Master interval scheduling problems",
+                    "Learn graph-based greedy algorithms",
+                    "Solve complex greedy problems"
+                ],
+                "time_estimate": "3-4 weeks",
+                "connects_to": ["Sorting", "Graphs", "Dynamic Programming", "Heaps"],
+                "important_problems": [
+                    "Activity Selection", "Fractional Knapsack", "Minimum Spanning Tree", "Huffman Coding", "Gas Station"
+                ]
+            },
+            "Backtracking": {
+                "difficulty": "Advanced",
+                "prerequisites": ["Recursion", "Trees", "Arrays"],
+                "description": "Algorithmic technique for finding solutions by exploring all possibilities",
+                "key_concepts": ["State space", "Pruning", "Constraint satisfaction", "Recursive exploration", "Optimization"],
+                "learning_path": [
+                    "Learn backtracking concepts",
+                    "Practice basic backtracking problems",
+                    "Master constraint satisfaction problems",
+                    "Learn optimization techniques",
+                    "Solve complex backtracking problems"
+                ],
+                "time_estimate": "3-4 weeks",
+                "connects_to": ["Recursion", "Trees", "Graphs", "Dynamic Programming"],
+                "important_problems": [
+                    "N-Queens", "Sudoku Solver", "Word Search", "Combination Sum", "Palindrome Partitioning"
+                ]
+            },
+            "Divide and Conquer": {
+                "difficulty": "Advanced",
+                "prerequisites": ["Recursion", "Sorting", "Arrays"],
+                "description": "Problem-solving technique dividing problems into smaller subproblems",
+                "key_concepts": ["Divide", "Conquer", "Combine", "Recurrence relations", "Master theorem"],
+                "learning_path": [
+                    "Learn divide and conquer concepts",
+                    "Practice basic divide and conquer problems",
+                    "Master sorting algorithms using D&C",
+                    "Learn advanced applications",
+                    "Analyze time complexity"
+                ],
+                "time_estimate": "3-4 weeks",
+                "connects_to": ["Recursion", "Sorting", "Trees", "Dynamic Programming"],
+                "important_problems": [
+                    "Merge Sort", "Quick Sort", "Maximum Subarray", "Closest Pair of Points", "Strassen's Matrix Multiplication"
+                ]
+            }
+        }
+    
+    def get_topic_roadmap(self, topic_name: str) -> str:
+        """Generate detailed roadmap for a specific topic"""
+        if topic_name not in self.topics_data:
+            return "❌ Topic not found! Please select a valid topic."
+        
+        topic = self.topics_data[topic_name]
+        
+        # Build the roadmap string
+        roadmap = f"""
+# 🎯 {topic_name} Learning Roadmap
+
+## 📊 Overview
+**Difficulty Level:** {topic['difficulty']}  
+**Estimated Time:** {topic['time_estimate']}  
+**Description:** {topic['description']}
+
+## 🔗 Prerequisites
+"""
+        
+        if topic['prerequisites']:
+            roadmap += "**You should learn these topics first:**\n"
+            for prereq in topic['prerequisites']:
+                roadmap += f"• {prereq}\n"
+        else:
+            roadmap += "**Great news!** This is a foundational topic - no prerequisites needed! 🎉\n"
+        
+        roadmap += f"""
+## 🗺️ Learning Path
+**Follow this step-by-step approach:**
+
+"""
+        
+        for i, step in enumerate(topic['learning_path'], 1):
+            roadmap += f"{i}. {step}\n"
+        
+        roadmap += f"""
+## 🔑 Key Concepts to Master
+"""
+        for concept in topic['key_concepts']:
+            roadmap += f"• {concept}\n"
+        
+        roadmap += f"""
+## 💡 Important Problems to Practice
+"""
+        for problem in topic['important_problems']:
+            roadmap += f"• {problem}\n"
+        
+        roadmap += f"""
+## 🌐 Connected Topics
+**After mastering {topic_name}, you'll be ready for:**
+"""
+        for connected in topic['connects_to']:
+            roadmap += f"• {connected}\n"
+        
+        return roadmap
+    
+    def get_prerequisites_chain(self, topic_name: str) -> str:
+        """Get the complete prerequisite chain for a topic"""
+        if topic_name not in self.topics_data:
+            return "❌ Topic not found!"
+        
+        visited = set()
+        chain = []
+        
+        def dfs_prerequisites(topic):
+            if topic in visited or topic not in self.topics_data:
+                return
+            
+            visited.add(topic)
+            
+            # Add prerequisites first
+            for prereq in self.topics_data[topic]['prerequisites']:
+                dfs_prerequisites(prereq)
+            
+            chain.append(topic)
+        
+        dfs_prerequisites(topic_name)
+        
+        if len(chain) <= 1:
+            return f"🎉 **{topic_name}** is a foundational topic - you can start learning it right away!"
+        
+        result = f"📚 **Complete Learning Path to Master {topic_name}:**\n\n"
+        
+        for i, topic in enumerate(chain, 1):
+            difficulty = self.topics_data[topic]['difficulty']
+            time_est = self.topics_data[topic]['time_estimate']
+            
+            if i == len(chain):
+                result += f"🎯 **{i}. {topic}** (Your Target!)  \n"
+            else:
+                result += f"📖 **{i}. {topic}**  \n"
+            
+            result += f"   *Difficulty: {difficulty} | Time: {time_est}*\n\n"
+        
+        total_topics = len(chain)
+        result += f"**Total Topics to Cover:** {total_topics}\n"
+        result += f"**Estimated Total Time:** {self._estimate_total_time(chain)}\n"
+        
+        return result
+    
+    def _estimate_total_time(self, chain: List[str]) -> str:
+        """Estimate total time needed for a chain of topics"""
+        total_weeks = 0
+        for topic in chain:
+            time_str = self.topics_data[topic]['time_estimate']
+            # Extract weeks from string like "2-3 weeks"
+            weeks = time_str.split()[0].split('-')
+            avg_weeks = (int(weeks[0]) + int(weeks[-1])) / 2
+            total_weeks += avg_weeks
+        
+        return f"{int(total_weeks)} weeks"
+    
+    def get_topic_connections(self, topic_name: str) -> str:
+        """Show how a topic connects to other topics"""
+        if topic_name not in self.topics_data:
+            return "❌ Topic not found!"
+        
+        topic = self.topics_data[topic_name]
+        
+        result = f"🔗 **Topic Interconnections for {topic_name}**\n\n"
+        
+        # Prerequisites
+        result += "**📚 Prerequisites (Learn these first):**\n"
+        if topic['prerequisites']:
+            for prereq in topic['prerequisites']:
+                result += f"• {prereq}\n"
+        else:
+            result += "• None - This is a foundational topic! 🎉\n"
+        
+        # What connects to this topic
+        result += f"\n**➡️ What {topic_name} enables:**\n"
+        for connected in topic['connects_to']:
+            result += f"• {connected}\n"
+        
+        # Find what topics depend on this one
+        dependents = []
+        for other_topic, other_data in self.topics_data.items():
+            if topic_name in other_data['prerequisites']:
+                dependents.append(other_topic)
+        
+        if dependents:
+            result += f"\n**🎯 Topics that require {topic_name}:**\n"
+            for dependent in dependents:
+                result += f"• {dependent}\n"
+        
+        return result
+    
+    def get_difficulty_based_roadmap(self, difficulty: str) -> str:
+        """Get all topics for a specific difficulty level"""
+        topics_by_difficulty = {
+            'Beginner': [],
+            'Intermediate': [],
+            'Advanced': []
+        }
+        
+        for topic_name, topic_data in self.topics_data.items():
+            topics_by_difficulty[topic_data['difficulty']].append(topic_name)
+        
+        if difficulty not in topics_by_difficulty:
+            return "❌ Invalid difficulty level!"
+        
+        result = f"📊 **{difficulty} Level DSA Topics**\n\n"
+        
+        topics = topics_by_difficulty[difficulty]
+        if not topics:
+            result += "No topics found for this difficulty level."
+            return result
+        
+        for i, topic in enumerate(topics, 1):
+            topic_data = self.topics_data[topic]
+            result += f"**{i}. {topic}**\n"
+            result += f"   *Time: {topic_data['time_estimate']}*\n"
+            result += f"   *{topic_data['description']}*\n\n"
+        
+        return result
+    
+    def get_all_topics_overview(self) -> str:
+        """Get overview of all topics with their relationships"""
+        result = "🗺️ **Complete DSA Topics Overview**\n\n"
+        
+        # Group by difficulty
+        by_difficulty = {'Beginner': [], 'Intermediate': [], 'Advanced': []}
+        for topic, data in self.topics_data.items():
+            by_difficulty[data['difficulty']].append(topic)
+        
+        for difficulty in ['Beginner', 'Intermediate', 'Advanced']:
+            result += f"## {difficulty} Topics\n"
+            for topic in by_difficulty[difficulty]:
+                result += f"• **{topic}** ({self.topics_data[topic]['time_estimate']})\n"
+            result += "\n"
+        
+        result += "**💡 Tips:**\n"
+        result += "• Start with Beginner topics if you're new to DSA\n"
+        result += "• Each topic builds upon previous knowledge\n"
+        result += "• Practice problems regularly to reinforce concepts\n"
+        result += "• Focus on understanding connections between topics\n"
+        
+        return result
+
+# Initialize the DSA roadmap system
+dsa_system = DSALearningRoadmap()
+
+# Get list of all topics for dropdown
+all_topics = list(dsa_system.topics_data.keys())
+difficulty_levels = ['All', 'Beginner', 'Intermediate', 'Advanced']
+
+def generate_roadmap(topic_name):
+    """Generate roadmap for selected topic"""
+    return dsa_system.get_topic_roadmap(topic_name)
+
+def show_prerequisites_chain(topic_name):
+    """Show complete prerequisite chain"""
+    return dsa_system.get_prerequisites_chain(topic_name)
+
+def show_topic_connections(topic_name):
+    """Show topic interconnections"""
+    return dsa_system.get_topic_connections(topic_name)
+
+def show_difficulty_roadmap(difficulty):
+    """Show topics by difficulty"""
+    if difficulty == 'All':
+        return dsa_system.get_all_topics_overview()
+    return dsa_system.get_difficulty_based_roadmap(difficulty)
+
+# Create the Gradio interface
+with gr.Blocks(title="🎯 DSA Learning Roadmap", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # 🎯 DSA Learning Roadmap Generator
+    
+    **Solve the problem of not knowing DSA prerequisites!** 
+    
+    This tool helps you understand:
+    - 📚 What to learn before tackling any DSA topic
+    - 🗺️ Step-by-step learning paths
+    - 🔗 How topics interconnect with each other
+    - ⏱️ Time estimates for mastering each topic
+    
+    Select any topic below to get your personalized roadmap!
+    """)
+    
+    with gr.Tabs():
+        # Tab 1: Individual Topic Roadmap
+        with gr.TabItem("📖 Topic Roadmap"):
+            gr.Markdown("### Get detailed roadmap for any DSA topic")
+            
+            topic_dropdown = gr.Dropdown(
+                choices=all_topics,
+                label="🎯 Select a DSA Topic",
+                value="Arrays",
+                info="Choose any topic to get a complete learning roadmap"
+            )
+            
+            generate_btn = gr.Button("🚀 Generate Roadmap", variant="primary")
+            roadmap_output = gr.Markdown(label="📋 Your Learning Roadmap")
+            
+            generate_btn.click(
+                fn=generate_roadmap,
+                inputs=topic_dropdown,
+                outputs=roadmap_output
+            )
+            
+            # Auto-generate on selection change
+            topic_dropdown.change(
+                fn=generate_roadmap,
+                inputs=topic_dropdown,
+                outputs=roadmap_output
+            )
+        
+        # Tab 2: Prerequisites Chain
+        with gr.TabItem("🔗 Prerequisites Chain"):
+            gr.Markdown("### See the complete learning path to master any topic")
+            
+            prereq_dropdown = gr.Dropdown(
+                choices=all_topics,
+                label="🎯 Select Target Topic",
+                value="Dynamic Programming",
+                info="See everything you need to learn before mastering this topic"
+            )
+            
+            prereq_btn = gr.Button("📚 Show Learning Path", variant="primary")
+            prereq_output = gr.Markdown(label="📋 Complete Learning Path")
+            
+            prereq_btn.click(
+                fn=show_prerequisites_chain,
+                inputs=prereq_dropdown,
+                outputs=prereq_output
+            )
+            
+            prereq_dropdown.change(
+                fn=show_prerequisites_chain,
+                inputs=prereq_dropdown,
+                outputs=prereq_output
+            )
+        
+        # Tab 3: Topic Connections
+        with gr.TabItem("🌐 Topic Connections"):
+            gr.Markdown("### Understand how topics connect to each other")
+            
+            connection_dropdown = gr.Dropdown(
+                choices=all_topics,
+                label="🎯 Select Topic",
+                value="Trees",
+                info="See how this topic connects to other DSA concepts"
+            )
+            
+            connection_btn = gr.Button("🔗 Show Connections", variant="primary")
+            connection_output = gr.Markdown(label="📋 Topic Interconnections")
+            
+            connection_btn.click(
+                fn=show_topic_connections,
+                inputs=connection_dropdown,
+                outputs=connection_output
+            )
+            
+            connection_dropdown.change(
+                fn=show_topic_connections,
+                inputs=connection_dropdown,
+                outputs=connection_output
+            )
+        
+        # Tab 4: Difficulty-based Overview
+        with gr.TabItem("📊 By Difficulty"):
+            gr.Markdown("### Browse topics by difficulty level")
+            
+            difficulty_dropdown = gr.Dropdown(
+                choices=difficulty_levels,
+                label="📈 Select Difficulty Level",
+                value="All",
+                info="View topics grouped by difficulty"
+            )
+            
+            difficulty_btn = gr.Button("📊 Show Topics", variant="primary")
+            difficulty_output = gr.Markdown(label="📋 Topics by Difficulty")
+            
+            difficulty_btn.click(
+                fn=show_difficulty_roadmap,
+                inputs=difficulty_dropdown,
+                outputs=difficulty_output
+            )
+            
+            difficulty_dropdown.change(
+                fn=show_difficulty_roadmap,
+                inputs=difficulty_dropdown,
+                outputs=difficulty_output
+            )
+    
+    # Footer
+    gr.Markdown("""
+    ---
+    ### 💡 How to Use This Tool:
+    1. **Topic Roadmap**: Get detailed learning plan for any specific topic
+    2. **Prerequisites Chain**: See exactly what to learn before your target topic
+    3. **Topic Connections**: Understand how topics relate to each other
+    4. **By Difficulty**: Browse topics based on your current skill level
+    
+    ### 🎯 Pro Tips:
+    - Start with **Beginner** topics if you're new to DSA
+    - Follow the **Prerequisites Chain** for optimal learning order
+    - Practice the **Important Problems** listed in each roadmap
+    - Use **Topic Connections** to plan your learning journey
+    
+    **Happy Learning! 🚀**
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch(share=True)