Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class DijkstraIntro(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Scene title
        # 2. Main equation: MathTex - .shift(UP * 1.5) - Key formula or concept highlight
        # 3. Secondary text: Text - .shift(DOWN * 1.5) - Explanation or context
        # 4. Left elements: Diagram of weighted graph - .shift(LEFT * 2.5) - Visual focus
        # 5. Right elements: Additional explanation text - .shift(RIGHT * 2.5) - Supporting info

        # 1. Title
        title = Text("Understanding Dijkstra's Algorithm").to_edge(UP, buff=0.5).set_color(WHITE)

        # 2. Main equation (conceptual formula for shortest path problem)
        main_eq = MathTex(
            r"\text{Find shortest paths from } s \text{ to all } v \in V",
            r"\text{ in weighted graph } G=(V,E,w \geq 0)"
        ).shift(UP * 1.5).set_color(BLUE)

        # 3. Secondary text (intro to shortest path problem)
        intro_text = Text(
            "Shortest path problems appear in navigation, routing, and more.",
            font_size=24
        ).shift(DOWN * 1.5).set_color(WHITE)

        # 4. Left element: Weighted graph diagram
        # Create nodes as dots with labels
        nodes = {
            "A": LEFT * 2 + UP * 0.5,
            "B": LEFT * 1 + UP * 1.5,
            "C": LEFT * 0 + UP * 0.5,
            "D": LEFT * 1 + DOWN * 0.5,
            "E": LEFT * 2 + DOWN * 1.5,
        }
        dots = VGroup()
        labels = VGroup()
        for name, pos in nodes.items():
            dot = Dot(pos=pos, color=YELLOW)
            label = Text(name, font_size=24).next_to(dot, DOWN)
            dots.add(dot)
            labels.add(label)

        # Edges with weights (Lines + MathTex for weights)
        edges = VGroup()
        weights = VGroup()
        # Edges: (start, end, weight)
        edge_data = [
            ("A", "B", 4),
            ("A", "D", 1),
            ("B", "C", 1),
            ("B", "D", 2),
            ("C", "E", 3),
            ("D", "E", 8),
            ("D", "C", 5),
        ]
        for start, end, w in edge_data:
            line = Line(nodes[start], nodes[end], color=WHITE)
            edges.add(line)
            # Place weight label at midpoint shifted slightly perpendicular
            midpoint = (nodes[start] + nodes[end]) / 2
            direction = (nodes[end] - nodes[start])
            perp = np.array([-direction[1], direction[0], 0])
            perp = perp / np.linalg.norm(perp) * 0.2
            weight_label = MathTex(str(w)).set_color(RED).move_to(midpoint + perp)
            weights.add(weight_label)

        graph_group = VGroup(edges, dots, labels, weights).shift(LEFT * 2.5)

        # 5. Right element: Explanation text about Dijkstra's algorithm
        explanation = Text(
            "Dijkstra's algorithm finds shortest paths\n"
            "from a start node to all others in a graph\n"
            "with non-negative edge weights.",
            font_size=24,
            line_spacing=1.2
        ).shift(RIGHT * 2.5).set_color(GREEN)

        # Animation Sequence:

        # Step 1: Show title and intro text
        self.play(Write(title), Write(intro_text), run_time=2)
        self.wait(1)
        self.play(FadeOut(intro_text))

        # Step 2: Show main equation and title (title stays)
        self.play(Write(main_eq), run_time=2)
        self.wait(1)

        # Step 3: Show graph diagram on left and explanation on right, keep title and main_eq
        self.play(Create(graph_group), Write(explanation), run_time=3)
        self.wait(2)

        # Step 4: Transition text at bottom (secondary text) about next step
        transition_text = Text(
            "Now that we know what problem Dijkstra's algorithm addresses,\n"
            "let's explore how the algorithm works step-by-step.",
            font_size=24
        ).shift(DOWN * 1.5).set_color(WHITE)

        # Fade out explanation and graph, keep title and main_eq
        self.play(FadeOut(graph_group), FadeOut(explanation))
        self.play(Write(transition_text), run_time=2)
        self.wait(2)

        # Final cleanup: fade out transition text, keep title and main_eq visible
        self.play(FadeOut(transition_text))
        self.wait(1)
```

PATTERN: step_progression

CRITICAL CONSTRAINTS:
1. Use ONLY these objects: Text, MathTex, Axes, Circle, Rectangle, Line, Arrow, Dot, SurroundingRectangle, VGroup
2. Use ONLY these animations: Write, Create, FadeIn, FadeOut 
3. Use ONLY these colors (no quotes): BLUE, RED, GREEN, YELLOW, WHITE, ORANGE, PURPLE
4. NO undefined objects like VideoFile, Slider, ImageMobject
5. NO Unicode characters - use LaTeX: \sqrt{} not √, \pm not ±

POSITIONING REQUIREMENTS (CRITICAL):
- Each element MUST have unique position within screen bounds
- SAFE positions only: .to_edge(UP), .shift(UP*1.5), .shift(DOWN*1.5), .shift(LEFT*2.5), .shift(RIGHT*2.5)
- NO extreme shifts: avoid UP*3, DOWN*3, LEFT*4, RIGHT*4 (goes off-screen)
- NO overlapping: if one element uses .shift(UP*1.5), others must use different positions
- Test positions: Title=top, Main=upper center, Secondary=lower center, Sides=left/right

TEMPLATE TO ADAPT:

        # Title at top
        title = Text("{title}").scale(0.8).to_edge(UP, buff=0.5)
        
        # Step equations positioned vertically
        step1 = MathTex(r"{step1}").shift(UP * 2)
        step2 = MathTex(r"{step2}").shift(UP * 0.5)  
        step3 = MathTex(r"{step3}").shift(DOWN * 1)
        
        # Step labels on the right
        label1 = Text("{label1}").scale(0.5).shift(RIGHT * 4 + UP * 2)
        label2 = Text("{label2}").scale(0.5).shift(RIGHT * 4 + UP * 0.5)
        label3 = Text("{label3}").scale(0.5).shift(RIGHT * 4 + DOWN * 1)
        
        # Progressive revelation
        self.play(Write(title))
        self.wait(1)
        self.play(Write(step1))
        self.wait(1)
        self.play(Write(label1))
        self.wait(1)
        self.play(Write(step2))
        self.wait(1)
        self.play(Write(label2))
        self.wait(1)
        self.play(Write(step3))
        self.wait(1)
        self.play(Write(label3))
        self.wait(2)
                

Replace placeholders with scene-specific values and ensure working Manim code.

Generate complete Python code:
SMART POSITIONING REQUIREMENTS:
- Analyze the content TYPE first: equation, diagram, comparison, process
- Position based on content meaning, not just arbitrary rules
- Main subject (equation/diagram) should be CENTER or slightly UP
- Supporting text should be BELOW the main subject
- Comparisons should use LEFT/RIGHT positioning
- Sequential content should use TOP-to-BOTTOM flow
- NEVER fade out main content - only temporary highlights

CAREFULLY IMPLEMENT THIS