C ++ e a biblioteca do lingeling
Resumo: Uma nova abordagem, sem novas soluções , um bom programa para brincar e alguns resultados interessantes da não-improvabilidade local das soluções conhecidas. Ah, e algumas observações geralmente úteis.
Usando uma
abordagem baseada em SAT , eu poderia resolver completamente
o problema semelhante para labirintos 4x4 com células bloqueadas em vez de paredes finas e posições fixas de partida e saída em cantos opostos. Então, eu esperava poder usar as mesmas idéias para esse problema. No entanto, mesmo para o outro problema, eu usei apenas 2423 labirintos (enquanto isso foi observado em 2083) e ele tem uma solução de comprimento 29, a codificação SAT usou milhões de variáveis e a solução levou dias.
Então, decidi mudar a abordagem de duas maneiras importantes:
- Não insista em procurar uma solução a partir do zero, mas permita corrigir uma parte da cadeia de solução. (É fácil fazer isso adicionando cláusulas de unidade, mas meu programa facilita a execução.)
- Não use todos os labirintos desde o início. Em vez disso, adicione gradualmente um labirinto não resolvido de cada vez. Alguns labirintos podem ser resolvidos por acaso, ou sempre são resolvidos quando os já considerados são resolvidos. No último caso, ele nunca será adicionado, sem precisarmos saber a implicação.
Também fiz algumas otimizações para usar menos variáveis e cláusulas de unidade.
O programa é baseado em @ orlp's. Uma mudança importante foi a seleção de labirintos:
- Em primeiro lugar, os labirintos são dados apenas pela estrutura da parede e pela posição inicial. (Eles também armazenam as posições alcançáveis.) A função
is_solution
verifica se todas as posições alcançáveis são alcançadas.
- (Inalterado: ainda não usando labirintos com apenas 4 ou menos posições alcançáveis. Mas a maioria deles seria jogada fora de qualquer maneira pelas seguintes observações.)
- Se um labirinto não usa nenhuma das três células superiores, é equivalente a um labirinto que é deslocado para cima. Para que possamos abandoná-lo. Da mesma forma para um labirinto que não usa nenhuma das três células esquerdas.
- Não importa se partes inacessíveis estão conectadas, por isso insistimos que cada célula inacessível esteja completamente cercada por paredes.
- Um labirinto de caminho único que é uma sub-imagem de um labirinto de caminho único maior sempre é resolvido quando o maior é resolvido, portanto não precisamos dele. Cada labirinto de tamanho único no máximo 7 faz parte de um maior (ainda em tamanho 3x3), mas existem labirintos de tamanho único de tamanho 8 que não são. Por uma questão de simplicidade, vamos soltar labirintos de caminho único de tamanho menor que 8. (E ainda estou usando que apenas os pontos extremos precisam ser considerados como posições iniciais. Todas as posições são usadas como posições de saída, o que é importante apenas para a parte SAT do programa.)
Dessa forma, recebo um total de 10772 labirintos com posições iniciais.
Aqui está o programa:
#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);
}
}
Primeiro configure.sh
e make
o lingeling
solucionador, compile o programa com algo como
g++ -std=c++11 -O3 -I ... -o m3sat m3sat.cc -L ... -llgl
, onde ...
está o caminho em que lglib.h
resp. liblgl.a
são, então ambos poderiam ser, por exemplo
../lingeling-<version>
. Ou simplesmente coloque-os no mesmo diretório e sem as opções -I
e -L
.
O programa tem um argumento de linha de comando obrigatório, uma cadeia que consiste N
, E
, S
, W
(para direções fixas) ou *
. Portanto, você pode procurar uma solução geral de tamanho 78, fornecendo uma sequência de 78 *
s (entre aspas) ou procurar uma solução começando com NEWS
, NEWS
seguido de tantos *
s quanto desejar para etapas adicionais. Como primeiro teste, pegue sua solução favorita e substitua algumas das letras por *
. Isso encontra uma solução rápida para um valor surpreendentemente alto de "alguns".
O programa dirá qual labirinto ele adiciona, descrito pela estrutura da parede e posição inicial, e também fornecerá o número de posições e paredes alcançáveis. Os labirintos são classificados por esses critérios e o primeiro não resolvido é adicionado. Portanto, a maioria dos labirintos adicionados tem (9/4)
, mas às vezes outros aparecem também.
Peguei a solução conhecida de comprimento 79 e, para cada grupo de 26 letras adjacentes, tentei substituí-las por 25. Também tentei remover 13 letras do começo e do fim e substituí-las por 13 no início e 12 no final e vice-versa. Infelizmente, tudo saiu insatisfatório. Então, podemos tomar isso como um indicador de que o comprimento 79 é ideal? Não, tentei da mesma forma melhorar a solução do comprimento 80 para o comprimento 79, e isso também não teve êxito.
Por fim, tentei combinar o início de uma solução com o final da outra e também com uma solução transformada por uma das simetrias. Agora que estou ficando sem idéias interessantes, decidi mostrar o que tenho, mesmo que não tenha levado a novas soluções.