This document summarizes the Kernighan-Lin algorithm for graph partitioning. It discusses implementing the K-L algorithm to partition graphs with up to 40,000 vertices from test cases on the DIMACS website. Key observations were that it was slower than multilevel partitioning and had space complexity of O(V*V), which could exceed memory for graphs over 50,000 vertices. The document then provides an overview of the K-L algorithm rationale and pseudo code for a 2-way partition. It notes that graph partitioning is NP-hard and further work is needed to address space complexity and find measures to evaluate results.

1. Graph Partition
Rohit Talwar
201001003
Project Mentor
Dr. Suresh Purini

2. Contents
• Recap
• Problems Addressed
• K-L Algorithm
• Pseudo Code
•What’s Next

3. Recap
• The Problem – K Way Partitioning
• Required – A Parallel Solution
• Basis of Comparison - Sequential Approach
• Most Popular : K-L Algorithm : used in most Implementations

4. Problem Addressed
• Implemented K – L algorithm
• Ran on variety of test cases – from 200 to 40,000 vertices
• Test cases adhere to Metis format obtained from DIMACS website
• Key Observations :
• Slower than Multilevel Partition – Metis
• Space Considerations - O(V*V)
• Might exceed memory for bigger sized graphs (> 50,000) 9 GB!

5. Kernighan Lin Algorithm
• Complexity – O(n2 logn )
• Heuristic Technique
• V divided into two equal subsets
• Assumes weight of all vertices to be equal
• Modifications applied : to get K way partition with unequal weights of
vertices

6. Rationale
• Required - Equal disjoint subsets ( let A & B)
• Swap 2 vertices(a ϵ A, b ϵ B) <- Maintains equal partitions
• Ea = sum of crossing or external edges from a into B
• Ia = sum of internal edges from a into A
• Snew = Sold + Ia + Ib – Ea – Eb + 2*c(a,b)
• Da = Ea - Ia & Db = Eb - Ib
• Sold – Snew = Da + Db - 2*c(a,b)
• Maximize Da + Db - 2*c(a,b) as each swap should minimize Snew

7. Pseudo Code – 2 way partition
1. Initial Partition the nodes into 2 sets A and B
2. Calculate D for A & B
3. Sort A and B on basis of D values
4. Check pairwise and calculate G
For (each a in A) {
For (each b in B) {
if (Da + Db < G){ Break }
else if (Da + Db -2*Cab > G) {
G = Da + Db -2*Cab;
Nexta = a; Nextb = b
}
}
}

8. 5. Put G, NextA & NextB into queue and mark them as visited
6. Update D values in A and B
Da = Da + 2*CaNexta – 2*CaNextb; Db = Db + 2*CbNextb – 2*CbNexta
7. If all nodes visited goto step 8 else step 3.
8. Find Gsum > 0 having maximum i such that – Gsum = 1
𝑖
𝐺
9. If I = 0 i.e Gsum cant be a positive quantity then stop else goto 3.

9. What’s Next
● Graph Partition is NP Hard – there is no right solution
● Need to find a measure of correctness/viability to compare results
● Need to find and set approximations for algorithm to converge
● Need to address the space complexity

10. Thanks
Q & A