C ++ और लाइब्रेरी से लिंगलिंग
सारांश: एक नया दृष्टिकोण, कोई नया समाधान , खेलने के लिए एक अच्छा कार्यक्रम, और ज्ञात समाधानों के स्थानीय गैर-अनुचितता के कुछ दिलचस्प परिणाम। ओह, और कुछ आम तौर पर उपयोगी टिप्पणियों।
सैट
आधारित दृष्टिकोण का उपयोग करते हुए , मैं
4x4 mazes के लिए इसी तरह की समस्या को हलकी दीवारों के बजाय अवरुद्ध कोशिकाओं के साथ पूरी तरह से हल कर सकता हूं और विपरीत कोनों पर स्थिर शुरुआत और निकास की स्थिति को निर्धारित कर सकता हूं
। इसलिए मैं इस समस्या के लिए समान विचारों का उपयोग करने में सक्षम होने की आशा करता हूं। हालाँकि, अन्य समस्या के लिए भले ही मैंने केवल 2423 mazes का उपयोग किया हो (इस बीच यह देखा गया है कि 2083 पर्याप्त हैं) और इसमें लंबाई 29 का समाधान है, SAT एन्कोडिंग ने लाखों चरों का उपयोग किया और इसे हल करने में दिन लग गए।
इसलिए मैंने दो महत्वपूर्ण तरीकों से दृष्टिकोण बदलने का फैसला किया:
- खरोंच से समाधान खोजने पर जोर न दें, लेकिन समाधान स्ट्रिंग के एक भाग को ठीक करने की अनुमति दें। (यूनिट क्लॉस को जोड़कर इसे वैसे भी करना आसान है, लेकिन मेरा कार्यक्रम इसे करने के लिए सहज बनाता है।)
- शुरुआत से सभी mazes का उपयोग न करें। इसके बजाय, एक समय में एक अनसुलझा भूलभुलैया जोड़ते हैं। कुछ मज़ारों को संयोग से हल किया जा सकता है, या वे हमेशा हल किए जाते हैं जब पहले से ही माना जाता है। उत्तरार्द्ध मामले में, यह कभी नहीं जोड़ा जाएगा, हमें निहितार्थ को जानने की आवश्यकता के बिना।
मैंने कम चरों और इकाई खंडों का उपयोग करने के लिए कुछ अनुकूलन भी किए।
कार्यक्रम @ orlp's पर आधारित है। एक महत्वपूर्ण बदलाव माज़ों का चयन था:
- सबसे पहले, मेज़ को उनकी दीवार संरचना और केवल शुरुआत की स्थिति द्वारा दिया जाता है। (वे रीचेबल पोजिशन को भी स्टोर करते हैं।) फंक्शन
is_solutionचेक करता है कि क्या सभी रीचेबल पोजिशन पर पहुंच गए हैं।
- (अपरिवर्तित: अभी भी केवल 4 या उससे कम पहुंच वाले पदों के साथ mazes का उपयोग नहीं कर रहा है। लेकिन उनमें से अधिकांश को निम्नलिखित टिप्पणियों द्वारा वैसे भी फेंक दिया जाएगा।)
- यदि कोई भूलभुलैया तीन शीर्ष कोशिकाओं में से किसी का उपयोग नहीं करती है, तो यह एक भूलभुलैया के बराबर है जिसे ऊपर स्थानांतरित कर दिया गया है। तो हम इसे गिरा सकते हैं। इसी तरह एक चक्रव्यूह के लिए जो तीन वामपंथी कोशिकाओं में से किसी का भी उपयोग नहीं करता है।
- इससे कोई फर्क नहीं पड़ता कि अगम्य भाग जुड़े हुए हैं, इसलिए हम जोर देते हैं कि प्रत्येक अगम्य सेल पूरी तरह से दीवारों से घिरा हुआ है।
- एक सिंगल पाथ भूलभुलैया जो कि एक बड़ी सिंगल पाथ भूलभुलैया है जो हमेशा बड़ी होने पर हल की जाती है, इसलिए हमें इसकी आवश्यकता होती है। अधिकतम 7 पर आकार का प्रत्येक एकल पथ भूलभुलैया एक बड़ा हिस्सा (अभी भी 3x3 में फिटिंग) का हिस्सा है, लेकिन आकार के 8 एकल पथ mazes हैं जो नहीं हैं। सरलता के लिए, आइए केवल 8. से कम आकार के एकल पथ mazes को छोड़ दें (और मैं अभी भी उपयोग कर रहा हूं कि केवल चरम बिंदुओं को प्रारंभ पदों के रूप में माना जाना चाहिए। सभी पदों का उपयोग निकास पदों के रूप में किया जाता है, जो केवल SAT भाग के लिए मायने रखता है। कार्यक्रम का।)
इस तरह, मुझे कुल 10772 mazes मिलते हैं, जिनमें से एक है।
यहाँ कार्यक्रम है:
#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और solver है, तो कुछ की तरह साथ कार्यक्रम संकलन
है, जहां पथ जहाँ है resp। हैं, इसलिए दोनों उदाहरण के लिए हो सकते हैं
। या बस उन्हें एक ही निर्देशिका में रखें और विकल्पों और विकल्पों के बिना करें।makelingelingg++ -std=c++11 -O3 -I ... -o m3sat m3sat.cc -L ... -llgl...lglib.hliblgl.a../lingeling-<version>-I-L
कार्यक्रम एक अनिवार्य कमांड लाइन तर्क लेता है, एक स्ट्रिंग से मिलकर N, E, S, W(फिक्स्ड दिशाओं के लिए) या *। तो आप 78 *एस (उद्धरणों में) की एक स्ट्रिंग देकर आकार 78 के एक सामान्य समाधान की खोज कर सकते हैं , या एक समाधान के लिए खोज शुरू NEWSकर सकते हैं, NEWSजिसके बाद *आप अतिरिक्त चरणों के लिए जितना चाहें उतना उपयोग कर सकते हैं। पहले परीक्षण के रूप में, अपना पसंदीदा समाधान लें और कुछ अक्षरों को बदल दें *। यह आश्चर्यजनक रूप से "कुछ" के उच्च मूल्य के लिए एक समाधान पाता है।
कार्यक्रम बताएगा कि यह किस भूलभुलैया को जोड़ता है, जिसे दीवार संरचना और प्रारंभ स्थिति द्वारा वर्णित किया गया है, और यह भी पहुंच योग्य पदों और दीवारों की संख्या देता है। इन मानदंडों के आधार पर मज़ारों को क्रमबद्ध किया जाता है, और पहले अनसुलझी को जोड़ा जाता है। इसलिए अधिकांश जोड़ा माज़ होता है (9/4), लेकिन कभी-कभी दूसरों को भी दिखाई देता है।
मैंने लंबाई 79 के ज्ञात समाधान को लिया, और आसन्न 26 अक्षरों के प्रत्येक समूह के लिए, उन्हें किसी भी 25 अक्षरों के साथ बदलने की कोशिश की। मैंने शुरुआत और अंत से 13 अक्षरों को हटाने की कोशिश की, और शुरुआत में किसी भी 13 और अंत में किसी भी 12 द्वारा प्रतिस्थापित करें, और इसके विपरीत। दुर्भाग्य से, यह सब असंतोषजनक है। तो, क्या हम इसे संकेतक के रूप में ले सकते हैं कि लंबाई 79 इष्टतम है? नहीं, मैंने इसी तरह I० समाधान की लंबाई I ९ की लंबाई में सुधार करने की कोशिश की, और यह भी सफल नहीं रहा।
अंत में, मैंने एक समाधान की शुरुआत को दूसरे के अंत के साथ संयोजित करने की कोशिश की, और एक समाधान के साथ एक समरूपता द्वारा बदल दिया। अब मैं दिलचस्प विचारों से बाहर निकल रहा हूं, इसलिए मैंने आपको यह दिखाने का फैसला किया कि मेरे पास क्या है, भले ही इससे नए समाधान नहीं निकले।
