Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class MSTConceptScene(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) - Definition of spanning tree
        # 3. Secondary text: Text - .shift(DOWN * 1.5) - Goal of MST
        # 4. Left elements: Axes + graph nodes/edges - .shift(LEFT * 2.5) - Example graph
        # 5. Right elements: SurroundingRectangle + highlights - .shift(RIGHT * 2.5) - Highlight MST conceptually

        # 1. Title
        title = Text("Minimum Spanning Tree (MST) Concept", color=WHITE).to_edge(UP, buff=0.5)

        # 2. Main equation: Define spanning tree
        spanning_tree_def = MathTex(
            r"\text{Spanning Tree: }",
            r"\text{subset of edges connecting all vertices without cycles}"
        ).shift(UP * 1.5).set_color(WHITE)

        # 3. Secondary text: Goal of MST
        mst_goal = Text(
            "Goal: Find spanning tree with minimum total edge weight",
            color=WHITE
        ).shift(DOWN * 1.5)

        # 4. Left side: Example weighted undirected graph
        # We'll create nodes as Dots with Circles and edges as Lines with weights as Text
        
        # Define nodes positions (within -3.5 to 3.5 vertical, -6 to 6 horizontal)
        node_coords = {
            "A": LEFT * 1 + UP * 1,
            "B": LEFT * 0 + UP * 2,
            "C": RIGHT * 1 + UP * 1,
            "D": LEFT * 0 + DOWN * 1,
            "E": RIGHT * 1 + DOWN * 1,
        }
        # Shift all left elements by LEFT * 2.5
        left_shift = LEFT * 2.5

        # Create nodes (Circles + Dots + labels)
        nodes = VGroup()
        for name, pos in node_coords.items():
            circle = Circle(radius=0.2, color=BLUE)
            dot = Dot(point=pos + left_shift, color=BLUE)
            label = Text(name, color=WHITE).scale(0.5).next_to(dot, DOWN, buff=0.1)
            group = VGroup(circle, dot, label)
            group.move_to(pos + left_shift)
            nodes.add(group)

        # Create edges with weights
        # Edges: (A-B:4), (A-D:7), (B-C:3), (B-D:1), (C-E:5), (D-E:2)
        edges_data = [
            ("A", "B", 4),
            ("A", "D", 7),
            ("B", "C", 3),
            ("B", "D", 1),
            ("C", "E", 5),
            ("D", "E", 2),
        ]
        edges = VGroup()
        weights = VGroup()
        for start, end, w in edges_data:
            start_pos = node_coords[start] + left_shift
            end_pos = node_coords[end] + left_shift
            line = Line(start_pos, end_pos, color=WHITE)
            edges.add(line)
            # Weight label at midpoint, slightly shifted up
            mid = (start_pos + end_pos) / 2 + UP * 0.15
            weight_label = Text(str(w), color=YELLOW).scale(0.5).move_to(mid)
            weights.add(weight_label)

        graph_group = VGroup(edges, nodes, weights)

        # 5. Right side: Highlight MST conceptually
        # We'll highlight edges that form MST: edges with weights 1,2,3,4 (B-D, D-E, B-C, A-B)
        mst_edges = []
        for start, end, w in edges_data:
            if w in [1, 2, 3, 4]:
                start_pos = node_coords[start] + RIGHT * 2.5
                end_pos = node_coords[end] + RIGHT * 2.5
                line = Line(start_pos, end_pos, color=GREEN, stroke_width=6)
                mst_edges.append(line)

        # Also show the same nodes on right side (without circles, just dots and labels)
        right_nodes = VGroup()
        for name, pos in node_coords.items():
            dot = Dot(point=pos + RIGHT * 2.5, color=BLUE)
            label = Text(name, color=WHITE).scale(0.5).next_to(dot, DOWN, buff=0.1)
            group = VGroup(dot, label)
            group.move_to(pos + RIGHT * 2.5)
            right_nodes.add(group)

        mst_highlight = VGroup(*mst_edges, right_nodes)

        # Animation Sequence:

        # 1. Write title
        self.play(Write(title), run_time=1.5)

        # 2. Write main equation (spanning tree definition)
        self.play(Write(spanning_tree_def), run_time=2)
        # Keep title and main equation visible

        # 3. Write secondary text (goal)
        self.play(Write(mst_goal), run_time=2)

        # 4. Show example graph on left
        self.play(Create(graph_group), run_time=3)

        # 5. Show MST highlight on right
        self.play(Create(mst_highlight), run_time=3)

        # Pause to let viewer see MST conceptually
        self.wait(2)

        # 6. Cleanup highlights (fade out MST highlight)
        self.play(FadeOut(mst_highlight), run_time=1)

        # 7. Cleanup example graph and secondary text (fade out)
        self.play(FadeOut(graph_group), FadeOut(mst_goal), run_time=1.5)

        # Title and main equation remain visible

        # 8. Transition text (introduce need for efficient method)
        transition_text = Text(
            "How to efficiently find the MST?\nNext: Kruskal's Algorithm",
            color=WHITE
        ).shift(DOWN * 1.5)
        self.play(Write(transition_text), run_time=2)

        self.wait(2)

        # Final cleanup: fade out everything
        self.play(FadeOut(title), FadeOut(spanning_tree_def), FadeOut(transition_text), run_time=2)
```

PATTERN: function_graph

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)
        
        # Axes positioned in lower area
        axes = Axes(
            x_range=[-3, 3, 1],
            y_range=[-2, 4, 1], 
            x_length=6,
            y_length=4,
            axis_config={{"color": BLUE}}
        ).shift(DOWN * 0.5)
        
        # Function plot
        function = axes.plot(lambda x: {function_expr}, color=RED)
        
        # Equation display
        equation = MathTex(r"{equation}").shift(UP * 1.5)
        
        # Animation sequence
        self.play(Write(title))
        self.wait(1)
        self.play(Write(equation))
        self.wait(1)
        self.play(Create(axes))
        self.wait(1)
        self.play(Create(function))
        self.wait(2)
                

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

Generate complete Python code: