Reverse algorithm engineering (Java code)

[Xyz1]

Hallo, ist es möglich, diesen Algorithmus zu vereinfachen oder zu parallelisieren oder eine Heuristik anzuwenden:

		List<Object[]> results = /*...*/;
		List<E1> list1 = /*...*/;
		List<E2> list2 = /*...*/;
		Map<E2, E3> map1 = /*...*/;
		for (E1 e1 : list1) {
			if (condition_a(e1)) {
				for (E2 e2 : list2) {
					if (condition_b(e2) && condition_c(e1, e2)) {
						if (map1.containsKey(e2)) {
							E3 e3 = map1.get(e2);
							if (condition_d(e3) && condition_e(e1, e2, e3)) {
								results.add(new Object[] { e1, e2, e3 });
							}
						}
					}
				}
			}
		}

 

[thecain]

Willst du noch erkären was er tut/tun soll oder soll das eine Übung für uns sein?

 

[Xyz1]

Nein, eigentlich nicht (Er soll Loops finden, also eine profitable Route zwischen zwei Entitäten, die auch den Bedingungen entspricht)

 

[mrBrown]

Die Schleifen lassen sich parallelisieren und condition_a, condition_b und condition_d lassen sich vorher berechnen (wäre dann für b und c O(M) statt O(N*M)).

 

[Xyz1]

Danke! Genauso eine Antwort habe ich erwartet! Mit den Conditions meinst du eine Vorfilterung oder?

 

[mrBrown]

Mit den Conditions meinst du eine Vorfilterung oder?

Ja, aus den Listen und der Map kann man einfach vorher alles rausschmeißen, was die jeweilige Bedingung nicht erfüllt.

 

[Flown]

Außer aus list1 würde ich das nicht machen, da ja nur einmal iteriert wird und das on-the-fly handlen würde:

List<E2> prefilteredList2 = list2.stream().filter(this::condition_b).collect(Collectors.toList());
Map<E2, E3> prefilteredMap = map1.entrySet().stream()
    .filter(e -> condition_d(e.getValue()))
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));


List<Object[]> results = list1.parallelStream()
    .filter(this::condition_a)
    .flatMap(e1 ->
        prefilteredList2.stream()
            .filter(e2 -> condition_c(e1, e2))
            .filter(prefilteredMap::containsKey)
            .flatMap(e2 ->
                Stream.of(prefilteredMap.get(e2))
                    .filter(e3 -> condition_e(e1, e2, e3))
                    .map(e3 -> new Object[] {e1, e2, e3})
            )
    ).collect(Collectors.toList());

Streams kinderleicht zu parallelisieren. Bezweifle aber einen benefit.