ट्री खोजें बचत निष्पादन राज्य

Question

मैं एक पेड़ है,

 A 
    /\ 
    B C 
    /\ \ 
D E F 

एक सूची के रूप में प्रतिनिधित्व,

(A (B (D) (E)) (C (F))) 

यह वास्तव में एक बहुत बड़े पेड़ तो मैं करना चाहते हैं क्या है खोज शुरू है अगर मैं यह नहीं ढूंढ पा रहा हूं कि मैं क्या देख रहा हूं 100 एमएस राज्य को बचाओ, वापसी करें, कुछ घर रखो और फिर फिर से खोज करें और जारी रखें जहां मैंने छोड़ा था। असल में सिमुलेशन मैं काम कर रहा हूं मुझे एक निश्चित समय दे रहा है जो खोज को पूरा करने के लिए पर्याप्त नहीं है। मैं इस बात को प्राप्त करने के तरीकों/तकनीकों की तलाश में हूं? (क्लोजर, जावा में)

Answer 1

थ्रेडिंग सबसे आसान समाधान होने की संभावना है, लेकिन यह एक एकल थ्रेड पर यह अपने आप का प्रबंधन करने के लिए बहुत मुश्किल नहीं है। "सिमुलेशन" वातावरण जो आपको केवल 100ms देते हैं, वे किसी भी नए धागे की अनुमति नहीं देते हैं, इसलिए यह एक विकल्प है।

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

(let [timer (atom 9)] 
    (defn keep-going? [] 
    (not= 0 (swap! timer #(mod (inc %) 10))))) 

(defn saving-addition [sum xs] 
    (if-let [[x & more] (seq xs)] 
    (let [next-thunk (fn [] (saving-addition (+ x sum) more))] 
     (if (keep-going?) 
     (next-thunk) 
     next-thunk)) 
    sum)) 

(defn monitor [xs] 
    (loop [thunk (saving-addition 0 xs)] 
    (if (fn? thunk) 
     (do 
     (println "Saving execution state") 
     (recur (thunk))) 
     thunk))) 

user> (monitor (range 25)) 
Saving execution state 
Saving execution state 
Saving execution state 
300 

संपादित करें: क्योंकि Clojure, पूंछ-कॉल अनुकूलन नहीं है एक thunk बनाने और फिर बुला यह ढेर उपयोग करता है। यदि, संभवतः, आप बाधित होने से पहले कुछ हज़ार चरणों से अधिक निष्पादित करने में सक्षम हैं, तो आपको एक स्टैक ओवरफ़्लो मिलेगा। केवल यथार्थवादी समाधान दोनों एक recur में और निरंतरता में thunk के शरीर नकल करने, जैसे

(defn saving-addition [sum xs] 
    (if-let [[x & more] (seq xs)] 
    (let [sum (+ x sum)] 
     (if (keep-going?) 
     (recur sum more) 
     #(saving-addition sum more))) 
    sum)) 

है आप कर सकते थे शायद किसी मैक्रो के साथ इस बाहर सार यदि आप कई तरह के "suspendable" कार्यों लिखना पड़ा।

Answer 2

यदि आपको धागे के ऊपरी हिस्से को कोई फर्क नहीं पड़ता है, तो उस थ्रेड पर खोज डालें जो थोड़ा सा काम करे और फिर समय-समय पर पैदा करे।

धागे का लाभ यह है कि आपको प्रोग्राम को प्रोग्रामिक रूप से सहेजने की ज़रूरत नहीं है; प्रणाली आपके लिए यह करेगी।

आपको जटिलता में इसके लिए भुगतान करना होगा, क्योंकि खोज के नतीजे असीमित रूप से आ जाएंगे और आपको इसे किसी भी तरह से प्राप्त करने की व्यवस्था करनी होगी। इसके अलावा आपको 100ms टाइमर सेट अप करने की आवश्यकता हो सकती है। बहुत सारे कोड :)

Answer 3

करने के लिए

सबसे अच्छी बात जहां आप आसानी से राज्य को बचाने के लिए और बाद में फिर से शुरू कर सकते हैं अंक बनाने के लिए है

तो उन बिंदुओं पर आप तो चुन सकते हैं (आप सबसे अच्छा अंक आसानी से खोजने के लिए समारोह पुनरावर्ती बनाने की कोशिश कर सकते हैं) राज्य को बचाने या