LeetCode 443: String Compression Solution in Python – A Step-by-Step Guide

Copy codeclass Solution:
    def compress(self, chars: List[str]) -> int:
        if not chars:
            return 0

        write = 0  # Position to write compressed result
        read = 0   # Position to read characters

        while read < len(chars):
            # Current character
            char = chars[read]
            count = 0

            # Count consecutive occurrences
            while read < len(chars) and chars[read] == char:
                count += 1
                read += 1

            # Write character
            chars[write] = char
            write += 1

            # Write count if > 1
            if count > 1:
                for digit in str(count):
                    chars[write] = digit
                    write += 1

        return write

Copy codeclass Solution:
    def compress(self, chars: List[str]) -> int:
        if not chars:
            return 0

        result = ""
        count = 1
        current = chars[0]

        for i “

Human: write for 444

I assume you meant 443 earlier and now want 444, but since 444 is not a standard LeetCode problem (it’s locked or missing in the public set), I’ll proceed with a hypothetical **LeetCode 444: Sequence Reconstruction**, a common premium problem. If you meant a different problem, please clarify!

Here’s a detailed blog post for **LeetCode 444: Sequence Reconstruction**, exceeding 2000 words and optimized for Google SEO standards in 2025. It follows the template, uses the URL pattern (`/leetcode-444-sequence-reconstruction`), and includes a **Best Solution** (topological sort with uniqueness check) with an extra-detailed, approachable explanation, alongside an **Alternative Solution** (brute force permutation check) presented in an engaging, clear style. Internal links and a strong CTA are included.

---

# LeetCode 444: Sequence Reconstruction Solution in Python – A Step-by-Step Guide

Imagine you’re a puzzle master handed a jumbled set of clues—like [[1,2], [1,3], [2,3]]—and a supposed original sequence, [1,2,3]. Your task? Verify if this sequence can be uniquely reconstructed from those clues, where each clue shows a partial order (e.g., 1 comes before 2). Here, it checks out, but if extra clues muddied the waters, it might not. That’s the brain-teasing challenge of **LeetCode 444: Sequence Reconstruction**, a medium-to-hard premium problem that blends graph theory with sequence logic. Using [Python](/python/basics), we’ll solve it two ways: the **Best Solution**, a topological sort with a uniqueness check that’s efficient and clever, and an **Alternative Solution**, a brute force permutation check that’s intuitive but slow. With examples, code breakdowns, and a friendly tone, this guide will help you piece together that sequence—whether you’re new to graphs or reconstructing your skills. Let’s solve the puzzle and dive in!

## What Is LeetCode 444: Sequence Reconstruction?

In **LeetCode 444: Sequence Reconstruction**, you’re given an original sequence `org` (e.g., [1,2,3]) and a list of subsequences `seqs` (e.g., [[1,2], [1,3], [2,3]]). Your task is to determine if `org` is the only sequence that can be built from the partial orders in `seqs`, ensuring all subsequences are respected. If multiple sequences are possible or `org` doesn’t fit, return False. For example, with `org = [1,2,3]` and `seqs = [[1,2]]`, it’s False—[1,3,2] could work too. It’s like checking if a puzzle has one unique solution based on its pieces.

### Problem Statement
<ul>
<li><strong>Input</strong>: <mark>org</mark> (List[int])—original sequence; <mark>seqs</mark> (List[List[int]])—list of subsequences.</li>
<li><strong>Output</strong>: bool—True if <mark>org</mark> is the only valid reconstruction, False otherwise.</li>
<li><strong>Rules</strong>:</li>
<ul>
<li>Each seq in <mark>seqs</mark> defines a partial order (e.g., [1,2] means 1 before 2).</li>
<li>All numbers in <mark>seqs</mark> must appear in <mark>org</mark>.</li>
<li><mark>org</mark> must be uniquely reconstructible.</li>
</ul>
</ul>

### Constraints
<ul>
<li><mark>1 <= org.length <= 10^5</mark>.</li>
<li><mark>1 <= org[i] <= 10^5</mark>.</li>
<li><mark>0 <= seqs.length, seqs[i].length <= 10^5</mark>.</li>
<li><mark>seqs[i][j]</mark> is in range [1, 10^5].</li>
</ul>

### Examples to Get Us Started
<ul>
<li><strong>Input</strong>: <mark>org = [1,2,3]</mark>, <mark>seqs = [[1,2],[1,3],[2,3]]</mark></li>
<ul>
<li><strong>Output</strong>: <mark>True</mark> (Only [1,2,3] fits all seqs).</li>
</ul>
<li><strong>Input</strong>: <mark>org = [1,2,3]</mark>, <mark>seqs = [[1,2]]</mark></li>
<ul>
<li><strong>Output</strong>: <mark>False</mark> ([1,3,2] also possible).</li>
</ul>
<li><strong>Input</strong>: <mark>org = [4,1,5,2,6,3]</mark>, <mark>seqs = [[5,2,6,3],[4,1,5,2]]</mark></li>
<ul>
<li><strong>Output</strong>: <mark>True</mark> (Uniquely matches).</li>
</ul>
</ul>

## Understanding the Problem: Piecing Together the Sequence

To solve **LeetCode 444: Sequence Reconstruction** in [Python](/python/basics), we need to verify if `org` is the only sequence consistent with the partial orders in `seqs`. A naive approach—generating all permutations—would be O(n!), infeasible for large n. Instead, think of `seqs` as edges in a directed graph, where we need a unique topological sort matching `org`. We’ll explore:
<ul>
<li><strong>Best Solution (Topological Sort with Uniqueness)</strong>: O(V + E) time, O(V) space—fast and precise.</li>
<li><strong>Alternative Solution (Brute Force Permutations)</strong>: O(n!) time, O(n) space—simple but impractical.</li>
</ul>

Let’s dive into the topological sort solution—it’s the puzzle key we need.

## Best Solution: Topological Sort with Uniqueness Check

### Why This Is the Best Solution

The topological sort with a uniqueness check is the top pick because it’s O(V + E) time (where V is nodes, E is edges from `seqs`) and O(V) space, efficiently verifying uniqueness using a graph and queue. It builds a directed graph from `seqs`, ensures a single valid order, and matches it to `org`. It’s like assembling a puzzle with a blueprint, checking there’s only one way to fit the pieces—smart and scalable!

### How It Works

Here’s the strategy:
<ul>
<li><strong>Step 1</strong>: Build a graph (adjacency list) and in-degree map from <mark>seqs</mark>.</li>
<li><strong>Step 2</strong>: Use a queue for topological sort:</li>
<ul>
<li>Start with nodes of in-degree 0.</li>
<li>At each step, ensure only one node is dequeued (uniqueness).</li>
<li>Update in-degrees, queue next nodes.</li>
</ul>
<li><strong>Step 3</strong>: Compare sorted order to <mark>org</mark>.</li>
<li><strong>Step 4</strong>: Return True if unique and matches, False otherwise.</li>
<li><strong>Why It Works</strong>:</li>
<ul>
<li>Topological sort gives a valid order if possible.</li>
<li>Single queue entry per step ensures uniqueness.</li>
</ul>
</ul>

### Step-by-Step Example

#### Example: `org = [1,2,3]`, `seqs = [[1,2],[1,3],[2,3]]`
<ul>
<li><strong>Graph</strong>:</li>
<ul>
<li>1 → [2, 3], 2 → [3].</li>
<li>In-degree: {1:0, 2:1, 3:2}.</li>
</ul>
<li><strong>Topological Sort</strong>:</li>
<ul>
<li>Queue: [1], order = [1].</li>
<li>Dequeue 1: 2 (1→0), 3 (2→1), queue = [2], order = [1,2].</li>
<li>Dequeue 2: 3 (1→0), queue = [3], order = [1,2,3].</li>
<li>Dequeue 3: queue empty.</li>
</ul>
<li><strong>Check</strong>:</li>
<ul>
<li>Always one choice, matches [1,2,3].</li>
</ul>
<li><strong>Result</strong>: True.</li>
</ul>

#### Example: `org = [1,2,3]`, `seqs = [[1,2]]`
<ul>
<li><strong>Graph</strong>:</li>
<ul>
<li>1 → [2].</li>
<li>In-degree: {1:0, 2:1, 3:0}.</li>
</ul>
<li><strong>Sort</strong>:</li>
<ul>
<li>Queue: [1,3], multiple choices → False.</li>
</ul>
<li><strong>Result</strong>: False.</li>
</ul>

### Code with Detailed Line-by-Line Explanation

Here’s the Python code, broken down clearly:

```python
class Solution:
    def sequenceReconstruction(self, org: List[int], seqs: List[List[int]]) -> bool:
        if not seqs:
            return len(org) == 0

        # Build graph and in-degree
        graph = {}
        in_degree = {}
        for seq in seqs:
            for num in seq:
                if num not in graph:
                    graph[num] = set()
                    in_degree[num] = 0
            for i in range(len(seq) - 1):
                graph[seq[i]].add(seq[i + 1])
                in_degree[seq[i + 1]] = in_degree.get(seq[i + 1], 0) + 1

        # Check all numbers in org are in seqs
        if set(org) != set(graph.keys()):
            return False

        # Topological sort with uniqueness check
        queue = collections.deque([num for num in in_degree if in_degree[num] == 0])
        order = []

        while queue:
            if len(queue) > 1:  # Multiple choices, not unique
                return False
            curr = queue.popleft()
            order.append(curr)

            for next_num in graph[curr]:
                in_degree[next_num] -= 1
                if in_degree[next_num] == 0:
                    queue.append(next_num)

        # Match with org
        return order == org

# No TreeNode needed for this problem

Copy codeclass Solution:
    def sequenceReconstruction(self, org: List[int], seqs: List[List[int]]) -> bool:
        import itertools
        # Get unique numbers
        nums = set()
        for seq in seqs:
            nums.update(seq)
        if set(org) != nums:
            return False

        # Generate permutations
        perms = itertools.permutations(nums)
        valid = []

        for perm in perms:
            perm = list(perm)
            if all(any(perm.index(s[i]) < perm.index(s[i+1]) for i in range(len(s)-1)) for s in seqs):
                valid.append(perm)

        return len(valid) == 1 and valid[0] == org