algorithm - Java finding full routes in NxN grid -


इस सवाल का पहले से ही एक उत्तर है: < / P>

  • 5 जवाब

इसलिए मैं बनाने की कोशिश कर रहा हूँ NxN ग्रिड में पूर्ण पथ खोजने के लिए एक एल्गोरिथ्म उदाहरण के लिए 1x1 ग्रिड में 1 संभव पथ है, 2x2 ग्रिड में 1 है, 3x3 में 2 और 4x4 में 8 है। यह विचार है परिदृश्यों को खोजने के लिए जहां हम ग्रिड के प्रत्येक स्थान को स्थानांतरित कर सकते हैं।

मैंने नौकरी के लिए एक रिकर्सिव फ़ंक्शन बनाया है और यहां कोड है:

  सार्वजनिक स्थिर int getRoutesHelp (int [] [] तालिका, int x, int y) {if (एक्स> टेबल: लैंग-1 || एक्स & लेफ्टिनेंट; 0 || वाई एंड लेफ्टिनेंट; 0; y & gt; टेबल। लांति-1) 0 लौटें; यदि (सारणी [x] [y] == 1) 0 लौटा; तालिका [x] [y] = 1; अगर (आईडडईड (टेबल, एक्स, वाई)) (यदि (हैटेबलफुल (टेबल)) 1 रिटर्न; } Else {int a = getRoutesHelp (तालिका, x-1, y); Int d = getRoutes सहायता (तालिका, एक्स, वाई + 1); Int b = getRoutes सहायता (तालिका, x + 1, y); Int c = getRoutes सहायता (तालिका, एक्स, वाई -1); वापसी + a + b + c + d; } वापसी 0; } सार्वजनिक स्थिर इंट्रेट्सट्राउट्स (पूर्णांक आकार) {int [] [] तालिका = नया इंट [आकार] [आकार]; // init तालिका के लिए (int i = 0; i & lt; आकार; i ++) {के लिए (int एक = 0; एक & lt; आकार; a ++) {टेबल [i] [a] = 0; }} वापसी getRoutes सहायता (तालिका, 0, 0); }  

इसलिए मूल रूप से मैं 0.0 से शुरू कर और सभी संभव दिशाओं में आगे बढ़ना शुरू कर रहा हूं और इसे दोहराकर मुझे सफल मार्गों की मात्रा मिलती है। समस्या यह है कि int d के असाइनमेंट के बाद मूल तालिका किसी तरह 1 से भरी जाती है, लेकिन यह तब तक खाली होनी चाहिए जब तक कि मैं समझता हूं क्योंकि जावा तालिका की एक प्रति सही से गुजरती है? मैं इस तरह 4 घंटों के लिए लड़ रहा हूं और वास्तव में इस समस्या को नहीं मिल सकता है इसलिए किसी भी मदद की सराहना की जाती है। तालिका में रिक्त स्लॉट 0 से चिह्नित होते हैं और 1 के साथ भरे गए स्लॉट्स।

संपादित करें: मैंने कॉपी करने के साथ मेरे पास समस्या को ठीक करने में कामयाब रहे और अब मेरी दूसरी समस्या यह है कि 5x5 ग्रिड मेरे एल्गोरिदम 52 मार्गों को रिटर्न करता है और यह 86 होनी चाहिए। तो यह 4x4 ग्रिड के साथ ठीक है, लेकिन एक बार जब मैं आगे बढ़ता हूं तो यह टूट जाता है।

यहां आइडड फ़ंक्शन जोड़ा गया है

  सार्वजनिक स्थिर बूलीयन हैडडएंड (int [] [] तालिका, int x, int y) {int toCheck [] = नया इंट [4]; ToCheck [0] = x-1; // चेक करने के लिए छोड़ दिया [1] = y-1; // शीर्ष करने के लिए चेक [2] = x + 1; // सही चेक [3] = y + 1; // नीचे अंतराल मूल्यों [संपादित करें] नए int [4]; // बाएं, ऊपर, दाएं, नीचे (इंट I = 0; i & lt; 4; i ++) के लिए {int tarkastettava = toCheck [i]; अगर (टेर्कस्टेटावा & gt; तालिका.लांबि-1 || टीर्कस्टेटावा & lt; 0) {valuesOfDirections [i] = 1; } और {if (i == 0 = i == 2) {valuesOfDirections [i] = तालिका [तारकास्टावा] [या]; } Else {valuesOfDirections [i] = तालिका [x] [तर्कास्टेटावा]; }}} के लिए (इंट आई = 0; आई & lt; 4; i ++) {यदि (मान ऑफीडियरेक्शन [i] == 0) {वापसी झूठी; }} सही सत्य; }  

इसे सोचने के लिए आओ, आप शायद यहां एक साधारण बैकएक्ट कर सकते हैं: < / P>

  तालिका [x] [y] = 1; अगर (आईडडईड (टेबल, एक्स, वाई)) (यदि (हैटेबलफुल (टेबल)) 1 रिटर्न; } तालिका [x] [y] = 0; }  

और बाद में:

  int res = a + b + c + d; If (res == 0) {// बैकट्रैक यहां भी तालिका [x] [y] = 0; } रिटर्न रिज़;  

Comments

Popular posts from this blog

sql - Find last match with latest inserted name in table -

c# - XML serialize base class without knowing derived class -

ios - Invalid IPA: missing embedded provisioning profile. Are you sure this is an ad hoc? -