Finished third exercise of assignment 3 (comp-algo).

algo-comp/ass3/algo-comp-3-answers.tex

@@ -34,37 +34,15 @@
 
 
 \section{Chemische stof}
-
-Een bepaalde chemische stof kan maximaal $n$ keer door een veredelingsproces
-gehaald worden, en elke keer dat dat gebeurt gaat er wat van die stof verloren.
-De stof kan ook na een willekeurige stap in dat proces verkocht worden. Als een
-hoeveelheid $x$ van de stof na stap $r$ verkocht wordt levert dat $\phi_r(x)$
-op. Als een hoeveelheid $y$ van de stof door het veredelingsproces gehaald
-wordt, heb je daarna nog maar $a * y$ van de stof over (hier is $a < 1$ de
-factor). Bedenk een dynamic programming algoritme die uitrekent hoeveel van de
-stof je in welke stap moet verkopen om de maximale winst te scoren. Wat is de
-complexiteit van uw algoritme?
-
 Na elke veredeling stijgt de waarde van de stof (er geldt dus
 $\phi_{r+1}(x) > \phi_{r}(x)$, als $x$ niet verandert). De hoeveelheid $x$ van
 de stof neemt af bij elke veredeling ($x_{i+1} = x_i * a$ met $a < 1$). De
 maximale winst van de chemische stof wordt behaald als $\phi_r(x)$ maximaal is.
 
-%\begin{lstlisting}[language=python,backgroundcolor=\color{darkgray}]
-%i = 0
-%
-%while i < n:
-%    phi(r, x)
-%
-%    i += 1
-%\end{lstlisting}
-
-\noindent
 Stel: $x_0$ = 6 en $\phi_0(x) = \frac{1}{2} x$. In dit voorbeeld nemen we aan dat
 $\phi_{r+1}(x) = \phi_r(x) * c$ met $c = 1.4$. Tot slot geldt in dit voorbeeld
-dat $a = 0.8$. Dat levert de volgende tabel op: \\
-
-\hspace{-.45in}
+dat $a = 0.8$. Dat levert de volgende tabel op:
+\begin{table}[H]
 \begin{tabular}{|r|l|l|l|l|l|l|l|l|l|l|}
 \hline
  & $x_0$ & $x_1$ & $x_2$ & $x_3$ & $x_4$ & $x_5$ & $x_6$ & $x_7$ & $x_8$ & $x_9$ \\
@@ -89,21 +67,30 @@ $\phi_8(x)$ &  44.27 & 35.42 & 28.34 & 22.67 & 18.13 & 14.51 & 11.61 & 9.28 & 7.
 \hline
 $\phi_9(x)$ &  61.98 & 49.59 & 39.67 & 31.74 & 25.39 & 20.31 & 16.25 & 13.00 & 10.40 & 8.32 \\
 \hline
-
-%\hline
-% & $x_0$ & $x_1$ & $x_2$ & $x_3$ & $x_4$ \\
-%\hline
-%$\phi_0(x)$ & 8.000 & 6.400 & 5.120 & 4.096 & 3.277 \\
-%\hline 
-%$\phi_1(x)$ & 11.20 & 8.960 & 7.168 & 5.734 & 4.588 \\
-%\hline
-%$\phi_2(x)$ & 15.68 & 12.54 & 10.04 & 8.028 & 6.423 \\
-%\hline
-%$\phi_3(x)$ & 21.95 & 17.56 & 14.05 & 11.24 & 8.992 \\
-%\hline
-%$\phi_4(x)$ & 30.73 & 24.59 & 19.67 & 15.74 & 12.59 \\
-%\hline
 \end{tabular}
+\end{table}
+
+\noindent Uit de tabel valt op te maken dat de cel $\phi_9(x_9)$ het meest voordelig is.
+Daardoor is het volgende algoritme bedacht:
+
+\begin{lstlisting}[language=python,backgroundcolor=\color{darkgray}]
+def phi(i, x):
+    if i == 0:
+        return 0.5 * x
+    else:
+        return phi(i-1, x * 1.4)
+    
+def x_i(i, x):
+    if i == 0:
+        return x
+    else:
+        return x_i(i-1, x * 0.8)
+
+max = phi(n, x_i(x, x0))
+\end{lstlisting}
+
+\noindent De worse-case tijdcomplexiteit van dit algoritme is van de orde
+$\mathcal{O}(n)$, omdat het zichzelf recursief aanroept (n keer).
 
 \section{}
 

algo-comp/ass3/profit.py

@@ -29,19 +29,24 @@ for i in range(0,max_i):
     lookup.append(r)
     r = []
 
+print " === calculations ==="
+
 n = 10
 x_step = float(x0) / n
 s = []
+left = float(x0)
 
 for i in range(0, n):
-    s.append(phi(i, x_step))
+    left -= x_step
+    s.append(phi(i, x_i(i, x_step)))
 
-print s, len(s), sum(s)
+print left, s, len(s), sum(s)
 
-print "x_n = x0 / n = %.3f =>" % x_step, sum([phi(i, x_step) for i in range(0, n)])
+print "x_n = x0 / n = %.3f =>" % x_step, sum([phi(i, x_i(i, x_step)) for i in range(0, n)])
 
-for f in range(2, 10):
+for f in range(2, 10, 1):
     x = float(x0)
+    left = x
 
     for d in range(0, n):
         x /= f
@@ -49,10 +54,15 @@ for f in range(2, 10):
     s = []
 
     for i in range(0, n-1):
+        print x
         x *= f
-        s.append(phi(i, x))
-
-    s.append(phi(n, x))
-    print s, len(s)
+        left -= x
+        s.append(phi(i, x_i(i, x)))
+    
+    s.append(phi(n, x_i(n, left)))
+    print left, s, len(s)
 
     print "x_n = x * %d =>" % f, sum(s)
+
+
+print "all x in phi():", phi(n, x_i(n, float(x0)))