The Fiduccia-Mattheyses algorithm is an iterative partitioning algorithm that aims to reduce the net cut cost of a weighted graph. It works by computing the gain of moving each vertex to the opposite partition and iteratively moving the vertex with the highest gain. This continues until all vertices are locked in and the algorithm terminates. The key steps are to initially compute gains, select the highest gain move, update all affected gains, and repeat until done. An example run on a sample graph demonstrates computing initial gains and making moves until the algorithm converges.

1. FIDUCCIA MATTHEYSES

2. FIDUCCIA MATTHEYSES
• Starts with possibly some random solution and changes the solution by sequence of
moves. At the beginning of pass all vertices are free to move (unlocked) and each
possible move is labeled with immediate changes in total cost called gain. Iteratively
a move with highest gain is selected and locked.
• Selection of best gain and update are repeated until all nodes are locked.
•This method had three operations, first computation of initial gain value, second
retrieval of best gain, and third update of all affected gain values.

3. FEATURES
• Aims at reducing the net-cut cost.
• Works well with weighted graphs.
• Only a single vertex is moved across the cut each time.
• Can handle unbalanced partitions .
• A special data structure is used to select vertices to be moved across.

4. STEPS…
• Compute gains of all cells, Gi = FS(i) – TE(i).
• Select base cell.
• Lock base cell.
• Check for more free cells.
• Choose for best sequence of moves for k-base cells.
• Make k-moves permanent and free all cells.

5. SOLVED EXAMPLE
Random initial partition

6. Gain(c)=FS(c)-TS(C)=1

7. c is contained in net n1, n2 and n3. n3 contains cell c as its only cell from left
partition, so FS(c)=1. Non of the nets are entirely located in left partition, so
TE(c)=0.
Gain(c)=FS(c)-TS(C)=1
F(c) = 1 T(c) = 0; G(c) = 1
F(d) = 1 T(d) = 0; G(d) = 1
F(g) = 2 T(c) = 0; G(g) = 2
F(a) = 0 T(a) = 0; G(a) = 0
F(b) = 1 T(b) = 0; G(b) = 1
F(e) = 2 T(e) = 0; G(e) = 2
F(f) = 1 T(f) = 0; G(f) = 1
F(h) = 0 T(h) = 0; G(h) = 0

8. Move 1: e

9. F(a) = 0 T(a) = 1; G(a) = -1
F(c) = 0 T(c) = 1; G(c) = -1
F(g) = 1 T(g) = 1; G(g) = 0
F(d) = 1 T(d) = 0; G(d) = 1
F(b) = 1 T(b) = 0; G(b) = 1
F(f) = 2 T(f) = 0; G(f) = 2
F(h) = 0 T(h) = 0; G(h) = 0

10. MOVE 2: f has the max gain, but moving f will violate the area constraint. So we
move d.

11. F(a) = 0 T(a) = 1; G(a) = -1
F(c) = 1 T(c) = 1; G(c) = 0
F(g) = 1 T(g) = 1; G(g) = 0
F(b) = 0 T(b) = 0; G(b) = 0
F(f) = 1 T(f) = 1; G(f) = 0
F(h) = 0 T(h) = 0; G(h) = 0

12. MOVE 3: consider b.

13. F(a) = 0 T(a) = 1; G(a) = -1
F(c) = 0 T(c) = 1; G(c) = -1
F(g) = 1 T(g) = 1; G(h) = 0
F(f) = 1 T(f) = 1; G(f) = 0
F(h) = 0 T(h) = 0; G(h) = 0

14. MOVE 4: choose g.

15. F(a) = 0 T(a) = 1; G(a) = -1
F(c) = 0 T(c) = 1; G(c) = -1
F(f) = 1 T(f) = 2; G(f) = -1
F(h) = 0 T(h) = 1; G(h) = -1

16. MOVE 5: We choose a.

17. F(c) = 0 T(c) = 0; G(c) = 0
F(f) = 1 T(f) = 2; G(f) = -1
F(h) = 0 T(h) = 1; G(h) = -1

18. MOVE 6: We consider f.

19. F(c) = 0 T(c) = 1; G(c) = -1
F(h) = 0 T(h) = 0; G(h) = 0

20. MOVE 7:

21. F(c) = 0 T(c) = 1; G(c) = -1

22. MOVE 8 (LAST MOVE):