Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class DijkstraProblemScene(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Scene title
        # 2. Diagram: Circles, Lines, Arrows, Text labels - .shift(LEFT * 2.5) - Weighted graph visualization
        # 3. Secondary Text: Text - .shift(RIGHT * 2.5) - Explanation of goal and problem difference
        #
        # Main equation placeholder: MathTex - .shift(UP * 1.5) - To keep visible throughout

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

        # 2. Main equation (kept visible throughout)
        main_eq = MathTex(
            r"\text{Find shortest paths from start node to all others in weighted graph}"
        ).shift(UP * 1.5).set_color(BLUE)

        # 3. Diagram (weighted graph) on left side
        # Create nodes as Circles with labels
        nodes = {}
        node_positions = {
            "A": LEFT * 2 + UP * 1,
            "B": LEFT * 1 + UP * 0,
            "C": LEFT * 3 + DOWN * 0.5,
            "D": LEFT * 1 + DOWN * 1.5,
            "E": LEFT * 3 + DOWN * 2,
        }
        for name, pos in node_positions.items():
            nodes[name] = Circle(radius=0.3, color=GREEN).move_to(pos)
        # Node labels
        node_labels = {
            name: Text(name, color=WHITE).move_to(nodes[name].get_center())
            for name in nodes
        }

        # Edges with weights (Lines + MathTex for weights)
        edges = []
        weights = {
            ("A", "B"): 4,
            ("A", "C"): 2,
            ("B", "C"): 5,
            ("B", "D"): 10,
            ("C", "E"): 3,
            ("E", "D"): 4,
        }
        for (start, end), w in weights.items():
            line = Line(nodes[start].get_center(), nodes[end].get_center(), color=WHITE)
            edges.append(line)
        # Weight labels positioned midway + slight offset
        weight_labels = []
        for (start, end), w in weights.items():
            start_pos = nodes[start].get_center()
            end_pos = nodes[end].get_center()
            mid = (start_pos + end_pos) / 2
            offset = UP * 0.2
            weight_label = MathTex(str(w), color=YELLOW).move_to(mid + offset)
            weight_labels.append(weight_label)

        # Group diagram elements and shift left side
        diagram_group = VGroup(*edges, *nodes.values(), *node_labels.values(), *weight_labels).shift(LEFT * 2.5)

        # 4. Secondary text on right side
        secondary_text_1 = Text(
            "Goal: Find shortest path\nfrom start node to all others",
            color=WHITE
        ).shift(RIGHT * 2.5 + UP * 0.5)
        secondary_text_2 = Text(
            "Unweighted vs Weighted:\nUnweighted - shortest path = fewest edges\nWeighted - shortest path = minimum sum of edge weights",
            color=WHITE
        ).shift(RIGHT * 2.5 + DOWN * 0.5)

        # Animation Sequence:

        # Step 1: Write title (keep visible)
        self.play(Write(title), run_time=2)

        # Step 2: Write main equation (keep visible)
        self.play(Write(main_eq), run_time=2)

        # Step 3: Create diagram on left side
        self.play(Create(diagram_group), run_time=3)

        # Step 4: Write secondary text 1 (fade out old secondary if any)
        self.play(Write(secondary_text_1), run_time=2)

        # Step 5: FadeOut secondary_text_1, Write secondary_text_2
        self.play(FadeOut(secondary_text_1), Write(secondary_text_2), run_time=2)

        # Step 6: FadeOut diagram and secondary_text_2, keep title and main_eq
        self.play(FadeOut(diagram_group), FadeOut(secondary_text_2), run_time=2)

        # Step 7: Show transition text (secondary text style) on right side
        transition_text = Text(
            "Having understood the problem,\nnext we explore how Dijkstra’s algorithm\napproaches solving it step-by-step.",
            color=WHITE
        ).shift(RIGHT * 2.5)
        self.play(Write(transition_text), run_time=3)

        # Final cleanup: FadeOut transition text, keep title and main_eq visible
        self.play(FadeOut(transition_text), run_time=2)
```
---

**Explanation:**

- Title is positioned `.to_edge(UP, buff=0.5)` at top edge.
- Main equation is `.shift(UP * 1.5)` at upper center, kept visible throughout.
- Diagram (nodes, edges, weights) grouped and shifted `.shift(LEFT * 2.5)` on left side.
- Secondary texts appear on right side `.shift(RIGHT * 2.5)`, split into two parts for clarity.
- All elements fit within the allowed coordinate range.
- Animations use only Write, Create, FadeIn, FadeOut.
- Colors limited to BLUE (main eq), WHITE (text, edges), GREEN (nodes), YELLOW (weights).
- Cleanup rules followed: fade out old secondary texts before new ones, fade out diagram before transition text.
- Main equation and title remain visible except at final cleanup where only they remain.
- Transition text placed on right side as secondary text.

This plan strictly follows the positioning and object/animation/color constraints.
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