die laufzeit einer rekrusiven methode fixen

[hm1]

a) die methode in C programmieren
Das wird nicht schneller werden.

bei einer eingabe von startvec.size()=100 und T=31 läuft das ding mehrere minuten lang, allerdings möchte ich diese methode für mehrere tausend Eid's ausführen (von denen ca. jede 10. einen startvector der länge 100 hat, die meisten haben nur eine länge von 1)
Wie dein Graph aussieht und was du hier/wirklich erreichen willst habe ich noch nicht so ganz durchstiegen.

ich hate tatsächlich noch einen kleinen logik fehler drin, den ich dank dir gefunden habe, der code ist nun (dank bubbles verbesserung) der folgendes:

  
private static HashMap<Integer,Double[]> p(HashMap<Integer,Double[]> map, Integer stationID, int t, int T) {  
        if(T == t+1) {  
                return map;  
        }  
  
        NodeDataIterator graph = new NodeDataIterator();  
        graph.selectStation(stationID);  
        ArrayList<NodeData> nachfolger = graph.getNexts();  
  
        for(NodeData node: nachfolger.toArray(new NodeData[nachfolger.size()])) {  
                Double[] d = map.get(node.id);  
                if(d == null) {  
                        d = new Double[T];  
                        for(int i=0; i<T; i++) {  
                                d[i] = 0.0;  
                        }  
                        map.put(node.id, d); //[1]  
                }  
  
                Tupel edgeWK0 = Controller.edgesWK.get(String.valueOf(StochastischeMatrix.kombi(stationID,node.id)));  
                Tupel edgeWK1 = edgeWK0 == null ? null : Controller.edgesWK.get(String.valueOf(StochastischeMatrix.kombi(stationID,stationID)));  
  
                if(edgeWK1 != null && edgeWK1.zahl[0] != 0) {  
                	if(d[t] != 0.0)  
                        d[t] = edgeWK0.zahl[0]/edgeWK1.zahl[1];  
                	else {  
                		Double[] prob = {d[t], (edgeWK0.zahl[0]/edgeWK1.zahl[1])};  
                		d[t] = gemVerteilung(prob);  
                	}  
                }  
                else {  
                        d[t] = 0.0;  
                }  
                //map.put(node.id, d);[1]  
                if(d[t] != 0) {  
                        return p(map, node.id, t+1, T);  
                }  
        }  
        return map;  
}  

aufgerufen durch:

  
for(Integer item: startvec.toArray(new Integer[startvec.size()]))  
		{  
	        p(map, item, 0, T);  
		}  

ich möchte folgendes tun:

gegeben: G=(V,E), S aus V, und T

für alle A, B aus E gilt, dass das kantengewicht w(A,B) die wahrscheinlichkeit dafür ist, dass von knoten A zu knoten B gewechselt wird innerhalb eines schrittes.

berechnen möchte ich eine HashMap map die als key die ID eines jeden knoten enthält, welchen wir erreichen können innerhalb von t schritten sowie die dazugehörigen kantengewichte.

beispiel:

T=2, S={A}

und G sei:
A -> A (selbstabbildung)
A -> B

dann ist die ausgabe:

map.get(NodeID)[t] = wahrscheinlichkeit im t-ten schritt Node mit NodeID zu erreichen und auf diesem node zu stehen (imt t-ten schritt mit t <= T)

map.get(B)[1] = w(A,B) für A -> B
map.get(B)[2] = gemVerteilung(w(A,A),w(A,B)) für A -> A -> B

map.get(A)[1] = w(A,A) für A -> A
map.get(A)[2] = gemVerteilung(w(A,A),w(A,A)) für A -> A -> A

und das möchte ich beschleunigen, eventuell kann ich den aufruf reinziehen in die rekrusive methode oder was in C oder so drehen....