I am having two algorithms, of which the second is a refinement of the first. However, I am having trouble to show that the seemingly better algorithm runs at least as fast as the first algorithm.
The algorithms aim to be FPT with respect to the parameter $k$ for the following problem:
Circle-Cover:
Input: A set of points $P\subseteq\mathbb R^2$ and $k\in\mathbb N$.
Question: Can we find $k$ circles such that each point $p\in P$ lies on the boundary of at least one circle?
The key observation for both algorithms is that a circle is uniquely determined by at most 3 points which are not collinear (or equivalently, affinely independent).
This gives us a branching algorithm in which we start with $k$ empty sets $P_1,...,P_k$ such that $C(P_i)$ is a/the circle which intersects all points in $P_i$.
For each element $p\in P$ we test if there is a set $P_i$ with $|P_i|=3$ and for which $p$ is on the boundary of $C(P_i)$. If not, we branch: For every set $P_1,...,P_k$ we test if we can add $p$ into it (which is the case if $|P_i|<3$ and the points aren't collinear), and if so, we create a subcase in which we add $p$ to the set.
Now we have that there exists set of $k$ circles cutting all points in $P$ if and only if at least one instance of the branching algorithm manages to allocate all points to the sets $P_1,...,P_k$.
This branching algorithm has a branching vector with width $k$, because we create at most for every of the sets $P_1,...,P_k$ a subcase, and width $3k$, as each set $P_1,...,P_k$ can contain at most 3 elements. Since each instance of the branching algorithm runs in polynomial time, we have a runtime $\mathcal{O^*}(k^{3k})$.
However, this algorithm wastes work since if there exists an instance in an execution of the branching algorithm with the sets $P_1,...,P_k$, then for every permutation $\sigma\in S_k$, we also have an instance with the sets $P_{\sigma(1)},...,P_{\sigma(k)}$. It should therefore be faster to make sure that we create each partition of $P$ into elements of size $\le 3$ at most once.
For simplicity, assume that all triples $\{p_1,p_2,p_3\}\subseteq P$ are not collinear.
Then we can find a solution of Circle-Cover if one exists by iteratively branching for each subset $\{p_1,p_2,p_3\}\subseteq P$ and deleting all points in $P$ which are on the boundary defined by $C(\{p_1,p_2,p_3\})$. If there exists a branching instance with depth $k-1$ such that there at most 3 elements left to allocate, then there exists a solution.
Looking at the running time, at depth $i$ we have at most $n-3(i-1)$ elements left to allocate, so we have at depth $i$ a width of $\binom{n-3(i-1)}3$, giving us a total running time of $$ \mathcal{O^*}(\prod_{i=0}^{k-1}\binom{\left|n\right|-3i}{3}) \in \mathcal{O^*}(\prod_{i=0}^{k-1} (n-3i)^3) $$
We further have $$ \prod_{i=0}^{k-1}\left(n-3i\right)^3 =\left(\prod_{i=0}^{k-1}\left(n-3i\right)\right)^3 =\left(\frac{3^k·(n/3)!}{(n/3-k)!}\right)^3 =3^{3k} \left(\left(\frac{n}{3}\right)⋅\left(\frac{n}{3}-1\right)⋯\left(\frac{n}{3}-k+1\right)\right)^3 ≤3^{3k} \left(\frac{n}{3}\right)^{3k} = n^{3k} $$
giving us a total runtime of $\mathcal{O^*}(n^{3k} )$.
However, this runtime analysis doesn't show that the algorithm runs in FPT with regard to the parameter $k$, and it's even slower than the first algorithm.
What is it I am missing?
