Weighted Bipartite Matching

The weighted bipartite matching problem aims to find a maximum weight matching in a weighted bipartite graph. It has applications in resource allocation.

Some key algorithms are:

  • Hungarian algorithm
  • Kuhn-Munkres algorithm
  • Flow-based methods

Java - Hungarian algorithm:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

int maxWeightMatching(int[][] graph) {
  
  int n = graph.length;
  int[] mate = new int[n];
  Arrays.fill(mate, -1);

  int[] label = new int[n];
  Arrays.fill(label, Integer.MAX_VALUE);
  
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      label[i] = Math.min(label[i], graph[i][j]);
    }
  }
  
  for (int i = 0; i < n; i++) {  
    // Find augmenting path
    // Augment flow  
  }

  int weight = 0;
  for (int i = 0; i < n; i++) {
    weight += graph[i][mate[i]];
  }

  return weight;
}

C++ - Kuhn-Munkres algorithm:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

int maxWeightMatching(vector<vector<int>> graph) {

  int N = graph.size(); 
  vector<int> mate(N, -1);
  vector<int> label(N, INT_MAX);

  for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++) {
      label[i] = min(label[i], graph[i][j]); 
    }
  }

  // Kuhn-Munkres algorithm
  
  int weight = 0;
  for (int i = 0; i < N; i++) {
    weight += graph[i][mate[i]];
  }

  return weight;
}

Python - Flow-based method:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from networkx import *

def maxWeightMatching(weights):
  
  N = len(weights)
  graph = Graph()

  for i in range(N):
    graph.add_node(f"a{i}", demand=-1) 
    graph.add_node(f"b{i}", demand=1)
    
  for i in range(N):
    for j in range(N):
      graph.add_edge(f"a{i}", f"b{j}", weight=weights[i][j], capacity=1)

  match = nx.max_weight_matching(graph, maxcardinality=True)
  return sum(graph[u][v]['weight'] for u, v in match)

Weighted bipartite matching extends the classic assignment problem to weighted graphs.

Weighted Bipartite Matching is a type of graph algorithm used to find an optimal set of edge pairings in a bipartite graph that maximizes the sum of their weights. In simpler terms, a bipartite graph is divided into two disjoint sets, and you want to connect the nodes between these sets in such a way that the total sum of the weights on the chosen edges is maximized. The Hungarian algorithm is commonly used to solve this problem.

Let’s visualize the concept of Weighted Bipartite Matching. In a bipartite graph, you have two sets of vertices, and each edge connects a vertex from the first set to a vertex from the second set. When these edges have weights, we get a “weighted” bipartite graph.

Consider a simple weighted bipartite graph with two sets (X) and (Y).

Set (X): (A, B)

Set (Y): (W, Z)

The weights for the edges connecting these sets are:

  1. Edge (AW) with weight 1
  2. Edge (AZ) with weight 2
  3. Edge (BW) with weight 2
  4. Edge (BZ) with weight 1

Here’s a textual representation:

    A ----1---- W
    | \        / |
    |  \      /  |
    2    \/    2
    |  /  \  /   |
    |/     \/    |
    B ----1---- Z

A weighted bipartite matching aims to find a matching (a subset of edges) such that:

  1. Each vertex is connected to at most one vertex from the other set.
  2. The sum of the weights of the chosen edges is maximized (or minimized, depending on the problem).

For this example, a maximum weighted matching could be ( (AW, BZ) ) with a total weight of ( 1 + 1 = 2 ).

Alternatively, ( (AZ, BW) ) is also a maximum weighted matching with a total weight of ( 2 + 2 = 4 ).

Understanding the visual representation helps in grasping the concept of how to select edges to maximize (or minimize) the sum of weights in the bipartite graph. This is often solved using algorithms like the Hungarian algorithm.

Solution

Java

In Java, the Hungarian algorithm can be implemented to solve weighted bipartite matching.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class HungarianAlgorithm {
    // Placeholder for the code. Implement Hungarian algorithm here.
}

public class Main {
    public static void main(String[] args) {
        // Create a cost matrix
        int[][] costMatrix = {
            {4, 2, 8},
            {4, 3, 7},
            {3, 1, 6}
        };

        // Use Hungarian algorithm to find optimal matching
        HungarianAlgorithm hungarian = new HungarianAlgorithm();
        // Implement function to find and print maximum matching
    }
}

C++

In C++, you can implement the Hungarian algorithm similarly.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class HungarianAlgorithm {
    // Placeholder for the code. Implement Hungarian algorithm here.
};

int main() {
    // Create a cost matrix
    int costMatrix[3][3] = {
        {4, 2, 8},
        {4, 3, 7},
        {3, 1, 6}
    };

    // Use Hungarian algorithm to find optimal matching
    HungarianAlgorithm hungarian;
    // Implement function to find and print maximum matching
    return 0;
}

Python

In Python, the Hungarian algorithm is often easier to implement due to its dynamic typing and ease of list manipulation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class HungarianAlgorithm:
    # Placeholder for the code. Implement Hungarian algorithm here.

# Create a cost matrix
cost_matrix = [
    [4, 2, 8],
    [4, 3, 7],
    [3, 1, 6]
]

# Use Hungarian algorithm to find optimal matching
hungarian = HungarianAlgorithm()
# Implement function to find and print maximum matching

Key Takeaways

  • Weighted Bipartite Matching is used to find an optimal set of edges in a bipartite graph that maximizes the sum of their weights.
  • The Hungarian algorithm is commonly used to solve this problem and can be implemented in Java, C++, and Python.
  • The structure of the code in all three languages will involve defining a class or methods for the Hungarian algorithm and then applying it to a cost matrix.