The k-cut Problem: Better Approximate and Exact Algorithms

1. the k-cut problembetter approximate and exact algorithms Anupam Gupta Carnegie Mellon University Based on joint work with: Euiwoong Lee (NYU) and Jason Li (CMU) SODA 2018 (and work in progress)

2. fine-grainedapproximation algorithms Anupam Gupta Carnegie Mellon University Based on joint work with: Euiwoong Lee (NYU) and Jason Li (CMU) SODA 2018 (and work in progress)

3. the k-cut problem Given graph G, delete minimum weight edges to cut graph into at least k components. NP-hard[Goldschmidt Hochbaum 94] rand min-cut algo in time[Karger Stein 96] det. algo in time[Thorup 00] W[] hard with parameter [Downey et al. 03] 2-approx [Saran Vazirani 95] (2-)-approx disproves Small Set Expansion hypothesis[Manurangsi 17] Q: Can we do better?

4. do better? version (approx. algos) hard with parameter can’t do better than exactly -approx disproves SSE can’t do better than 2x in poly time Q: Can we get -approximation in FPT time ? A: We don’t know, but… Theorem: 1.8-approx in FPT time. Today: show ideas behind 1.999-approx in FPT time.

5. do better? version (exact algos) at least as hard as clique may not beat best exact algorithms take time Q: Can we get tight results? A: We don’t know, but… Theorem: exact algorithms in Today (probably not): show ideas behind algorithm that runs in time “” “” “”

6. result #: FPT approx • Theorem: -approx for -cut in time • The main ideas: • greedy algo is 2-approx. • if greedy is better, we’re done • look at instances where greedy does poorly • bad examples have special structure • exploit structure via another algorithm

7. the greedy algorithm [Saran Vazirani 95] greedy algorithm is 2-approximate For iterations, greedily take the min global cut Proof: is possible cut. either or is a possible cut . For all , our cut . Hence our cost is at most times OPT.

8. tight examples [Saran Vazirani 95] greedy algorithm is 2-approximate For iterations, greedily take the min global cut Proof: is possible cut. either or is a possible cut . For all , our cut . Hence our cost is at most times OPT.

9. idea #: branching [Saran Vazirani 95] greedy algorithm is 2-approximate For iterations, greedily take the min global cut recall: cut what about vs suppose then must be completely cut, else it's a valid cut! union of some of algo’s components is exactly (!!) Idea #: guess all subsets of components Branching factor: , branching depth: time Henceforth, assume for all components that we find in greedy.

10. all cuts smaller than [Saran Vazirani 95] greedy algorithm is 2-approximate For iterations, greedily take the min global cut Assume: all cuts

11. idea #2: if there are gaps… Idea #2: If there’s a gap, we win. if Similarly, if a b

12. hard case for greedy No gaps: even first cut has In particular, mincut(G) for all

13. crossing cuts Hard case: mincut(G) for all Consider all -min-cuts in G. Idea #3: If two of them cross: min 4-cut mincut(G). Greedily take min-4-cuts: pay mincut(G), get new pieces. so paying mincut(G) per new component. If we can do this times, we save .

14. crossing cuts Hard case: mincut(G) for all near-min-cuts don’t cross (laminar family) Recall: only many near-min-cuts. Can represent by tree T. Optimal cut = deleting incomparable edges in this tree Idea #4: special algorithm for this “laminar cut” problem. “Given G and T, delete k-1 incomp edges, minimize cut value”

15. special case: “partial vertex cover” T = star Cut edges to minimize cut. Reduces to: graph H, pick nodes, minimize weight of edges hitting them Algo: Pick min-degree nodes. overcount!  Case 1: Case II: #edges H overcount edges, error randomly color edges red/blue, throw away red edges. w.p. have all intra-OPT edges blue, all cut edges red. -approximation in FPT time

16. to recap • Theorem: -approx for -cut in time • The main ideas: • ensure we haven’t found the min-cut, else we win • repeatedly find either min-cut or min 4-wise cut • if many of these “small”, we win • else, instance has most near-min-cuts being non-crossing • then use special algorithm for this “laminar-cut” instance • builds on the partial vertex cover ideas • dynamic programming which repeatedly calls partial vertex cover.

17. result #: faster exact algos • Theorem: exact algorithms in time • Today: algorithm in time. • Main ideas: • Thorup’s tree-packing theorem • incomparable case: reduction to max-weight triangle • general case: careful dynamic program • reducing the crossings

18. Thorup’s tree theorem Can efficiently find tree T such that it crosses OPT cut at most times. Enumeration gives his time algorithm. Use structure of k-cut to get better?

19. special case: incomparable crossings tree crosses OPT times Say times. Create tripartite graph: “nodes” in each part = edges of tree. link between two “nodes” if incomparable Weight of link captures edges cut: w( , ) = wt. of edges leaving red blob, except to green blob find max-weight triangle in time. To remove incomparability assumption: careful DP.

20. reducing crossings In general, tree crosses OPT times Show that: delete random edge from tree & add random edge in G crossing resulting cut Pr[ reduce the number of edges in OPT ] =

21. recap of result #: faster exact algos • Today: algorithm in time. • Main ideas: • Thorup’s tree-packing theorem • incompable case: reduction to max-weight triangle • general case: delicate DP • reducing the crossings

22. in summary • New algorithms for k-cut, both in the exact and approximate setting. • fixed-parameter runtime to get better approximations • brings new set of ideas into play • tight results? • extension to the hypergraph k-cut problem? • Better understanding of interplay between FPT and approximation? • better algorithms for other problems in FPT time? • E.g., dense-k-subgraph in time? Thanks!