數獨解題技巧完全指南：從基礎到專家級策略Complete Sudoku Strategies Guide: From Basics to Expert Level

Easy

技巧 1：裸單數（Naked Singles）Technique 1: Naked Singles

定義：Definition: 某個格子的候選數只剩下一個數字，直接填入。A cell has only one candidate left, fill it in directly.

識別方法：Identification: 檢查每個空格，找出候選數列表只有一個數字的格子。Check each empty cell, find cells with only one number in the candidate list.

使用頻率：Usage Frequency: ⭐⭐⭐⭐⭐（每個數獨都會用到）⭐⭐⭐⭐⭐ (Used in every Sudoku)

function findNakedSingles(grid, candidates) {
    const singles = [];

    for (let row = 0; row < 9; row++) {
        for (let col = 0; col < 9; col++) {
            // 跳過已填充的格子
            if (grid[row][col] !== 0) continue;

            // 計算候選數數量
            const possibleValues = candidates[row][col];

            if (possibleValues.size === 1) {
                // 找到裸單數
                const value = Array.from(possibleValues)[0];
                singles.push({
                    row: row,
                    col: col,
                    value: value,
                    technique: 'Naked Single'
                });
            }
        }
    }

    return singles;
}

// 應用裸單數
function applyNakedSingle(grid, candidates, row, col, value) {
    // 填入數字
    grid[row][col] = value;

    // 從行中移除候選數
    for (let c = 0; c < 9; c++) {
        candidates[row][c].delete(value);
    }

    // 從列中移除候選數
    for (let r = 0; r < 9; r++) {
        candidates[r][col].delete(value);
    }

    // 從宮格中移除候選數
    const boxRow = Math.floor(row / 3) * 3;
    const boxCol = Math.floor(col / 3) * 3;
    for (let r = boxRow; r < boxRow + 3; r++) {
        for (let c = boxCol; c < boxCol + 3; c++) {
            candidates[r][c].delete(value);
        }
    }
}

Easy

技巧 2：隱藏單數（Hidden Singles）Technique 2: Hidden Singles

定義：Definition: 在某行、列或宮格中，某個數字只能放在一個位置。In a row, column, or box, a number can only go in one position.

識別方法：Identification: 對每個數字（1-9），檢查在某個區域內是否只有一個格子可以放置。For each number (1-9), check if only one cell in an area can hold it.

使用頻率：Usage Frequency: ⭐⭐⭐⭐⭐（基礎中的基礎）⭐⭐⭐⭐⭐ (Most fundamental technique)

function findHiddenSingles(grid, candidates) {
    const singles = [];

    // 檢查每個數字 1-9
    for (let num = 1; num <= 9; num++) {
        // 檢查每行
        for (let row = 0; row < 9; row++) {
            const positions = [];
            for (let col = 0; col < 9; col++) {
                if (grid[row][col] === 0 &&
                    candidates[row][col].has(num)) {
                    positions.push(col);
                }
            }

            // 只有一個位置可以放置
            if (positions.length === 1) {
                singles.push({
                    row: row,
                    col: positions[0],
                    value: num,
                    technique: 'Hidden Single (Row)',
                    unit: `Row ${row + 1}`
                });
            }
        }

        // 檢查每列
        for (let col = 0; col < 9; col++) {
            const positions = [];
            for (let row = 0; row < 9; row++) {
                if (grid[row][col] === 0 &&
                    candidates[row][col].has(num)) {
                    positions.push(row);
                }
            }

            if (positions.length === 1) {
                singles.push({
                    row: positions[0],
                    col: col,
                    value: num,
                    technique: 'Hidden Single (Column)',
                    unit: `Column ${col + 1}`
                });
            }
        }

        // 檢查每個宮格
        for (let box = 0; box < 9; box++) {
            const boxRow = Math.floor(box / 3) * 3;
            const boxCol = (box % 3) * 3;
            const positions = [];

            for (let r = boxRow; r < boxRow + 3; r++) {
                for (let c = boxCol; c < boxCol + 3; c++) {
                    if (grid[r][c] === 0 &&
                        candidates[r][c].has(num)) {
                        positions.push({row: r, col: c});
                    }
                }
            }

            if (positions.length === 1) {
                singles.push({
                    row: positions[0].row,
                    col: positions[0].col,
                    value: num,
                    technique: 'Hidden Single (Box)',
                    unit: `Box ${box + 1}`
                });
            }
        }
    }

    return singles;
}

Medium

技巧 3：裸對（Naked Pairs）Technique 3: Naked Pairs

定義：Definition: 在同一區域內，兩個格子的候選數完全相同且只有兩個數字，可以從其他格子中排除這兩個數字。In the same region, two cells have exactly the same two candidates, allowing elimination of these numbers from other cells.

範例：Example: 如果 R1C1 和 R1C3 都只能是 {2, 5}，則第1行的其他格子不能是 2 或 5。If R1C1 and R1C3 can only be {2, 5}, other cells in row 1 cannot be 2 or 5.

使用頻率：Usage Frequency: ⭐⭐⭐⭐

function findNakedPairs(candidates) {
    const eliminations = [];

    // 檢查每行
    for (let row = 0; row < 9; row++) {
        const pairs = findPairsInRow(candidates, row);
        for (const pair of pairs) {
            const [col1, col2, values] = pair;

            // 從同行其他格子中移除這兩個值
            for (let col = 0; col < 9; col++) {
                if (col !== col1 && col !== col2) {
                    for (const val of values) {
                        if (candidates[row][col].has(val)) {
                            eliminations.push({
                                row: row,
                                col: col,
                                value: val,
                                technique: 'Naked Pair',
                                pairCells: [[row, col1], [row, col2]]
                            });
                        }
                    }
                }
            }
        }
    }

    // 類似地檢查列和宮格...
    return eliminations;
}

function findPairsInRow(candidates, row) {
    const pairs = [];
    const cells = [];

    // 收集只有兩個候選數的格子
    for (let col = 0; col < 9; col++) {
        if (candidates[row][col].size === 2) {
            cells.push({
                col: col,
                values: Array.from(candidates[row][col])
            });
        }
    }

    // 找出候選數相同的配對
    for (let i = 0; i < cells.length; i++) {
        for (let j = i + 1; j < cells.length; j++) {
            const vals1 = cells[i].values;
            const vals2 = cells[j].values;

            if (vals1[0] === vals2[0] && vals1[1] === vals2[1]) {
                pairs.push([
                    cells[i].col,
                    cells[j].col,
                    vals1
                ]);
            }
        }
    }

    return pairs;
}

Medium

技巧 4：隱藏對（Hidden Pairs）Technique 4: Hidden Pairs

定義：Definition: 在某個區域內，兩個數字只能放在同樣的兩個格子中，可以從這兩個格子中排除其他候選數。In a region, two numbers can only go in the same two cells, allowing elimination of other candidates from those cells.

範例：Example: 如果數字 3 和 7 在第一行只能放在 C2 和 C5，則 R1C2 和 R1C5 的其他候選數都可以刪除。If numbers 3 and 7 in row 1 can only go in C2 and C5, other candidates in R1C2 and R1C5 can be eliminated.

使用頻率：Usage Frequency: ⭐⭐⭐

Medium

技巧 5：指向對（Pointing Pairs）Technique 5: Pointing Pairs

定義：Definition: 在某個宮格內，某個數字只能放在同一行或同一列，可以從該行或列的其他宮格中排除這個數字。In a box, a number can only go in the same row or column, allowing elimination from other boxes in that row or column.

範例：Example: 如果宮格1中的數字 4 只能放在第1行，則第1行其他宮格中的 4 都可以刪除。If number 4 in box 1 can only go in row 1, then 4 can be eliminated from other boxes in row 1.

使用頻率：Usage Frequency: ⭐⭐⭐⭐

Hard

技巧 6：X-WingTechnique 6: X-Wing

定義：Definition: 某個數字在兩行中都只能放在相同的兩列，可以從這兩列的其他行中排除該數字。A number can only go in the same two columns in two rows, allowing elimination from other rows in those columns.

識別條件：Identification Conditions:

• 選定一個數字（如 5）Select a number (e.g., 5)
• 在兩個不同的行中，該數字都只能放在相同的兩列In two different rows, the number can only go in the same two columns
• 形成一個矩形模式（4個頂點）Forms a rectangular pattern (4 vertices)

使用頻率：Usage Frequency: ⭐⭐⭐

function findXWing(candidates) {
    const eliminations = [];

    // 對每個數字檢查
    for (let num = 1; num <= 9; num++) {
        // 行中的 X-Wing
        for (let row1 = 0; row1 < 8; row1++) {
            const cols1 = findCandidateColumns(candidates, row1, num);

            // X-Wing 需要恰好兩列
            if (cols1.length !== 2) continue;

            for (let row2 = row1 + 1; row2 < 9; row2++) {
                const cols2 = findCandidateColumns(candidates, row2, num);

                // 檢查是否在相同的兩列
                if (cols2.length === 2 &&
                    cols1[0] === cols2[0] && cols1[1] === cols2[1]) {

                    // 找到 X-Wing！從這兩列的其他行中移除
                    const [col1, col2] = cols1;

                    for (let row = 0; row < 9; row++) {
                        if (row !== row1 && row !== row2) {
                            if (candidates[row][col1].has(num)) {
                                eliminations.push({
                                    row: row,
                                    col: col1,
                                    value: num,
                                    technique: 'X-Wing',
                                    pattern: {
                                        rows: [row1, row2],
                                        cols: [col1, col2]
                                    }
                                });
                            }
                            if (candidates[row][col2].has(num)) {
                                eliminations.push({
                                    row: row,
                                    col: col2,
                                    value: num,
                                    technique: 'X-Wing',
                                    pattern: {
                                        rows: [row1, row2],
                                        cols: [col1, col2]
                                    }
                                });
                            }
                        }
                    }
                }
            }
        }

        // 類似地檢查列中的 X-Wing...
    }

    return eliminations;
}

function findCandidateColumns(candidates, row, num) {
    const columns = [];
    for (let col = 0; col < 9; col++) {
        if (candidates[row][col].has(num)) {
            columns.push(col);
        }
    }
    return columns;
}

Hard

技巧 7：SwordfishTechnique 7: Swordfish

定義：Definition: X-Wing 的擴展版本，使用三行三列而非兩行兩列。Extended version of X-Wing, using three rows and three columns instead of two.

識別條件：Identification Conditions:

• 某個數字在三個行中，最多只能放在相同的三列A number in three rows can only go in the same three columns
• 每行至少在兩列中有該候選數Each row has the candidate in at least two columns
• 形成 3×3 的模式（最多9個頂點）Forms a 3×3 pattern (up to 9 vertices)

使用頻率：Usage Frequency: ⭐⭐（較罕見）⭐⭐ (Relatively rare)

Hard

技巧 8：XY-WingTechnique 8: XY-Wing

定義：Definition: 三個雙候選數格子形成的鏈式結構，可以在特定位置排除候選數。Chain structure formed by three bi-value cells, allowing candidate elimination at specific positions.

結構：Structure:

• 樞紐格（Pivot）：候選數為 {X, Y}Pivot: candidates {X, Y}
• 翼格1（Wing 1）：候選數為 {X, Z}，與樞紐格共享一個區域Wing 1: candidates {X, Z}, shares a unit with pivot
• 翼格2（Wing 2）：候選數為 {Y, Z}，與樞紐格共享一個區域Wing 2: candidates {Y, Z}, shares a unit with pivot
• 排除規則：同時能看到兩個翼格的格子不能是 ZElimination rule: cells seeing both wings cannot be Z

使用頻率：Usage Frequency: ⭐⭐⭐

Expert

技巧 9：簡單著色（Simple Coloring）Technique 9: Simple Coloring

定義：Definition: 對於某個數字，在其候選位置之間建立「強關聯」，然後用兩種顏色標記，根據顏色衝突排除候選數。For a number, establish "strong links" between candidate positions, then mark with two colors, eliminating candidates based on color conflicts.

強關聯：Strong Link: 在某個區域內，某個數字只能放在兩個位置之一。In a region, a number can only go in one of two positions.

規則：Rules:

• 兩個相同顏色的格子不能同時在同一區域（顏色衝突）Two same-colored cells cannot be in the same region (color conflict)
• 能同時看到兩種顏色的格子不能是該數字Cells seeing both colors cannot be that number

使用頻率：Usage Frequency: ⭐⭐

function findSimpleColoring(candidates, num) {
    const eliminations = [];
    const colors = {};  // {cellKey: 'blue' | 'red'}
    const chains = [];

    // 1. 建立強關聯鏈
    for (let row = 0; row < 9; row++) {
        const positions = findCandidateColumns(candidates, row, num);
        if (positions.length === 2) {
            // 強關聯：這兩個位置之一必須是 num
            chains.push({
                type: 'row',
                cells: [
                    {row: row, col: positions[0]},
                    {row: row, col: positions[1]}
                ]
            });
        }
    }

    // 類似地處理列和宮格...

    // 2. 為鏈著色
    for (const chain of chains) {
        colorChain(chain, colors);
    }

    // 3. 檢查顏色衝突規則
    // 規則 1：相同顏色在同一區域 → 該顏色不可能
    for (const color of ['blue', 'red']) {
        if (hasSameColorInUnit(colors, color)) {
            // 排除該顏色的所有格子
            const oppositeColor = color === 'blue' ? 'red' : 'blue';
            for (const [cellKey, cellColor] of Object.entries(colors)) {
                if (cellColor === oppositeColor) {
                    const [row, col] = parseCellKey(cellKey);
                    eliminations.push({
                        row: row,
                        col: col,
                        value: num,
                        technique: 'Simple Coloring (Color Trap)'
                    });
                }
            }
        }
    }

    // 規則 2：能看到兩種顏色 → 不能是該數字
    for (let row = 0; row < 9; row++) {
        for (let col = 0; col < 9; col++) {
            if (!candidates[row][col].has(num)) continue;

            const visibleColors = getVisibleColors(row, col, colors);
            if (visibleColors.has('blue') && visibleColors.has('red')) {
                eliminations.push({
                    row: row,
                    col: col,
                    value: num,
                    technique: 'Simple Coloring (Color Wrap)'
                });
            }
        }
    }

    return eliminations;
}

function colorChain(chain, colors) {
    // 使用 BFS 或 DFS 為連接的格子交替著色
    const queue = [{ cell: chain.cells[0], color: 'blue' }];
    const visited = new Set();

    while (queue.length > 0) {
        const { cell, color } = queue.shift();
        const cellKey = `${cell.row},${cell.col}`;

        if (visited.has(cellKey)) continue;
        visited.add(cellKey);

        colors[cellKey] = color;

        // 找到強關聯的鄰居，使用相反顏色
        const nextColor = color === 'blue' ? 'red' : 'blue';
        // ... 添加鄰居到隊列
    }
}

Expert

技巧 10：強制鏈（Forcing Chains）Technique 10: Forcing Chains

定義：Definition: 追蹤候選數的連鎖效應，如果某個假設導致矛盾或確定結果，則可以做出推論。Track the chain effects of candidates; if an assumption leads to contradiction or certain result, conclusions can be drawn.

類型：Types:

• 鏈收斂：Chain Convergence: 兩個不同的假設導致相同結果Two different assumptions lead to the same result
• 鏈矛盾：Chain Contradiction: 某個假設導致邏輯矛盾An assumption leads to logical contradiction
• 雙重鏈：Double Chain: 兩個鏈的交叉分析Cross-analysis of two chains

使用頻率：Usage Frequency: ⭐（非常罕見，接近猜測）⭐ (Very rare, close to guessing)