เขาวงกตบนตาราง N โดย N ของเซลล์สี่เหลี่ยมถูกกำหนดโดยระบุว่าขอบแต่ละด้านเป็นผนังหรือไม่กับผนัง ขอบด้านนอกทั้งหมดเป็นผนัง เซลล์หนึ่งถูกกำหนดให้เป็นจุดเริ่มต้นและเซลล์หนึ่งถูกกำหนดให้เป็นทางออกและทางออกสามารถเข้าถึงได้ตั้งแต่เริ่มต้น การเริ่มต้นและการออกจะไม่เหมือนเดิม

โปรดทราบว่าทั้งการเริ่มต้นและการออกไม่จำเป็นต้องอยู่บนขอบด้านนอกของเขาวงกตดังนั้นนี่คือเขาวงกตที่ถูกต้อง:

สตริงของ 'N', 'E', 'S' และ 'W' หมายถึงการพยายามย้ายทิศเหนือ, ตะวันออก, ใต้และตะวันตกตามลำดับ การเคลื่อนไหวที่ถูกบล็อกโดยกำแพงถูกข้ามโดยไม่มีการเคลื่อนไหว สตริงออกจากเขาวงกตหากใช้สตริงนั้นจากผลลัพธ์เริ่มต้นในการออกจากการเข้าถึง (ไม่ว่าสตริงนั้นจะดำเนินต่อไปหรือไม่หลังจากถึงทางออก)

แรงบันดาลใจจากpuzzling.SE นี้คำถามที่xnorให้วิธีการที่พิสูจน์ได้ของการแก้ด้วยสตริงที่ยาวมากเขียนโค้ดที่สามารถค้นหาสตริงเดี่ยวที่ออกจากเขาวงกต 3 คูณ 3

การยกเว้นเขาวงกตที่ไม่ถูกต้อง (เริ่มต้นและออกในเซลล์เดียวกันหรือออกไม่สามารถเข้าถึงได้ตั้งแต่เริ่มต้น) มีเขาวงกตที่ถูกต้อง 138,172 รายการและสตริงจะต้องออกจากแต่ละรายการ

ความถูกต้อง

สตริงต้องเป็นไปตาม:

• มันประกอบด้วยตัวละคร 'N', 'E', 'S' และ 'W' เท่านั้น
• มันออกจากเขาวงกตที่ใช้กับถ้าเริ่มต้นเมื่อเริ่มต้น

ตั้งแต่ชุดของเขาวงกตที่เป็นไปได้ทั้งหมดรวมถึงเขาวงกตแต่ละที่เป็นไปได้ที่มีจุดเริ่มต้นที่ถูกต้องในแต่ละที่เป็นไปได้นี้โดยอัตโนมัติหมายความว่าสตริงจะออกจากเขาวงกตใด ๆ จากการใด ๆเป็นจุดเริ่มต้นที่ถูกต้อง นั่นคือจากจุดเริ่มต้นที่สามารถเข้าถึงทางออกได้

การชนะ

ผู้ชนะคือคำตอบที่ให้สตริงที่สั้นที่สุดและรวมถึงรหัสที่ใช้สร้างมัน หากคำตอบมากกว่าหนึ่งข้อให้สตริงที่มีความยาวสั้นที่สุดคำตอบแรกที่โพสต์ความยาวสตริงนั้นจะเป็นผู้ชนะ

ตัวอย่าง

นี่คือตัวอย่างของสตริง 500 ตัวอักษรเพื่อให้คุณเอาชนะ:

SEENSSNESSWNNSNNNNWWNWENENNWEENSESSNENSESWENWWWWWENWNWWSESNSWENNWNWENWSSSNNNNNNESWNEWWWWWNNNSWESSEEWNENWENEENNEEESEENSSEENNWWWNWSWNSSENNNWESSESNWESWEENNWSNWWEEWWESNWEEEWWSSSESEEWWNSSEEEEESSENWWNNSWNENSESSNEESENEWSSNWNSEWEEEWEESWSNNNEWNNWNWSSWEESSSSNESESNENNWEESNWEWSWNSNWNNWENSNSWEWSWWNNWNSENESSNENEWNSSWNNEWSESWENEEENSWWSNNNNSSNENEWSNEEWNWENEEWEESEWEEWSSESSSWNWNNSWNWENWNENWNSWESNWSNSSENENNNWSSENSSSWWNENWWWEWSEWSNSSWNNSEWEWENSWENWSENEENSWEWSEWWSESSWWWNWSSEWSNWSNNWESNSNENNSNEWSNNESNNENWNWNNNEWWEWEE

ขอบคุณorlp ที่บริจาคสิ่งนี้

ลีดเดอร์บอร์ด

คะแนนที่เท่ากันจะแสดงตามลำดับการโพสต์ของคะแนนนั้น นี่ไม่จำเป็นต้องเป็นลำดับที่คำตอบถูกโพสต์เนื่องจากคะแนนสำหรับคำตอบที่ระบุอาจมีการอัปเดตเมื่อเวลาผ่านไป

ผู้พิพากษา

นี่คือเครื่องมือตรวจสอบ Python 3ที่รับสตริงของ NESW เป็นอาร์กิวเมนต์บรรทัดคำสั่งหรือผ่าน STDIN

สำหรับสตริงที่ไม่ถูกต้องสิ่งนี้จะทำให้คุณเห็นตัวอย่างของเขาวงกตที่ล้มเหลว

C ++, 97 95 93 91 86 83 82 81 79 อักขระ

NNWSWNNSENESESWSSWNSEENWWNWSSEWWNENWEENWSWNWSSENENWNWNESENESESWNWSESEWWNENWNEES

กลยุทธ์ของฉันค่อนข้างเรียบง่าย - อัลกอริธึมการวิวัฒนาการที่สามารถเติบโตหดตัวสลับองค์ประกอบของและเปลี่ยนลำดับที่ถูกต้องได้ ตรรกะวิวัฒนาการของฉันเกือบจะเหมือนกับ @ Sp3000 แล้วในขณะที่เขาพัฒนาไปแล้ว

อย่างไรก็ตามการใช้ตรรกะเขาวงกตของฉันค่อนข้างดี สิ่งนี้ทำให้ฉันสามารถตรวจสอบว่าสตริงมีความถูกต้องที่ความเร็วพองหรือไม่ ลองคิดออกโดยดูที่ความคิดเห็นdo_moveและตัวMazeสร้าง

#include <algorithm>
#include <bitset>
#include <cstdint>
#include <iostream>
#include <random>
#include <set>
#include <vector>

/*
    Positions:

        8, 10, 12
        16, 18, 20
        24, 26, 28

    By defining as enum respectively N, W, E, S as 0, 1, 2, 3 we get:

        N: -8, E: 2, S: 8, W: -2
        0: -8, 1: -2, 2: 2, 3: 8

    To get the indices for the walls, average the numbers of the positions it
    would be blocking. This gives the following indices:

        9, 11, 12, 14, 16, 17, 19, 20, 22, 24, 25, 27

    We'll construct a wall mask with a 1 bit for every position that does not
    have a wall. Then if a 1 shifted by the average of the positions AND'd with
    the wall mask is zero, we have hit a wall.
*/

enum { N = -8, W = -2, E = 2, S = 8 };
static const int encoded_pos[] = {8, 10, 12, 16, 18, 20, 24, 26, 28};
static const int wall_idx[] = {9, 11, 12, 14, 16, 17, 19, 20, 22, 24, 25, 27};
static const int move_offsets[] = { N, W, E, S };

int do_move(uint32_t walls, int pos, int move) {
    int idx = pos + move / 2;
    return walls & (1ull << idx) ? pos + move : pos;
}

struct Maze {
    uint32_t walls;
    int start, end;

    Maze(uint32_t maze_id, int start, int end) {
        walls = 0;
        for (int i = 0; i < 12; ++i) {
            if (maze_id & (1 << i)) walls |= 1 << wall_idx[i];
        }
        this->start = encoded_pos[start];
        this->end = encoded_pos[end];
    }

    uint32_t reachable() {
        if (start == end) return false;

        uint32_t reached = 0;
        std::vector<int> fill; fill.reserve(8); fill.push_back(start);
        while (fill.size()) {
            int pos = fill.back(); fill.pop_back();
            if (reached & (1 << pos)) continue;
            reached |= 1 << pos;
            for (int m : move_offsets) fill.push_back(do_move(walls, pos, m));
        }

        return reached;
    }

    bool interesting() {
        uint32_t reached = reachable();
        if (!(reached & (1 << end))) return false;
        if (std::bitset<32>(reached).count() <= 4) return false;

        int max_deg = 0;
        uint32_t ends = 0;
        for (int p = 0; p < 9; ++p) {
            int pos = encoded_pos[p];
            if (reached & (1 << pos)) {
                int deg = 0;
                for (int m : move_offsets) {
                    if (pos != do_move(walls, pos, m)) ++deg;
                }
                if (deg == 1) ends |= 1 << pos;
                max_deg = std::max(deg, max_deg);
            }
        }

        if (max_deg <= 2 && ends != ((1u << start) | (1u << end))) return false;

        return true;
    }
};

std::vector<Maze> gen_valid_mazes() {
    std::vector<Maze> mazes;
    for (int maze_id = 0; maze_id < (1 << 12); maze_id++) {
        for (int points = 0; points < 9*9; ++points) {
            Maze maze(maze_id, points % 9, points / 9);
            if (!maze.interesting()) continue;
            mazes.push_back(maze);
        }
    }

    return mazes;
}

bool is_solution(const std::vector<int>& moves, Maze maze) {
    int pos = maze.start;
    for (auto move : moves) {
        pos = do_move(maze.walls, pos, move);
        if (pos == maze.end) return true;
    }

    return false;
}

std::vector<int> str_to_moves(std::string str) {
    std::vector<int> moves;
    for (auto c : str) {
        switch (c) {
        case 'N': moves.push_back(N); break;
        case 'E': moves.push_back(E); break;
        case 'S': moves.push_back(S); break;
        case 'W': moves.push_back(W); break;
        }
    }

    return moves;
}

std::string moves_to_str(const std::vector<int>& moves) {
    std::string result;
    for (auto move : moves) {
             if (move == N) result += "N";
        else if (move == E) result += "E";
        else if (move == S) result += "S";
        else if (move == W) result += "W";
    }
    return result;
}

bool solves_all(const std::vector<int>& moves, std::vector<Maze>& mazes) {
    for (size_t i = 0; i < mazes.size(); ++i) {
        if (!is_solution(moves, mazes[i])) {
            // Bring failing maze closer to begin.
            std::swap(mazes[i], mazes[i / 2]);
            return false;
        }
    }
    return true;
}

template<class Gen>
int randint(int lo, int hi, Gen& gen) {
    return std::uniform_int_distribution<int>(lo, hi)(gen);
}

template<class Gen>
int randmove(Gen& gen) { return move_offsets[randint(0, 3, gen)]; }

constexpr double mutation_p = 0.35; // Chance to mutate.
constexpr double grow_p = 0.1; // Chance to grow.
constexpr double swap_p = 0.2; // Chance to swap.

int main(int argc, char** argv) {
    std::random_device rnd;
    std::mt19937 rng(rnd());
    std::uniform_real_distribution<double> real;
    std::exponential_distribution<double> exp_big(0.5);
    std::exponential_distribution<double> exp_small(2);

    std::vector<Maze> mazes = gen_valid_mazes();

    std::vector<int> moves;
    while (!solves_all(moves, mazes)) {
        moves.clear();
        for (int m = 0; m < 500; m++) moves.push_back(randmove(rng));
    }

    size_t best_seen = moves.size();
    std::set<std::vector<int>> printed;
    while (true) {
        std::vector<int> new_moves(moves);
        double p = real(rng);

        if (p < grow_p && moves.size() < best_seen + 10) {
            int idx = randint(0, new_moves.size() - 1, rng);
            new_moves.insert(new_moves.begin() + idx, randmove(rng));
        } else if (p < swap_p) {
            int num_swap = std::min<int>(1 + exp_big(rng), new_moves.size()/2);
            for (int i = 0; i < num_swap; ++i) {
                int a = randint(0, new_moves.size() - 1, rng);
                int b = randint(0, new_moves.size() - 1, rng);
                std::swap(new_moves[a], new_moves[b]);
            }
        } else if (p < mutation_p) {
            int num_mut = std::min<int>(1 + exp_big(rng), new_moves.size());
            for (int i = 0; i < num_mut; ++i) {
                int idx = randint(0, new_moves.size() - 1, rng);
                new_moves[idx] = randmove(rng);
            }
        } else {
            int num_shrink = std::min<int>(1 + exp_small(rng), new_moves.size());
            for (int i = 0; i < num_shrink; ++i) {
                int idx = randint(0, new_moves.size() - 1, rng);
                new_moves.erase(new_moves.begin() + idx);
            }
        }

        if (solves_all(new_moves, mazes)) {
            moves = new_moves;

            if (moves.size() <= best_seen && !printed.count(moves)) {
                std::cout << moves.size() << " " << moves_to_str(moves) << "\n";
                if (moves.size() < best_seen) {
                    printed.clear(); best_seen = moves.size();
                }
                printed.insert(moves);
            }
        }
    }

    return 0;
}

Python 3 + PyPy, 82 80 ตัวอักษร

SWWNNSENESESWSSWSEENWNWSWSEWNWNENENWWSESSEWSWNWSENWEENWWNNESENESSWNWSESESWWNNESE

ฉันลังเลที่จะโพสต์คำตอบนี้เพราะโดยทั่วไปฉันใช้วิธีการของ orlp และหมุนตัวเองไป สตริงนี้ถูกค้นพบโดยเริ่มต้นด้วยการแก้ปัญหาความยาวหลอกเทียม 500 - มีเมล็ดจำนวนมากพยายามก่อนที่ฉันจะทำลายสถิติปัจจุบัน

การเพิ่มประสิทธิภาพที่สำคัญใหม่เพียงอย่างเดียวคือฉันดูที่หนึ่งในสามของเขาวงกต เขาวงกตสองประเภทจะถูกแยกออกจากการค้นหา:

• เขาวงกตที่<= 7สามารถเข้าถึงช่องสี่เหลี่ยม
• เขาวงกตที่สี่เหลี่ยมที่เข้าถึงได้ทั้งหมดอยู่บนเส้นทางเดียวและจุดเริ่มต้น / สิ้นสุดไม่ได้ที่ปลายทั้งสอง

แนวคิดก็คือสตริงใด ๆ ที่แก้ส่วนที่เหลือของเขาวงกตก็ควรที่จะแก้ปัญหาข้างต้นโดยอัตโนมัติ ฉันเชื่อว่านี่เป็นความจริงสำหรับประเภทที่สอง แต่ไม่เป็นความจริงสำหรับประเภทแรกดังนั้นผลลัพธ์จะมีผลบวกปลอมบางอย่างที่ต้องตรวจสอบแยกต่างหาก บวกเท็จเหล่านี้มักจะพลาดเพียงประมาณ 20 เขาวงกตดังนั้นฉันจึงคิดว่ามันจะเป็นการแลกเปลี่ยนที่ดีระหว่างความเร็วและความแม่นยำ

ในตอนแรกฉันได้ศึกษารายการฮิวริสติกแบบยาว ๆ แต่ก็ไม่มีอะไรน่ากลัวเลยกว่า 140 ข้อ

import random

N, M = 3, 3

W = 2*N-1
H = 2*M-1

random.seed(142857)


def move(c, cell, walls):
    global W, H

    if c == "N":
        if cell > W and not (1<<(cell-W)//2 & walls):
            cell = cell - W*2

    elif c == "S":
        if cell < W*(H-1) and not (1<<(cell+W)//2 & walls):
            cell = cell + W*2

    elif c == "E":
        if cell % W < W-1 and not (1<<(cell+1)//2 & walls):
            cell = cell + 2

    elif c == "W":
        if cell % W > 0 and not (1<<(cell-1)//2 & walls):
            cell = cell - 2

    return cell


def valid_maze(start, finish, walls):
    global adjacent

    if start == finish:
        return False

    visited = set()
    cells = [start]

    while cells:
        curr_cell = cells.pop()

        if curr_cell == finish:
            return True

        if curr_cell in visited:
            continue

        visited.add(curr_cell)

        for c in "NSEW":
            cells.append(move(c, curr_cell, walls))

    return False


def print_maze(maze):
    start, finish, walls = maze
    print_str = "".join(" #"[walls & (1 << i//2) != 0] if i%2 == 1
                        else " SF"[2*(i==finish) + (i==start)]
                        for i in range(W*H))

    print("#"*(H+2))

    for i in range(H):
        print("#" + print_str[i*W:(i+1)*W] + "#")

    print("#"*(H+2), end="\n\n")

all_cells = [W*y+x for y in range(0, H, 2) for x in range(0, W, 2)]
mazes = []

for start in all_cells:
    for finish in all_cells:
        for walls in range(1<<(N*(M-1) + M*(N-1))):
            if valid_maze(start, finish, walls):
                mazes.append((start, finish, walls))

num_mazes = len(mazes)
print(num_mazes, "mazes generated")

to_remove = set()

for i, maze in enumerate(mazes):
    start, finish, walls = maze

    reachable = set()
    cells = [start]

    while cells:
        cell = cells.pop()

        if cell in reachable:
            continue

        reachable.add(cell)

        if cell == finish:
            continue

        for c in "NSEW":
            new_cell = move(c, cell, walls)
            cells.append(new_cell)

    max_deg = 0
    sf = set()

    for cell in reachable:
        deg = 0

        for c in "NSEW":
            if move(c, cell, walls) != cell:
                deg += 1

        max_deg = max(deg, max_deg)

        if deg == 1:
            sf.add(cell)

    if max_deg <= 2 and len(sf) == 2 and sf != {start, finish}:
        # Single path subset
        to_remove.add(i)

    elif len(reachable) <= (N*M*4)//5:
        # Low reachability maze, above ratio is adjustable
        to_remove.add(i)

mazes = [maze for i,maze in enumerate(mazes) if i not in to_remove]
print(num_mazes - len(mazes), "mazes removed,", len(mazes), "remaining")
num_mazes = len(mazes)


def check(string, cache = set()):
    global mazes

    if string in cache:
        return True

    for i, maze in enumerate(mazes):
        start, finish, walls = maze
        cell = start

        for c in string:
            cell = move(c, cell, walls)

            if cell == finish:
                break

        else:
            # Swap maze to front
            mazes[i//2], mazes[i] = mazes[i], mazes[i//2]
            return False

    cache.add(string)
    return True


while True:
    string = "".join(random.choice("NSEW") for _ in range(500))

    if check(string):
        break

# string = "NWWSSESNESESNNWNNSWNWSSENESWSWNENENWNWESESENNESWSESWNWSWNNEWSESWSEEWNENWWSSNNEESS"

best = len(string)
seen = set()

while True:
    action = random.random()

    if action < 0.1:
        # Grow
        num_grow = int(random.expovariate(lambd=3)) + 1
        new_string = string

        for _ in range(num_grow):
            i = random.randrange(len(new_string))
            new_string = new_string[:i] + random.choice("NSEW") + new_string[i:]

    elif action < 0.2:
        # Swap
        num_swap = int(random.expovariate(lambd=1)) + 1
        new_string = string

        for _ in range(num_swap):
            i,j = sorted(random.sample(range(len(new_string)), 2))
            new_string = new_string[:i] + new_string[j] + new_string[i+1:j] + new_string[i] + new_string[j+1:]

    elif action < 0.35:
        # Mutate
        num_mutate = int(random.expovariate(lambd=1)) + 1
        new_string = string

        for _ in range(num_mutate):
            i = random.randrange(len(new_string))
            new_string = new_string[:i] + random.choice("NSEW") + new_string[i+1:]

    else:
        # Shrink
        num_shrink = int(random.expovariate(lambd=3)) + 1
        new_string = string

        for _ in range(num_shrink):
            i = random.randrange(len(new_string))
            new_string = new_string[:i] + new_string[i+1:]


    if check(new_string):
        string = new_string

    if len(string) <= best and string not in seen:
        while True:
            if len(string) < best:
                seen = set()

            seen.add(string)
            best = len(string)
            print(string, len(string))

            # Force removals on new record strings
            for i in range(len(string)):
                new_string = string[:i] + string[i+1:]

                if check(new_string):
                    string = new_string
                    break

            else:
                break

C ++ และไลบรารี่จากการสะท้อน

สรุป: วิธีการใหม่ไม่มีวิธีแก้ปัญหาใหม่โปรแกรมที่น่าเล่นและผลลัพธ์ที่น่าสนใจของการแก้ปัญหาที่รู้จักในท้องถิ่น โอ้และการสังเกตที่มีประโยชน์โดยทั่วไป

เมื่อใช้วิธีการแบบSAT ฉันสามารถแก้ปัญหา ที่คล้ายกันอย่างสมบูรณ์ สำหรับเขาวงกต 4x4 ที่มีเซลล์ที่ถูกบล็อกแทนผนังบางและตำแหน่งเริ่มต้นและทางออกคงที่ในมุมตรงข้าม ดังนั้นฉันหวังว่าจะสามารถใช้ความคิดเดียวกันกับปัญหานี้ได้ อย่างไรก็ตามแม้ว่าปัญหาอื่น ๆ ที่ฉันใช้เพียง 2423 เขาวงกต (ในขณะเดียวกันก็พบว่า 2,083 มีเพียงพอ) และมันมีวิธีแก้ปัญหาความยาว 29 การเข้ารหัส SAT ใช้ตัวแปรนับล้านและใช้เวลาหลายวัน

ดังนั้นฉันตัดสินใจที่จะเปลี่ยนวิธีการในสองวิธีที่สำคัญ:

• อย่ายืนยันในการค้นหาโซลูชันตั้งแต่เริ่มต้น แต่อนุญาตให้แก้ไขส่วนของสตริงโซลูชัน (นั่นเป็นเรื่องง่ายที่จะทำต่อไปโดยการเพิ่มส่วนคำสั่ง แต่โปรแกรมของฉันทำให้มันสะดวกสบายในการทำ)
• อย่าใช้เขาวงกตทั้งหมดตั้งแต่ต้น แทนที่จะเพิ่มเขาวงกตที่ยังไม่ได้แก้ไขทีละคน เขาวงกตบางคนอาจได้รับการแก้ไขโดยบังเอิญหรือพวกเขาจะได้รับการแก้ไขเมื่อสิ่งที่พิจารณาแล้วได้รับการแก้ไข ในกรณีหลังมันจะไม่ถูกเพิ่มเข้ามาโดยที่เราไม่จำเป็นต้องรู้ถึงความหมาย

ฉันยังทำการปรับให้เหมาะสมเพื่อใช้ตัวแปรน้อยลงและส่วนคำสั่งหน่วย

โปรแกรมจะขึ้นอยู่กับ @ orlp ของ การเปลี่ยนแปลงที่สำคัญคือการเลือกเขาวงกต:

• ประการแรกเขาจะได้รับจากโครงสร้างผนังและตำแหน่งเริ่มต้นเท่านั้น (พวกเขายังเก็บตำแหน่งที่เข้าถึงได้) ฟังก์ชั่นis_solutionตรวจสอบว่าตำแหน่งที่เข้าถึงได้ทั้งหมดถึงหรือไม่
• (ไม่เปลี่ยนแปลง: ยังคงไม่ใช้เขาวงกตที่มีตำแหน่งที่เข้าถึงได้เพียง 4 หรือน้อยกว่า แต่ส่วนใหญ่จะถูกโยนทิ้งไปโดยการสังเกตต่อไปนี้)
• หากเขาวงกตไม่ได้ใช้เซลล์ใด ๆ ของทั้งสามเซลล์มันจะเทียบเท่ากับเขาวงกตที่เลื่อนขึ้น ดังนั้นเราสามารถวางมันลง เช่นเดียวกับเขาวงกตที่ไม่ได้ใช้เซลล์ซ้ายสามเซลล์ใด ๆ
• ไม่สำคัญว่าจะเชื่อมต่อชิ้นส่วนที่ไม่สามารถเข้าถึงได้ดังนั้นเรายืนยันว่าแต่ละเซลล์ที่ไม่สามารถเข้าถึงได้นั้นล้อมรอบด้วยกำแพงอย่างสมบูรณ์
• เขาวงกตเส้นทางเดียวที่เป็น submaze ของเขาวงกตเส้นทางเดียวที่ใหญ่กว่าจะได้รับการแก้ไขเสมอเมื่อมีการแก้ไขที่ใหญ่กว่าดังนั้นเราจึงไม่ต้องการมัน เส้นทางเขาวงกตขนาดเดียวแต่ละเส้นทางที่มากที่สุด 7 เป็นส่วนหนึ่งของเส้นทางที่ใหญ่กว่า (ยังเหมาะสมใน 3x3) แต่มีเส้นทางเส้นทางเดียวขนาด 8 เขาวงกตที่ไม่ได้เป็น สำหรับ simpliciy เราแค่ปล่อย mazes ขนาดเดียวให้น้อยกว่า 8 (และฉันยังคงใช้เฉพาะจุดสุดขีดเท่านั้นที่ต้องพิจารณาในฐานะตำแหน่งเริ่มต้นตำแหน่งทั้งหมดถูกใช้เป็นตำแหน่งทางออกซึ่งสำคัญสำหรับส่วน SAT เท่านั้น ของโปรแกรม)

ด้วยวิธีนี้ฉันได้รับ 1,0772 เขาวงกตรวมกับตำแหน่งเริ่มต้น

นี่คือโปรแกรม:

#include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <iostream>
#include <set>
#include <vector>
#include <limits>
#include <cassert>

extern "C"{
#include "lglib.h"
}

// reusing a lot of @orlp's ideas and code

enum { N = -8, W = -2, E = 2, S = 8 };
static const int encoded_pos[] = {8, 10, 12, 16, 18, 20, 24, 26, 28};
static const int wall_idx[] = {9, 11, 12, 14, 16, 17, 19, 20, 22, 24, 25, 27};
static const int move_offsets[] = { N, E, S, W };
static const uint32_t toppos = 1ull << 8 | 1ull << 10 | 1ull << 12;
static const uint32_t leftpos = 1ull << 8 | 1ull << 16 | 1ull << 24;
static const int unencoded_pos[] = {0,0,0,0,0,0,0,0,0,0,1,0,2,0,0,0,3,
                                    0,4,0,5,0,0,0,6,0,7,0,8};

int do_move(uint32_t walls, int pos, int move) {
  int idx = pos + move / 2;
  return walls & (1ull << idx) ? pos + move : pos;
}

struct Maze {
  uint32_t walls, reach;
  int start;

  Maze(uint32_t walls=0, uint32_t reach=0, int start=0):
    walls(walls),reach(reach),start(start) {}

  bool is_dummy() const {
    return (walls==0);
  }

  std::size_t size() const{
    return std::bitset<32>(reach).count();
  }

  std::size_t simplicity() const{  // how many potential walls aren't there?
    return std::bitset<32>(walls).count();
  }

};

bool cmp(const Maze& a, const Maze& b){
  auto asz = a.size();
  auto bsz = b.size();
  if (asz>bsz) return true;
  if (asz<bsz) return false;
  return a.simplicity()<b.simplicity();
}

uint32_t reachable(uint32_t walls) {
  static int fill[9];
  uint32_t reached = 0;
  uint32_t reached_relevant = 0;
  for (int start : encoded_pos){
    if ((1ull << start) & reached) continue;
    uint32_t reached_component = (1ull << start);
    fill[0]=start;
    int count=1;
    for(int i=0; i<count; ++i)
      for(int m : move_offsets) {
        int newpos = do_move(walls, fill[i], m);
        if (reached_component & (1ull << newpos)) continue;
        reached_component |= 1ull << newpos;
        fill[count++] = newpos;
      }
    if (count>1){
      if (reached_relevant)
        return 0;  // more than one nonsingular component
      if (!(reached_component & toppos) || !(reached_component & leftpos))
        return 0;  // equivalent to shifted version
      if (std::bitset<32>(reached_component).count() <= 4)
        return 0;  
      reached_relevant = reached_component;
    }
    reached |= reached_component;
  }
  return reached_relevant;
}

void enterMazes(uint32_t walls, uint32_t reached, std::vector<Maze>& mazes){
  int max_deg = 0;
  uint32_t ends = 0;
  for (int pos : encoded_pos)
    if (reached & (1ull << pos)) {
      int deg = 0;
      for (int m : move_offsets) {
        if (pos != do_move(walls, pos, m))
          ++deg;
      }
      if (deg == 1)
        ends |= 1ull << pos;
      max_deg = std::max(deg, max_deg);
    }
  uint32_t starts = reached;
  if (max_deg == 2){
    if (std::bitset<32>(reached).count() <= 7)
      return; // small paths are redundant
    starts = ends; // need only start at extremal points
  }
  for (int pos : encoded_pos)
    if ( starts & (1ull << pos))
      mazes.emplace_back(walls, reached, pos);
}

std::vector<Maze> gen_valid_mazes() {
  std::vector<Maze> mazes;
  for (int maze_id = 0; maze_id < (1 << 12); maze_id++) {
    uint32_t walls = 0;
    for (int i = 0; i < 12; ++i) 
      if (maze_id & (1 << i))
    walls |= 1ull << wall_idx[i];
    uint32_t reached=reachable(walls);
    if (!reached) continue;
    enterMazes(walls, reached, mazes);
  }
  std::sort(mazes.begin(),mazes.end(),cmp);
  return mazes;
};

bool is_solution(const std::vector<int>& moves, Maze& maze) {
  int pos = maze.start;
  uint32_t reached = 1ull << pos;
  for (auto move : moves) {
    pos = do_move(maze.walls, pos, move);
    reached |= 1ull << pos;
    if (reached == maze.reach) return true;
  }
  return false;
}

std::vector<int> str_to_moves(std::string str) {
  std::vector<int> moves;
  for (auto c : str) {
    switch (c) {
    case 'N': moves.push_back(N); break;
    case 'E': moves.push_back(E); break;
    case 'S': moves.push_back(S); break;
    case 'W': moves.push_back(W); break;
    }
  }
  return moves;
}

Maze unsolved(const std::vector<int>& moves, std::vector<Maze>& mazes) {
  int unsolved_count = 0;
  Maze problem{};
  for (Maze m : mazes)
    if (!is_solution(moves, m))
      if(!(unsolved_count++))
    problem=m;
  if (unsolved_count)
    std::cout << "unsolved: " << unsolved_count << "\n";
  return problem;
}

LGL * lgl;

constexpr int TRUELIT = std::numeric_limits<int>::max();
constexpr int FALSELIT = -TRUELIT;

int new_var(){
  static int next_var = 1;
  assert(next_var<TRUELIT);
  return next_var++;
}

bool lit_is_true(int lit){
  int abslit = lit>0 ? lit : -lit;
  bool res = (abslit==TRUELIT) || (lglderef(lgl,abslit)>0);
  return lit>0 ? res : !res;
}

void unsat(){
  std::cout << "Unsatisfiable!\n";
  std::exit(1);
}

void clause(const std::set<int>& lits){
  if (lits.find(TRUELIT) != lits.end())
    return;
  for (int lit : lits)
    if (lits.find(-lit) != lits.end())
      return;
  int found=0;
  for (int lit : lits)
    if (lit != FALSELIT){
      lgladd(lgl, lit);
      found=1;
    }
  lgladd(lgl, 0);
  if (!found)
    unsat();
}

void at_most_one(const std::set<int>& lits){
  if (lits.size()<2)
    return;
  for(auto it1=lits.cbegin(); it1!=lits.cend(); ++it1){
    auto it2=it1;
    ++it2;
    for(  ; it2!=lits.cend(); ++it2)
      clause( {- *it1, - *it2} );
  }
}

/* Usually, lit_op(lits,sgn) creates a new variable which it returns,
   and adds clauses that ensure that the variable is equivalent to the
   disjunction (if sgn==1) or the conjunction (if sgn==-1) of the literals
   in lits. However, if this disjunction or conjunction is constant True
   or False or simplifies to a single literal, that is returned without
   creating a new variable and without adding clauses.                    */ 

int lit_op(std::set<int> lits, int sgn){
  if (lits.find(sgn*TRUELIT) != lits.end())
    return sgn*TRUELIT;
  lits.erase(sgn*FALSELIT);
  if (!lits.size())
    return sgn*FALSELIT;
  if (lits.size()==1)
    return *lits.begin();
  int res=new_var();
  for(int lit : lits)
    clause({sgn*res,-sgn*lit});
  for(int lit : lits)
    lgladd(lgl,sgn*lit);
  lgladd(lgl,-sgn*res);
  lgladd(lgl,0);
  return res;
}

int lit_or(std::set<int> lits){
  return lit_op(lits,1);
}

int lit_and(std::set<int> lits){
  return lit_op(lits,-1);
}

using A4 = std::array<int,4>;

void add_maze_conditions(Maze m, std::vector<A4> dirs, int len){
  int mp[9][2];
  int rp[9];
  for(int p=0; p<9; ++p)
    if((1ull << encoded_pos[p]) & m.reach)
      rp[p] = mp[p][0] = encoded_pos[p]==m.start ? TRUELIT : FALSELIT;
  int t=0;
  for(int i=0; i<len; ++i){
    std::set<int> posn {};
    for(int p=0; p<9; ++p){
      int ep = encoded_pos[p];
      if((1ull << ep) & m.reach){
        std::set<int> reach_pos {};
        for(int d=0; d<4; ++d){
          int np = do_move(m.walls, ep, move_offsets[d]);
          reach_pos.insert( lit_and({mp[unencoded_pos[np]][t],
                                  dirs[i][d ^ ((np==ep)?0:2)]    }));
        }
        int pl = lit_or(reach_pos);
        mp[p][!t] = pl;
        rp[p] = lit_or({rp[p], pl});
        posn.insert(pl);
      }
    }
    at_most_one(posn);
    t=!t;
  }
  for(int p=0; p<9; ++p)
    if((1ull << encoded_pos[p]) & m.reach)
      clause({rp[p]});
}

void usage(char* argv0){
  std::cout << "usage: " << argv0 <<
    " <string>\n   where <string> consists of 'N', 'E', 'S', 'W' and '*'.\n" ;
  std::exit(2);
}

const std::string nesw{"NESW"};

int main(int argc, char** argv) {
  if (argc!=2)
    usage(argv[0]);
  std::vector<Maze> mazes = gen_valid_mazes();
  std::cout << "Mazes with start positions: " << mazes.size() << "\n" ;
  lgl = lglinit();
  int len = std::strlen(argv[1]);
  std::cout << argv[1] << "\n   with length " << len << "\n";

  std::vector<A4> dirs;
  for(int i=0; i<len; ++i){
    switch(argv[1][i]){
    case 'N':
      dirs.emplace_back(A4{TRUELIT,FALSELIT,FALSELIT,FALSELIT});
      break;
    case 'E':
      dirs.emplace_back(A4{FALSELIT,TRUELIT,FALSELIT,FALSELIT});
      break;
    case 'S':
      dirs.emplace_back(A4{FALSELIT,FALSELIT,TRUELIT,FALSELIT});
      break;
    case 'W':
      dirs.emplace_back(A4{FALSELIT,FALSELIT,FALSELIT,TRUELIT});
      break;
    case '*': {
      dirs.emplace_back();
      std::generate_n(dirs[i].begin(),4,new_var);
      std::set<int> dirs_here { dirs[i].begin(), dirs[i].end() };
      at_most_one(dirs_here);
      clause(dirs_here);
      for(int l : dirs_here)
        lglfreeze(lgl,l);
      break;
      }
    default:
      usage(argv[0]);
    }
  }

  int maze_nr=0;
  for(;;) {
    std::cout << "Solving...\n";
    int res=lglsat(lgl);
    if(res==LGL_UNSATISFIABLE)
      unsat();
    assert(res==LGL_SATISFIABLE);
    std::string sol(len,' ');
    for(int i=0; i<len; ++i)
      for(int d=0; d<4; ++d)
        if (lit_is_true(dirs[i][d])){
          sol[i]=nesw[d];
          break;
    }
    std::cout << sol << "\n";

    Maze m=unsolved(str_to_moves(sol),mazes);
    if (m.is_dummy()){
      std::cout << "That solves all!\n";
      return 0;
    }
    std::cout << "Adding maze " << ++maze_nr << ": " << 
      m.walls << "/" << m.start <<
      " (" << m.size() << "/" << 12-m.simplicity() << ")\n";
    add_maze_conditions(m,dirs,len);
  }
}  

อันดับแรกconfigure.shและmakeตัวlingelingแก้ไขจากนั้นคอมไพล์โปรแกรมด้วยบางสิ่งบางอย่าง g++ -std=c++11 -O3 -I ... -o m3sat m3sat.cc -L ... -llglซึ่ง...เป็นเส้นทางที่lglib.hresp ดังนั้นทั้งสองอาจจะยกตัวอย่างเช่นliblgl.a ../lingeling-<version>หรือเพียงวางไว้ในไดเรกทอรีเดียวกันและทำได้โดยไม่ต้องมีตัวเลือก-Iและ-L

โปรแกรมที่ใช้อาร์กิวเมนต์หนึ่งที่บังคับใช้บรรทัดคำสั่งสตริงประกอบด้วยN, E, S, W(สำหรับเส้นทางคงที่) *หรือ ดังนั้นคุณสามารถค้นหาวิธีแก้ปัญหาทั่วไปขนาด 78 โดยให้สตริงที่ 78 *s (ในเครื่องหมายคำพูด) หรือค้นหาวิธีแก้ปัญหาที่เริ่มต้นด้วยการNEWSใช้NEWSตามด้วย*s มากเท่าที่คุณต้องการสำหรับขั้นตอนเพิ่มเติม *ในฐานะที่เป็นการทดสอบครั้งแรกที่ใช้วิธีการแก้ปัญหาที่คุณชื่นชอบและแทนที่ตัวอักษรบางตัวที่มี นี่เป็นวิธีการแก้ปัญหาที่รวดเร็วสำหรับมูลค่าที่สูงอย่างน่าประหลาดใจ

โปรแกรมจะบอกให้ทราบว่าเขาวงกตตัวใดเพิ่มเข้ามาอธิบายด้วยโครงสร้างผนังและตำแหน่งเริ่มต้นรวมทั้งบอกจำนวนตำแหน่งและกำแพงที่สามารถเข้าถึงได้ เขาวงกตจะถูกจัดเรียงตามเกณฑ์เหล่านี้และอันที่ยังไม่ได้แก้ไขแรกจะถูกเพิ่ม ดังนั้นเขาวงกตที่เพิ่มเข้ามาส่วนใหญ่จึงมี(9/4)แต่บางครั้งก็มีบางคนปรากฏเช่นกัน

ฉันใช้วิธีแก้ปัญหาที่รู้จักที่มีความยาว 79 และสำหรับแต่ละกลุ่มของตัวอักษร 26 ตัวที่อยู่ติดกันพยายามที่จะแทนที่ด้วย 25 ตัวอักษร ฉันพยายามลบตัวอักษร 13 ตัวออกจากจุดเริ่มต้นและตอนท้ายและแทนที่ด้วยตัวอักษร 13 ตัวที่จุดเริ่มต้นและอีก 12 ตัวท้ายและในทางกลับกัน น่าเสียดายที่มันไม่น่าพอใจ ดังนั้นเราสามารถทำสิ่งนี้เป็นตัวบ่งชี้ว่าความยาว 79 นั้นเหมาะสมหรือไม่ ไม่ฉันพยายามปรับปรุงโซลูชัน 80 ความยาวให้ยาว 79 เช่นเดียวกันและนั่นก็ไม่ประสบความสำเร็จเช่นกัน

ในที่สุดฉันพยายามรวมจุดเริ่มต้นของโซลูชันหนึ่งกับอีกโซลูชันหนึ่งและกับโซลูชันหนึ่งที่เปลี่ยนรูปโดยสมมาตรอันใดอันหนึ่ง ตอนนี้ฉันหมดความคิดที่น่าสนใจดังนั้นฉันตัดสินใจที่จะแสดงสิ่งที่ฉันมีถึงแม้ว่ามันจะไม่นำไปสู่การแก้ปัญหาใหม่