2012-05-08 27 views
7

मैंने वस्तुओं की एक दी गई सूची के सभी संभावित क्रमपरिवर्तन खोजने के लिए एक कार्यक्रम लिखा है। यह ठीक मतलब यह है कि मेरा कार्यक्रम प्रिंट हर संभव पी (एन, आर) आर के लिए = 0 एनसंख्याओं की सूची के क्रमिक क्रम के लिए जावा कोड

नीचे करने के लिए मानों कोड है:

package com.algorithm; 

import java.util.ArrayList; 
import java.util.Calendar; 
import java.util.Collection; 
import java.util.HashSet; 
import java.util.List; 
import java.util.Set; 

public class Permutations<T> { 
    public static void main(String args[]) { 
     Permutations<Integer> obj = new Permutations<Integer>(); 
     Collection<Integer> input = new ArrayList<Integer>(); 
     input.add(1); 
     input.add(2); 
     input.add(3); 

     Collection<List<Integer>> output = obj.permute(input); 
     int k = 0; 
     Set<List<Integer>> pnr = null; 
     for (int i = 0; i <= input.size(); i++) { 
      pnr = new HashSet<List<Integer>>(); 
      for(List<Integer> integers : output){ 
      pnr.add(integers.subList(i, integers.size())); 
      } 
      k = input.size()- i; 
      System.out.println("P("+input.size()+","+k+") :"+ 
      "Count ("+pnr.size()+") :- "+pnr); 
     } 
    } 
    public Collection<List<T>> permute(Collection<T> input) { 
     Collection<List<T>> output = new ArrayList<List<T>>(); 
     if (input.isEmpty()) { 
      output.add(new ArrayList<T>()); 
      return output; 
     } 
     List<T> list = new ArrayList<T>(input); 
     T head = list.get(0); 
     List<T> rest = list.subList(1, list.size()); 
     for (List<T> permutations : permute(rest)) { 
      List<List<T>> subLists = new ArrayList<List<T>>(); 
      for (int i = 0; i <= permutations.size(); i++) { 
       List<T> subList = new ArrayList<T>(); 
       subList.addAll(permutations); 
       subList.add(i, head); 
       subLists.add(subList); 
      } 
      output.addAll(subLists); 
     } 
     return output; 
    } 
} 

आउटपुट

P(3,3) : Count (6) :- [[1, 2, 3], [2, 3, 1], [3, 2, 1], [3, 1, 2], [2, 1, 3], [1, 3, 2]] 
P(3,2) : Count (6) :- [[3, 1], [2, 1], [3, 2], [1, 3], [2, 3], [1, 2]] 
P(3,1) : Count (3) :- [[3], [1], [2]] 
P(3,0) : Count (1) :- [[]] 

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

मैं इसे 8 जीबी रैम और आई 5 प्रोसेसर वाली मशीन पर चला रहा हूं, इसलिए गति और स्थान कोई समस्या नहीं है।

मैं सराहना करता हूं, अगर कोई मुझे अधिक कुशल कोड लिखने में मदद कर सकता है।

+4

बेहतर के लिए अनुकूल [http://codereview.stackexchange.com/](http:/ /codereview.stackexchange.com/)। –

+0

@ एंथनी धन्यवाद :) मैं इस के लिए नया हूं, विचार नहीं है कि कहां रखा जाए। – dharam

उत्तर

8

यदि आप 15-आश या अधिक तत्वों के सभी क्रमपरिवर्तन चाहते हैं, तो उन्हें डिस्क या डीबी या कुछ लिखें, क्योंकि वे स्मृति में फिट नहीं होंगे। संपादित करें: Steinhaus–Johnson–Trotter algorithm। शायद यह वही है जो आप खोज रहे हैं।

+0

मुझे विश्वास है कि आपने जो कहा वह सच है। समस्या भंडारण नहीं है। समस्या समय चल रहा है। लगभग 13 संख्याओं के क्रमपरिवर्तन के लिए इसमें एक मिनट से अधिक समय लग रहा है। – dharam

+0

लिंक वास्तव में महान है। यहां तक ​​कि गतिशीलता मुझे अनुमान लगाने में मदद कर सकती है। सूचक के लिए धन्यवाद। लिंक के लिए यहां – dharam

+0

+1 को आजमाएं और पोस्ट करें, धन्यवाद! – kritzikratzi

1

आपको एहसास है कि आप बहुत बड़ी सूचियां उत्पन्न कर रहे हैं, और सूची की लंबाई बढ़ने के साथ चलने का समय बढ़ जाएगा। क्या आपने यह निर्धारित किया है कि आपको कौन सी सूचियां आपको परेशानी दे रही हैं?

एक चीज जो कुछ लोगों की मदद कर सकती है, उन्हें एक सूची में इकट्ठा करने और उन्हें प्रिंट करने के बजाय प्रत्येक क्रमपरिवर्तन को प्रिंट करना होगा। बेशक, यदि बिंदु वास्तव में पूरी सूची को स्टोर करना है, और न केवल उन्हें मुद्रित करना है, जो मदद नहीं करेगा।

+0

प्रतिक्रिया के लिए धन्यवाद। यहां तक ​​कि अगर मैं इसे मुद्रित करता हूं तो 10 संख्या के लिए उत्पन्न क्रमिक क्रम संख्या 100000 है। मान लीजिए कि मैं इसे संग्रहीत नहीं कर रहा हूं, यहां तक ​​कि उस मामले में भी आदेश नहीं बदला जा रहा है। इसके अलावा मेरे कोड के साथ समस्या यह है कि रिकर्सन पेड़ एक तरफा है। अगर कुछ मायनों से मैं एक एल्गोरिदम पा सकता हूं जो प्रत्येक रिकर्सन पर इनपुट को दो बराबर भागों में विभाजित करता है और फिर छोटी सूचियों के क्रमपरिवर्तन को ढूंढता है और अंत में उन्हें विलय करता है। सिर्फ यह जानना चाहता था कि कोई मुझे उन्नत एल्गोरिदम के लिए एक पुस्तक का संदर्भ दे सकता है या नहीं। – dharam

13

यदि आप इसे संग्रहीत नहीं कर रहे हैं - यदि आप इसके माध्यम से बस इसे सक्रिय कर रहे हैं - तो हेप के एल्गोरिदम (# 3 http://www.cut-the-knot.org/do_you_know/AllPerm.shtml पर # 3) का उपयोग करने पर विचार करें - या, बस अपना जीवन आसान बनाने के लिए, गुवा के Collections2.permutations का उपयोग करें, वास्तव में क्रमपरिवर्तन की पूरी सूची नहीं बनाते - यह फ्लाई पर उनके माध्यम से चलता है। (प्रकटीकरण: मैं अमरूद के लिए योगदान करते हैं।)

+0

अच्छा धन्यवाद, मैं निश्चित रूप से इसे आज़मा दूंगा। – dharam

संबंधित मुद्दे