🙌🏽 🚐 💴 मलोकस्की सुरक्षित मामला 🕘 🐥 📭

मुझे लगता है कि यहां मौजूद कई लोग गेम रेंजर्स को जानते हैं। इसके अलावा, मुझे नहीं लगता कि अगर मैं कहता हूं कि मुझे बहुत गलत लगता है, तो बहुत हद तक, इस खेल का आकर्षण, वास्तव में, इसे पुनर्जीवित करता है, पाठ quests । इनमें से कुछ quests, जैसे कि Citadels या स्की रिज़ॉर्ट, को अच्छी तरह से स्वतंत्र खेल माना जा सकता है।

टेक्स्ट क्वैश्चंस के प्रति मेरा दृष्टिकोण दुगुना है। एक ओर, वे बहुत ही रोचक और अकल्पनीय रूप से वायुमंडलीय हैं। दूसरी ओर, उनमें से कुछ के माध्यम से प्राप्त करना आसान नहीं है। "पंद्रह" की खोज ने मुझे तुरंत प्रभावित किया। सामान्य तौर पर, मैं सभी प्रकार की पहेलियों को हल करने में बहुत अच्छा नहीं हूं, इसलिए मैंने एक कार्यक्रम लिखने का फैसला किया जो मेरे लिए एक समाधान ढूंढेगा।

तो, असाइनमेंट की शर्तों के अनुसार, हमें तिजोरी को खोलने की आवश्यकता है, जिसके लिए हमें पहेली को सुलझाने की जरूरत है, जो कि प्रसिद्ध गेम 15 की दर्दनाक याद ताजा करती है।

समानता के बावजूद, दो महत्वपूर्ण अंतर हैं जिनका उल्लेख किया जाना चाहिए:

पहेली को सीमित संख्या में हल करने की आवश्यकता है
जैसा कि आप देख सकते हैं, चिप्स पर नंबर दोहराए जाते हैं

चाल की संख्या पर प्रतिबंध, जैसा कि नीचे दिखाया गया है, हमें समस्या को हल करने में मदद करेगा (मैं ध्यान देता हूं कि सबसे कम समाधान की खोज करना आवश्यक नहीं है, यह 59 चालों से अधिक नहीं होने वाले किसी भी समाधान को खोजने के लिए पर्याप्त है)। दूसरा बिंदु इतना सरल नहीं है। पहली नज़र में, यह समाधान को सरल करना चाहिए, लेकिन ऐसा नहीं है।

यह व्यापक रूप से ज्ञात है कि खेल "15" में संभावित पदों में से आधे का कोई समाधान नहीं है। इसके अलावा, पदों के हिस्से के लिए, हल करने के लिए आवश्यक न्यूनतम चाल की संख्या, नौकरी की शर्तों में निर्दिष्ट चालों की संख्या से अधिक हो सकती है। इस प्रकार, यदि हम चिप्स की एक जोड़ी को गलत स्थान पर ले जाना शुरू करते हैं, तो हम सबसे अधिक संभावना पहेली को हल करने में सक्षम नहीं होंगे। युग्मित टुकड़ों के साथ भ्रमित न होने के लिए, यह एक अनोखे तरीके से उन्हें पुनः बनाने के लिए समझ में आता है, पहेली को क्लासिक गेम "15" तक कम कर देता है।

चूंकि, असाइनमेंट की शर्तों के अनुसार, 7 जोड़े मिलान चिप्स हैं, वास्तव में 2 ^ (7 - 1) = 64 पहेलियों में से एक को हल करना आवश्यक है, जिनमें से कुछ का समाधान नहीं होगा। यह निस्संदेह कार्य को जटिल बनाता है।

समस्या के समाधान के साथ आगे बढ़ने से पहले, हम ध्यान दें कि 16 कोशिकाओं की स्थिति को संग्रहीत करना आवश्यक है, जिनमें से प्रत्येक 16 राज्यों में हो सकता है (एक खाली सेल को शून्य से एन्कोड किया जाएगा)। यह आपको स्थिति को स्टोर करने के लिए 8-बाइट पूर्णांक का उपयोग करने की अनुमति देता है।

आइए क्लासिक पहेली "15" को हल करके शुरू करें (गैर-दोहराए जाने वाले चिप्स के साथ):

solver.h

#ifndef SOLVER_H_ #define SOLVER_H_ #include <stdio.h> #include "common.h" #include "PerfCnt.h" class Solver { public: Solver(Long startPos, Long endPos, int stepCnt): startPos(startPos), endPos(endPos), stepCnt(stepCnt), posCnt(0), perfCnt() {} bool solve(); private: Long startPos; Long endPos; int stepCnt; Long posCnt; PerfCnt perfCnt; static Long pos[MAX_DEEP]; static Byte step[MAX_DEEP]; void dumpSolve(int deep); void dumpPos(int delta); void dumpTotal(); bool checkPos(Long p, int deep); bool solve(int deep, int delta, int startDelta, int X, int Y); Long getStep(Long p, int x, int y, int dx, int dy, int& dd); }; #endif

solver.cpp

 #include "solver.h" Long Solver::pos[MAX_DEEP]; Byte Solver::step[MAX_DEEP]; void Solver::dumpPos(int delta) { printf("Distance: %d\n\n", delta); Long mask = 0xFFFF; for (int shift = 48; shift >= 0; shift -= 16) { int x = (int)((startPos & (mask << shift)) >> shift); int y = (int)((endPos & (mask << shift)) >> shift); printf("%04X %04X\n", x, y); } } void Solver::dumpSolve(int deep) { printf("\n"); for (int i = 0; i < deep; i++) { printf("%d", step[i]); } printf("\n"); } void Solver::dumpTotal() { printf("\nCount: %6I64d\n", posCnt); printf("Time: %7.3f\n\n", perfCnt.elapsed()); } bool Solver::checkPos(Long p, int deep) { int j = MAX_LOOP; for (int i = deep - 1; i >=0; i--) { if (pos[i] == p) return true; if (--j <= 0) break; } return false; } bool Solver::solve() { if (stepCnt >= MAX_DEEP) return false; pos[0] = startPos; int delta = getDelta(startPos, endPos); int X = getX(startPos); int Y = getY(startPos); dumpPos(delta); bool r = solve(0, delta, delta, X, Y); dumpTotal(); return r; } Long Solver::getStep(Long p, int x, int y, int dx, int dy, int& dd) { Long digit = getDigit(p, x + dx, y + dy); if (digit == 0) return p; if (dx != 0) { int delta = getDeltaX(startPos, endPos, digit); if (delta * dx <= 0) { dd++; } else { dd--; } } if (dy != 0) { int delta = getDeltaY(startPos, endPos, digit); if (delta * dy <= 0) { dd++; } else { dd--; } } xorDigit(p, x, y, digit); xorDigit(p, x + dx, y + dy, digit); return p; } bool Solver::solve(int deep, int delta, int startDelta, int X, int Y) { if (pos[deep] == endPos) { dumpSolve(deep); return true; } if (delta > stepCnt - deep) { return false; } if (delta - startDelta > MAX_DELTA_DIFF) { return false; } for (int i = 0; i < 4; i++) { int dd = 0; int dx = 0; int dy = 0; switch (i) { case 0: dy--; break; case 1: dx++; break; case 2: dy++; break; case 3: dx--; break; } if ((X + dx < 1)||(Y + dy < 1)||(X + dx > 4)||(Y + dy > 4)) continue; if (deep + 1 >= MAX_DEEP) return false; pos[deep + 1] = getStep(pos[deep], X, Y, dx, dy, dd); if (checkPos(pos[deep + 1], deep)) continue; step[deep] = i; posCnt++; if (solve(deep + 1, delta + dd, startDelta, X + dx, Y + dy)) return true; } return false; }

यह एक साधारण वापसी खोज है। हम सभी संभावित चालों पर पुनरावृत्ति करते हैं, स्थिति बदलते हैं और नई स्थिति के लिए उसी फ़ंक्शन को पुनरावर्ती कहते हैं। किए गए कदम 0 से 3 तक की संख्याओं के साथ एन्कोड किए गए हैं, जो खाली सेल (0 - अप, 1 - दाईं ओर, 2 - नीचे, 3 - बाईं ओर) की गति की दिशा का संकेत देते हैं:

  switch (i) { case 0: dy--; break; case 1: dx++; break; case 2: dy++; break; case 3: dx--; break; }

समाधान को आउटपुट करने की सुविधा के लिए, हम स्टैक पर पूर्ण चाल के अनुक्रम को संग्रहीत करते हैं (चूंकि चाल की संख्या कार्य की शर्तों द्वारा सीमित है, आप एक नियमित स्थैतिक सरणी का उपयोग कर सकते हैं)।

इस दृष्टिकोण की मुख्य कठिनाई खोज की गहराई के आधार पर देखी गई स्थितियों की संख्या में एक हिमस्खलन जैसी वृद्धि है। यह किसी भी तरह से चाल को काटने के लिए आवश्यक है कि स्पष्ट रूप से सही निर्णय न हो। निम्नलिखित विचार मदद करेंगे:

प्रत्येक स्थिति के लिए, 2 से 4 संभावित चालें संभव हैं (खाली सेल की स्थिति के आधार पर), जबकि यह पहले से माना पदों (पदों की तरह चाल, एक स्थिर स्टैक में संग्रहित किया जा सकता है) को दोहराने के लिए कोई मतलब नहीं है।
प्रत्येक स्थिति के लिए, आप मैनहट्टन की दूरी को वांछित स्थिति (सभी चिप्स को उनके स्थान पर वापस करने के लिए आवश्यक चाल की कुल संख्या की गणना कर सकते हैं, बशर्ते कि अन्य चिप्स उनके साथ हस्तक्षेप न करें)। पाठ में आगे, मैं इसे बस दूरी कहूंगा। यदि गणना की गई दूरी शेष चालों की संख्या से अधिक है, तो स्थिति का कोई हल नहीं है और आगे की खोज को रोका जा सकता है (यहां हमें इस ज्ञान से मदद की जाती है कि पहेली एन चालों से अधिक नहीं में हल होती है)।

चूंकि दूरी की गणना एक अपेक्षाकृत संसाधन-गहन ऑपरेशन है, इसे एक बार (प्रारंभिक स्थिति के लिए) गणना की जा सकती है, फिर चिप के आंदोलन की दिशा के आधार पर इस मूल्य को बढ़ा या घटाया जाता है, जो कि अगला कदम है।

हम सहायक कार्यों को लागू करते हैं:

common.h

 #ifndef COMMON_H_ #define COMMON_H_ typedef unsigned __int64 Long; typedef unsigned __int16 Short; typedef unsigned char Byte; const int MAX_POSITION = 4; const int MAX_DIGIT = 15; const int MAX_DEEP = 100; const int MAX_LOOP = 10; const int MAX_TASKS = 100; const int MAX_DELTA_DIFF = 5; int getPosition(Long part); int getX(Long state); int getY(Long state); int getX(Long state, Long d); int getY(Long state, Long d); int getDeltaX(Long a, Long b, Long d); int getDeltaY(Long a, Long b, Long d); int getDelta(Long a, Long b); Long getDigit(Long p, int x, int y); void xorDigit(Long& p, int x, int y, Long d); void setDigit(Long& p, Long m, Long d); #endif

common.cpp

 #include "common.h" #include <math.h> Long digit[MAX_DIGIT + 1] = { 0x0000000000000000L, 0x1111111111111111L, 0x2222222222222222L, 0x3333333333333333L, 0x4444444444444444L, 0x5555555555555555L, 0x6666666666666666L, 0x7777777777777777L, 0x8888888888888888L, 0x9999999999999999L, 0xAAAAAAAAAAAAAAAAL, 0xBBBBBBBBBBBBBBBBL, 0xCCCCCCCCCCCCCCCCL, 0xDDDDDDDDDDDDDDDDL, 0xEEEEEEEEEEEEEEEEL, 0xFFFFFFFFFFFFFFFFL }; int getPosition(Long part) { for (int i = 4; i > 0; i--) { if ((part & 0xF) == 0) return i; part >>= 4; } return 0; } int getX(Long state) { for (int i = 4; i >= 1; i--) { int r = getPosition(state & 0xFFFF); if (r != 0) return r; state >>= 16; } return 0; } int getY(Long state) { for (int i = 4; i >= 1; i--) { int r = getPosition(state & 0xFFFF); if (r != 0) return i; state >>= 16; } return 0; } int getX(Long state, Long d) { state ^= digit[d]; return getX(state); } int getY(Long state, Long d) { state ^= digit[d]; return getY(state); } int getDeltaX(Long a, Long b, Long d) { a ^= digit[d]; b ^= digit[d]; return getX(a) - getX(b); } int getDeltaY(Long a, Long b, Long d) { a ^= digit[d]; b ^= digit[d]; return getY(a) - getY(b); } int getDelta(Long a, Long b) { int r = 0; for (Long d = 1; d <= MAX_DIGIT; d++) { r += abs(getDeltaX(a, b, d)); r += abs(getDeltaY(a, b, d)); } return r; } Long getDigit(Long p, int x, int y) { for (; y <= 4; y++) { if (y == 4) { p &= 0xFFFF; for (; x <= 4; x++) { if (x == 4) { return p & 0xF; } p >>= 4; } break; } p >>= 16; } return -1; } void xorDigit(Long& p, int x, int y, Long d) { for (; x < 4; x++) { d <<= 4; } for (; y < 4; y++) { d <<= 16; } p ^= d; } void setDigit(Long& p, Long m, Long d) { p ^= p & m; m &= digit[d]; p ^= m; }

प्रदर्शन का अनुकूलन करने के लिए, हम अधिकांश बिट संचालन करने का प्रयास करते हैं।

यह सुनिश्चित करने के लिए कि सब कुछ काम करता है, आप एक छोटी पहेली को हल कर सकते हैं:

 1 2 3 4 5 1 3 4 5 6 7 8 9 2 B 7 9 ABCD 6 A 8 DEFEFC

चूंकि मैंने खुद इस उदाहरण को तैयार किया है, मुझे पता है कि इसे हल करने के लिए 11 चालें पर्याप्त हैं।

दरअसल, इस सीमा के साथ, कार्यक्रम एक सेकंड के हजारवें हिस्से में उत्तर प्रदर्शित करता है:

 Distance: 11 1234 5134 5678 92B7 9ABC D6A8 DEF0 0EFC 00323003222 Count: 18 Time: 0.001

हम देखते हैं कि 18 वस्तुओं पर विचार किया जाता है। चाल की संख्या और अंतिम स्थिति की दूरी पर सीमा के अंतर के आधार पर जटिलता में वृद्धि का आकलन करने के लिए, मैं चाल की संख्या को देखते हुए, चाल की संख्या पर सीमा बढ़ाऊंगा।

अंतिम ग्राफ इस प्रकार है:

ग्राफ की sawtoothness को इस तथ्य से समझाया जाता है कि कार्यक्रम नए (लंबे) समाधानों को ढूंढता है, जबकि चाल की संख्या पर सीमा को बढ़ाता है। जैसी कि उम्मीद थी, देखे गए पदों की संख्या बहुत जल्दी बढ़ जाती है।

अब यह चिप्स की जोड़ी के पुनर्निधारण को लागू करने के लिए बना हुआ है। इसमें, पुनरावृत्ति भी मदद करेगी:

initializer.h

 #ifndef INITIALIZER_H_ #define INITIALIZER_H_ #include "common.h" #include "solver.h" struct Task { Long startPos; Long endPos; int delta; bool isProcessed; }; class Initializer { public: Initializer(Long startPos, Long endPos, int stepCnt): startPos(startPos), endPos(endPos), stepCnt(stepCnt), taskCnt(0) {} bool solve(); private: Long startPos; Long endPos; int stepCnt; int taskCnt; static Task tasks[MAX_TASKS]; static int digits[MAX_DIGIT + 1]; bool checkInit(Long s, Long e); bool addPos(Long s, Long e); bool init(Long s, Long e); Long getFreeDigit(); bool checkPos(Long s, Long e); void normalize(Long& p); void dumpPos(Long s, Long e, int delta); }; #endif

initializer.cpp

 #include "initializer.h" Task Initializer::tasks[MAX_TASKS]; int Initializer::digits[MAX_DIGIT + 1]; bool Initializer::solve() { if (!init(startPos, endPos)) return false; while (true) { int mn = stepCnt; int ix = -1; for (int i = 0; i < taskCnt; i++) { if (tasks[i].isProcessed) continue; if (stepCnt - tasks[i].delta < mn) { mn = stepCnt - tasks[i].delta; ix = i; } } if (ix < 0) break; tasks[ix].isProcessed = true; Solver solver(tasks[ix].startPos, tasks[ix].endPos, stepCnt); if (solver.solve()) return true; } return false; } bool Initializer::checkInit(Long s, Long e) { for (int i = 0; i <= MAX_DIGIT; i++) { digits[i] = 0; } for (int i = 0; i <= MAX_DIGIT; i++) { digits[s & 0xF]++; s >>= 4; } if (digits[0] != 1) return false; for (int i = 0; i <= MAX_DIGIT; i++) { digits[e & 0xF]--; e >>= 4; } for (int i = 0; i <= MAX_DIGIT; i++) { if (digits[i] != 0) return false; } return true; } void Initializer::dumpPos(Long s, Long e, int delta) { printf("0x"); Long mask = 0xFFFF; for (int shift = 48; shift >= 0; shift -= 16) { int x = (int)((s & (mask << shift)) >> shift); printf("%04X", x); } printf(" 0x"); mask = 0xFFFF; for (int shift = 48; shift >= 0; shift -= 16) { int x = (int)((e & (mask << shift)) >> shift); printf("%04X", x); } printf(" %d\n", delta); } bool Initializer::addPos(Long s, Long e) { if (!checkPos(s, e)) return true; if (taskCnt >= MAX_TASKS) return false; tasks[taskCnt].startPos = s; tasks[taskCnt].endPos = e; tasks[taskCnt].delta = getDelta(s, e); tasks[taskCnt].isProcessed = false; if (tasks[taskCnt].delta == 0) return false; if (tasks[taskCnt].delta > stepCnt) return true; taskCnt++; return true; } Long Initializer::getFreeDigit() { for (Long i = 1; i <= MAX_DIGIT; i++) { if (digits[i] == 0) return i; } return 0; } bool Initializer::init(Long s, Long e) { for (int i = 0; i <= MAX_DIGIT; i++) { digits[i] = 0; } Long x = s; for (int i = 0; i <= MAX_DIGIT; i++) { digits[x & 0xF]++; x >>= 4; } bool f = true; for (int i = 0; i <= MAX_DIGIT; i++) { if (digits[i] != 1) f = false; } if (f) { return addPos(s, e); } Long d = getFreeDigit(); if (d == 0) return false; x = s; Long ms = 0xF; for (int i = 0; i <= MAX_DIGIT; i++) { Long t = x & 0xF; if (digits[t] > 1) { setDigit(s, ms, d); Long y = e; Long me = 0xF; for (int j = 0; j <= MAX_DIGIT; j++) { if ((y & 0xF) == t) { Long k = e; setDigit(k, me, d); if (!init(s, k)) return false; } me <<= 4; y >>= 4; } break; } ms <<= 4; x >>= 4; } return true; } void Initializer::normalize(Long& p) { int x = getX(p); int y = getY(p); for (; x < 4; x++) { Long d = getDigit(p, x + 1, y); xorDigit(p, x + 1, y, d); xorDigit(p, x, y, d); } for (; y < 4; y++) { Long d = getDigit(p, x, y + 1); xorDigit(p, x, y + 1, d); xorDigit(p, x, y, d); } } bool Initializer::checkPos(Long s, Long e) { normalize(s); normalize(e); Long nums[16] = {0}; int ix = 0; for (int y = 1; y < 4; y++) { for (int x = 1; x < 4; x++) { Long d = getDigit(e, x, y); if (d != 0) { nums[d] = ++ix; } } } int cn = 0; for (int y = 1; y < 4; y++) { for (int x = 1; x < 4; x++) { Long d = getDigit(s, x, y); for (Long i = 1; i <= 15; i++) { if (nums[i] < nums[d]) { int Y = getY(s, i); if (Y < y) continue; if (Y > y) { cn++; break; } int X = getX(s, i); if (X > x) { cn++; break; } } } } } return (cn & 1) == 0; }

सूची में जोड़ने से पहले, हम जांचते हैं कि क्या स्थिति का कोई समाधान है और क्या यह निर्दिष्ट संख्या में हल किया जा सकता है (स्थिति की महंगी खोज करने के लिए फिर से जांच करना बेहतर है कि स्पष्ट रूप से कोई समाधान नहीं है)।

यहाँ संभावित स्थिति की एक सूची है, जो दूरी के अवरोही क्रम में क्रमबद्ध है:

सूची

 0x763258F4E1DCBA90 0x6CBEDA1F29873450 50 0x763258F4E1DCBA90 0x6CBED81F29A73450 48 0x763258F4E1DCBA90 0x6CBEDA9F21873450 48 0x763258F4E1DCBA90 0x6CBED89F21A73450 46 0x763258F4E1DCBA90 0x6C4EDA1F29873B50 44 0x763258F4E1DCBA90 0x65BEDA12F98734C0 44 0x763258F4E1DCBA90 0x6CBE7A1F298D3450 44 0x763258F4E1DCBA90 0x6C4ED81F29A73B50 42 0x763258F4E1DCBA90 0x65BED812F9A734C0 42 0x763258F4E1DCBA90 0x6CBE781F29AD3450 42 0x763258F4E1DCBA90 0x6CB3DA1F2987E450 42 0x763258F4E1DCBA90 0x6C4EDA9F21873B50 42 0x763258F4E1DCBA90 0x65BEDA92F18734C0 42 0x763258F4E1DCBA90 0x6CBE7A9F218D3450 42 0x763258F4E1DCBA90 0x6CB3D81F29A7E450 40 0x763258F4E1DCBA90 0x6C4ED89F21A73B50 40 0x763258F4E1DCBA90 0x65BED892F1A734C0 40 0x763258F4E1DCBA90 0x6CBE789F21AD3450 40 0x763258F4E1DCBA90 0x6CB3DA9F2187E450 40 0x763258F4E1DCBA90 0x654EDA12F9873BC0 38 0x763258F4E1DCBA90 0x6C4E7A1F298D3B50 38 0x763258F4E1DCBA90 0x65BE7A12F98D34C0 38 0x763258F4E1DCBA90 0x6CB3D89F21A7E450 38 0x763258F4E1DCBA90 0x654ED812F9A73BC0 36 0x763258F4E1DCBA90 0x6C4E781F29AD3B50 36 0x763258F4E1DCBA90 0x65BE7812F9AD34C0 36 0x763258F4E1DCBA90 0x6C43DA1F2987EB50 36 0x763258F4E1DCBA90 0x65B3DA12F987E4C0 36 0x763258F4E1DCBA90 0x6CB37A1F298DE450 36 0x763258F4E1DCBA90 0x654EDA92F1873BC0 36 0x763258F4E1DCBA90 0x6C4E7A9F218D3B50 36 0x763258F4E1DCBA90 0x65BE7A92F18D34C0 36 0x763258F4E1DCBA90 0x6C43D81F29A7EB50 34 0x763258F4E1DCBA90 0x65B3D812F9A7E4C0 34 0x763258F4E1DCBA90 0x6CB3781F29ADE450 34 0x763258F4E1DCBA90 0x654ED892F1A73BC0 34 0x763258F4E1DCBA90 0x6C4E789F21AD3B50 34 0x763258F4E1DCBA90 0x65BE7892F1AD34C0 34 0x763258F4E1DCBA90 0x6C43DA9F2187EB50 34 0x763258F4E1DCBA90 0x65B3DA92F187E4C0 34 0x763258F4E1DCBA90 0x6CB37A9F218DE450 34 0x763258F4E1DCBA90 0x654E7A12F98D3BC0 32 0x763258F4E1DCBA90 0x6C43D89F21A7EB50 32 0x763258F4E1DCBA90 0x65B3D892F1A7E4C0 32 0x763258F4E1DCBA90 0x6CB3789F21ADE450 32 0x763258F4E1DCBA90 0x654E7812F9AD3BC0 30 0x763258F4E1DCBA90 0x6543DA12F987EBC0 30 0x763258F4E1DCBA90 0x6C437A1F298DEB50 30 0x763258F4E1DCBA90 0x65B37A12F98DE4C0 30 0x763258F4E1DCBA90 0x654E7A92F18D3BC0 30 0x763258F4E1DCBA90 0x6543D812F9A7EBC0 28 0x763258F4E1DCBA90 0x6C43781F29ADEB50 28 0x763258F4E1DCBA90 0x65B37812F9ADE4C0 28 0x763258F4E1DCBA90 0x654E7892F1AD3BC0 28 0x763258F4E1DCBA90 0x6543DA92F187EBC0 28 0x763258F4E1DCBA90 0x6C437A9F218DEB50 28 0x763258F4E1DCBA90 0x65B37A92F18DE4C0 28 0x763258F4E1DCBA90 0x6543D892F1A7EBC0 26 0x763258F4E1DCBA90 0x6C43789F21ADEB50 26 0x763258F4E1DCBA90 0x65B37892F1ADE4C0 26 0x763258F4E1DCBA90 0x65437A12F98DEBC0 24 0x763258F4E1DCBA90 0x65437812F9ADEBC0 22 0x763258F4E1DCBA90 0x65437A92F18DEBC0 22 0x763258F4E1DCBA90 0x65437892F1ADEBC0 20

यह इस क्रम में था कि मैंने पदों को जांचना शुरू किया, क्योंकि मैंने सोचा था कि सबसे तेज़ खोज अधिकतम दूरी वाले पदों के लिए होगी। दरअसल, सूची के पहले तत्वों को कुछ सेकंड में जांचा गया था, लेकिन 42 की दूरी के साथ पहली स्थिति के लिए, 10 मिनट के इंतजार के बाद खोज को रोकना पड़ा।

इस बिंदु पर, मैं थोड़ा उदास था और संभव कदमों की गणना के क्रम को निर्धारित करने के लिए अनुमान लगाने के बारे में सोचना शुरू कर दिया, और वास्तव में, ए * एल्गोरिथ्म का अधिक सावधान अध्ययन। लेकिन, सिर्फ जड़ता से, मैंने सूची के अंतिम तत्व की जांच करने का फैसला किया:

 #include <iostream> #include <tchar.h> #include "initializer.h" int _tmain(int argc, _TCHAR* argv[]) { Initializer m(0x763258F4E1DCBA90, 0x65437892F1ADEBC0, 59); m.solve(); return 0; }

मैं तुरंत यह भी नहीं समझ पाया कि कार्यक्रम का हल मिल गया है:

 Distance: 20 7632 6543 58F4 7892 E1DC F1AD BA90 EBC0 00032103210321032330111223010323032112233000121221 Count: 6117348 Time: 2.404

सिर्फ ढाई सेकंड में।

क्वेस्ट पूरी हुई।

सूत्र, हमेशा की तरह, GitHub पर।

मलोकस्की सुरक्षित मामला

More articles: