From a61f86617149397551da2fb6db4e98232721bd0f Mon Sep 17 00:00:00 2001 From: joachimschmidt557 Date: Tue, 26 Mar 2019 14:24:14 +0100 Subject: [PATCH] Endlich funktionierts richtig --- Projektgruppe_175/src/base/Graph.java | 5 +- .../src/base/GraphAlgorithm.java | 68 ++++++++++++++----- .../student/GraphAlgoComplexityTest.java | 8 ++- doc/Dokumentation.tex | 21 ++++-- 4 files changed, 77 insertions(+), 25 deletions(-) diff --git a/Projektgruppe_175/src/base/Graph.java b/Projektgruppe_175/src/base/Graph.java index 81261b9..005bdc4 100644 --- a/Projektgruppe_175/src/base/Graph.java +++ b/Projektgruppe_175/src/base/Graph.java @@ -103,7 +103,7 @@ public class Graph { public List> getEdges(Node node) { return edges.stream() - .filter(x -> x.getNodeA().equals(node) || x.getNodeB().equals(node)) + .filter(x -> x.contains(node)) .collect(Collectors.toList()); } @@ -118,8 +118,7 @@ public class Graph { public Edge getEdge(Node nodeA, Node nodeB) { return edges.stream() - .filter(x -> x.getNodeA().equals(nodeA) && x.getNodeB().equals(nodeB) || - x.getNodeA().equals(nodeB) && x.getNodeB().equals(nodeA)) + .filter(x -> x.contains(nodeA) && x.contains(nodeB)) .findFirst() .orElse(null); } diff --git a/Projektgruppe_175/src/base/GraphAlgorithm.java b/Projektgruppe_175/src/base/GraphAlgorithm.java index 8b54dad..57e5352 100644 --- a/Projektgruppe_175/src/base/GraphAlgorithm.java +++ b/Projektgruppe_175/src/base/GraphAlgorithm.java @@ -81,18 +81,31 @@ public abstract class GraphAlgorithm { Iterator> iter = availableNodes.iterator(); Iterator> minElemIter = availableNodes.iterator(); - Node minNode; - AlgorithmNode minAlgoNode; + Node minNode = null; + AlgorithmNode minAlgoNode = null; Node tempNode; AlgorithmNode tempAlgoNode; - + + ///// + + /* + + minNode = availableNodes.stream().min((x, y) -> Double.compare(algorithmNodes.get(x).value, algorithmNodes.get(y).value)).orElse(null); + + if (minNode != null) + System.out.println(availableNodes.remove(minNode)); + + if (minNode == null) + return null; + else + return algorithmNodes.get(minNode); + + */ + + ///// + if (iter.hasNext()) { - - // Set minimum to first element - minNode = iter.next(); - minAlgoNode = algorithmNodes.get(minNode); - minElemIter.next(); - + while (iter.hasNext()) { if (DEBUG) @@ -100,14 +113,13 @@ public abstract class GraphAlgorithm { if (DEBUG_2) { System.out.println("gSN with size " + availableNodes.size() + " and n=" + n); - System.out.flush(); } tempNode = iter.next(); tempAlgoNode = algorithmNodes.get(tempNode); - if (tempAlgoNode.value > 0) { - if (tempAlgoNode.value < minAlgoNode.value) { - + if (tempAlgoNode.value >= 0) { + if (minAlgoNode == null || tempAlgoNode.value < minAlgoNode.value) { + // New minimum minNode = tempNode; minAlgoNode = tempAlgoNode; @@ -119,12 +131,22 @@ public abstract class GraphAlgorithm { } minElemIter.remove(); + //availableNodes.remove(minNode); + + if (DEBUG_2) + if (minNode != null) + System.out.println("Exit gSN with sN="+minNode.getValue()); + else + System.out.println("Exit gSN with sN=null"); return minAlgoNode; } return null; + + + } /** @@ -149,6 +171,10 @@ public abstract class GraphAlgorithm { if (DEBUG_2) System.out.println("Enter run"); + if (DEBUG_2) { + + } + AlgorithmNode v = getSmallestNode(); while (v != null) { @@ -177,7 +203,7 @@ public abstract class GraphAlgorithm { n.value = a; n.previous = v; - System.out.println("--" + n + " " + n.previous); + System.out.println("--" + n.node.getValue() + " " + n.previous.node.getValue()); } @@ -213,18 +239,26 @@ public abstract class GraphAlgorithm { if (prevNode == null) return null; + //int x = 0; + while (!(prevNode.value == 0)) { + //if (x > 1000) + //return null; + + //x++; + if (DEBUG_2) System.out.println("Iteration"); AlgorithmNode prevPrevNode = prevNode.previous; - - if (prevNode.equals(prevPrevNode)) throw new IndexOutOfBoundsException(); - + if (prevPrevNode == null) return null; + if (DEBUG_2) + System.out.println("==" + prevNode.node.getValue() + " " + prevPrevNode.node.getValue()); + reversePath.add(new Edge(prevPrevNode.node, prevNode.node)); prevNode = prevPrevNode; diff --git a/Projektgruppe_175/src/tests/student/GraphAlgoComplexityTest.java b/Projektgruppe_175/src/tests/student/GraphAlgoComplexityTest.java index 977fc42..620bb76 100644 --- a/Projektgruppe_175/src/tests/student/GraphAlgoComplexityTest.java +++ b/Projektgruppe_175/src/tests/student/GraphAlgoComplexityTest.java @@ -17,6 +17,8 @@ public class GraphAlgoComplexityTest { for (int i = 30; i < 50; i+=1) { + /* + Graph g = generateGraph(i); DumbGraphAlgorithm ga = new DumbGraphAlgorithm(g, g.getNodes().get(0)); @@ -28,6 +30,8 @@ public class GraphAlgoComplexityTest { System.out.println(i + "," + ga.getN() + "," + divN + "," + divN2 + "," + divN3); + */ + ///////////// Graph g2 = generateGraph2(i); @@ -35,7 +39,7 @@ public class GraphAlgoComplexityTest { ga2.run(); - List> path = ga2.getPath(g2.getNodes().get(12)); + List> path = ga2.getPath(g2.getNodes().get(2)); for (Edge edge : path) { System.out.println(edge.getNodeA().getValue().toString() + " " + edge.getNodeB().getValue().toString()); } @@ -79,6 +83,8 @@ public class GraphAlgoComplexityTest { g.addEdge(nodes.get(i), nodes.get(i+1)); } + g.addEdge(nodes.get(6), nodes.get(9)); + return g; } diff --git a/doc/Dokumentation.tex b/doc/Dokumentation.tex index 3807e21..274b8f8 100644 --- a/doc/Dokumentation.tex +++ b/doc/Dokumentation.tex @@ -250,14 +250,27 @@ Schritten $M^h$ die Längen von den Pfaden enthält, die am kürzesten sind und dabei nicht mehr als $h + 1$ Kanten besuchen. -%Für die Graphmatrix $M$ gilt außerdem -%$M(k_1, k_2) < 0$ usw. bis $M(k_n, k_1) < 0$. +Sei also $x$ die Länge des Zykels. Es gilt: $x < 0$. +Daraus folgt, dass $2 \cdot x < x$ und $3 \cdot x < x$ usw. +Bei beliebig großen $n$ gibt es also die Gefahr, +dass der Algorithmus versucht, so oft wie möglich +diesen Zyklus zu durchlaufen, um die kleinste Länge +zu erreichen. \subsubsection{Teil (b)} -Best case: $\Theta()$ +Best case: In diesem Fall müsste der Algorithmus -Worst case: $\Theta()$ +$$\Theta()$$ + +Worst case: Im schlimmsten Fall müsste der Algorithmus +in jeder Iteration der Schleife die Länge von jedem +Knoten zu jedem anderen Knoten berechnen. Es müssten +also alle Felder der $(n \times n)$-Matrix neu berechnet +werden. Deswegen müssten jede Iteration $n^2$ Schritte +durchgeführt werden. Das resultiert in der Asymptotik + +$$\Theta(n^3)$$ \section{Weitergestaltung des Spiels}