1. Bichromatic Separating Circles

2. Problem Given two sets of points, R and B ∈ R ² where | R | = n and | B | = m: – Find the smallest circle containing all of R and as few points as possible from B

3. Example Smallest enclosing circle Smallest separating circle

4. Possible Applications Communications jamming Minimizing civilian casualties Data set separation

5. Previous Work Fisk - Pure separability in O(nm) time O’Rourke et al. - Pure separability in O(n+m) time using linear programming – Linear Programming methods taken from Meggido

6. Previous Work Hurtado et al. – Color grouping within axis parallel rectangles and strips Aronov et al. – Separating red and blue sets using a line

7. Possible Separating Circles If it contains 3 points from R the answer is the smallest enclosing circle for R Must contain at least two points from R

8. No Less Than Two Red Points Single red point on boundary - contradiction

9. Two Red Points Two red points lying on the boundary of a circle – Farthest two red points since all red points must be contained in the circle

10. Farthest Neighbor Voronoi Diagram An edge is the locus of all points that have the same two farthest points from R Can be thought of as a tree with the root being the center of the minimum enclosing circle of R

11. Finding the Boundary Center circle on farthest Neighbor Voronoi edge Find event point for each point in B Event point is defined as when a blue point enters or exits the circle

12. Finding the Boundary Two red points and the edge of FVD that they define

13. Finding the Boundary Finding the event points

14. Finding the Boundary

15. The Algorithm Compute the FVD for R For each of the O(n) edges of the diagram, we perform an event point sweep – Find event points for all blue points – Sort in order of increasing distance from the red points – Calculate # of blue points within the circle Only need to increment/decrement after first count – Constant time update

16. Running Time/Space Analysis (Smallest Circle) Computing the FVD for R takes O(n logn) time and uses O(n) space For each of the O(n) edges of the diagram, we perform the sweep – This uses O(m) space and O(mlogm) time Thus, overall we use O(n+m) space and O(nmlogm + nlogn) time

17. Event Points Sweep algorithm analyzes all event points Each edge may have O(m) event points As the circle grows, it will eventually enclose all blue points in the halfspace

18. Event Points Each edge may have O(m) event points

19. Event Points Each edge may have O(m) event points

20. Event Points Intersection of halfspaces Place O(m) points within this region – All of those points will cause event points for each of the edges

21. Exit Event Points Size of enclosing circle increases along path from root to leaf Not necessary to analyze all event points – Only analyze exit events

22. Exit Event Points Each edge of FVD( R) defines an exit region Exit regions are disjoint – <= m exit events

23. Counting Blue Points Sweeping allowed count to be found in constant time Use circular range counting

24. Running Time/Space Analysis (Smallest Circle) Second Algorithm Find edge of FVD( R) defining the exit region for each point in B – O(nm) time Perform O(m) circular range counting queries – O*(m 1.5 ) time and space * notation hides a polylogarithmic factor Faster than the sweeping algorithm if n=ω(√m)

25. Bound on the Number of Smallest Circles There are n separating circles in the worst case Lower bound

26. Bound on the Number of Smallest Circles There are n separating circles in the worst case Lower bound

27. Bound on the Number of Smallest Circles There are n separating circles in the worst case Upper bound Center of smallest enclosing circle Root to leaf path increases circle size, so smallest separating circles can only exist on disjoint root to leaf paths

28. Largest Separating Circle Use largest separating circle algorithm for purely separable sets as a subroutine Remove all points from B that are inside circles with the minimum number of blue points encountered during the sweep

29. Largest Separating Circle Subroutine takes O((n+m)log(n+m)) time Overall running time O(m(n+m)log(n+m))