Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class DijkstraIntroScene(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) - Core concept statement
        # 3. Secondary text: Text - .shift(DOWN * 1.5) - Explanation or description
        # 4. Left elements: Diagram of weighted graph - .shift(LEFT * 2.5) - Visual focus
        # 5. Right elements: Text explanation of initial setup - .shift(RIGHT * 2.5) - Setup explanation

        # --- Step 1: Show Title ---
        title = Text("Understanding Dijkstra's Algorithm").to_edge(UP, buff=0.5).set_color(WHITE)
        self.play(Write(title), run_time=1.5)

        # --- Step 2: Show Main Equation (Concept) ---
        main_eq = MathTex(
            r"\text{Find shortest paths from a start node to all nodes}",
            substrings_to_isolate=["shortest paths"]
        ).shift(UP * 1.5).set_color(WHITE)
        main_eq.set_color_by_tex("shortest paths", YELLOW)
        self.play(Write(main_eq), run_time=2)
        
        # --- Step 3: Show Secondary Text (Intro to shortest path problem) ---
        secondary_text_1 = Text(
            "In weighted graphs, edges have distances.\n"
            "We want the minimum total distance from start to others.",
            font_size=24
        ).shift(DOWN * 1.5).set_color(WHITE)
        self.play(Write(secondary_text_1), run_time=2)
        self.wait(1)
        self.play(FadeOut(secondary_text_1))

        # --- Step 4: Show Diagram of weighted graph (Left) ---
        # Create nodes (dots + labels)
        nodes = {}
        node_coords = {
            "A": np.array([0, 1, 0]),
            "B": np.array([1.5, 2, 0]),
            "C": np.array([2.5, 0.5, 0]),
            "D": np.array([4, 1.5, 0]),
            "E": np.array([4, 0, 0]),
        }
        graph_group = VGroup()
        for name, coord in node_coords.items():
            dot = Dot(coord, color=BLUE)
            label = Text(name, font_size=24).next_to(dot, DOWN)
            nodes[name] = VGroup(dot, label)
            graph_group.add(nodes[name])

        # Create edges with distances (Lines + MathTex)
        edges = VGroup()
        edge_data = [
            ("A", "B", 4),
            ("A", "C", 2),
            ("B", "C", 5),
            ("B", "D", 10),
            ("C", "E", 3),
            ("E", "D", 4),
        ]
        for start, end, dist in edge_data:
            line = Line(nodes[start][0].get_center(), nodes[end][0].get_center(), color=WHITE)
            # Place distance label at midpoint with slight offset
            mid = (nodes[start][0].get_center() + nodes[end][0].get_center()) / 2
            offset = np.array([0, 0.2, 0])
            dist_label = MathTex(str(dist), font_size=24).move_to(mid + offset).set_color(YELLOW)
            edges.add(VGroup(line, dist_label))

        graph_group.add(edges)
        graph_group.shift(LEFT * 2.5)

        self.play(Create(graph_group), run_time=3)

        # --- Step 5: Show Explanation of initial setup (Right) ---
        setup_text = Text(
            "Start node: A (distance = 0)\n"
            "Other nodes: distance = ∞ (tentative)\n"
            "Visited nodes: finalized distances\n"
            "Unvisited nodes: tentative distances",
            font_size=24,
            t2c={"A": RED, "0": RED, "∞": YELLOW}
        ).shift(RIGHT * 2.5).set_color(WHITE)
        # Highlight "A" and "0" in red, "∞" in yellow
        # (t2c param colors substrings accordingly)

        self.play(Write(setup_text), run_time=3)
        self.wait(2)

        # Highlight starting node A in graph (red circle around A)
        highlight_circle = Circle(radius=0.3, color=RED).move_to(nodes["A"][0].get_center())
        self.play(Create(highlight_circle), run_time=1.5)
        self.wait(1)
        self.play(FadeOut(highlight_circle))

        # --- Transition Text (Secondary text lower center) ---
        self.play(FadeOut(setup_text), FadeOut(graph_group))
        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)

        self.play(Write(transition_text), run_time=3)
        self.wait(2)

        # Final cleanup: fade out transition text and main equation and title
        self.play(FadeOut(transition_text), FadeOut(main_eq), FadeOut(title), run_time=1.5)
```
---

### Explanation of implementation:

- **Title**: Positioned at top edge with `.to_edge(UP, buff=0.5)`.
- **Main equation**: Positioned upper center `.shift(UP * 1.5)`.
- **Secondary text**: Positioned lower center `.shift(DOWN * 1.5)`.
- **Graph diagram**: Positioned left `.shift(LEFT * 2.5)`.
- **Setup explanation text**: Positioned right `.shift(RIGHT * 2.5)`.
- All elements fit within screen bounds.
- Colors limited to BLUE (nodes), RED (start node highlight), YELLOW (distances), WHITE (text and edges).
- Animations only Write, Create, FadeIn, FadeOut.
- Cleanup rules followed: fade out old descriptions before new ones; keep main equation visible until transition; fade out highlights after showing.
- Step progression pattern respected by introducing concepts stepwise.

This plan and code satisfy all strict requirements and positioning rules.
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