अधिकतम द्विदलीय मिलान

द्विपक्षीय मिलान एक ग्राफ में किनारों का एक सेट है जिसे इस तरह से चुना जाता है, कि उस सेट में कोई भी दो किनारे एक समापन बिंदु साझा नहीं करेंगे। अधिकतम मिलान किनारों की अधिकतम संख्या से मेल खा रहा है।

जब अधिकतम मिलान मिल जाता है, तो हम दूसरा किनारा नहीं जोड़ सकते। यदि अधिकतम मिलान वाले ग्राफ़ में एक किनारा जोड़ दिया जाता है, तो यह अब मेल नहीं खाता है। एक द्विदलीय ग्राफ़ के लिए, एक से अधिक अधिकतम मिलान संभव हो सकते हैं।

इनपुट और आउटपुट

Input:
The adjacency matrix.
0 1 1 0 0 0
1 0 0 1 0 0
0 0 1 0 0 0
0 0 1 1 0 0
0 0 0 0 0 0
0 0 0 0 0 1

Output:
Maximum number of applicants matching for job: 5

एल्गोरिदम

द्विपक्षीय मैच (यू, विज़िट किया गया, असाइन किया गया)

इनपुट: नोड शुरू करना, ट्रैक रखने के लिए विज़िट की गई सूची, दूसरे नोड के साथ नोड असाइन करने के लिए सूची असाइन करना।

आउटपुट - जब वर्टेक्स u के लिए मिलान संभव हो तो सही लौटाता है।

Begin
   for all vertex v, which are adjacent with u, do
      if v is not visited, then
         mark v as visited
         if v is not assigned, or bipartiteMatch(assign[v], visited, assign) is true, then
            assign[v] := u
            return true
   done
   return false
End

मैक्समैच(ग्राफ)

इनपुट - दिया गया ग्राफ।

आउटपुट - मैच की अधिकतम संख्या।

Begin
   initially no vertex is assigned
   count := 0
   for all applicant u in M, do
      make all node as unvisited
      if bipartiteMatch(u, visited, assign), then
         increase count by 1
   done
End

उदाहरण

#include <iostream>
#define M 6
#define N 6
using namespace std;

bool bipartiteGraph[M][N] = {    //A graph with M applicant and N jobs
   {0, 1, 1, 0, 0, 0},
   {1, 0, 0, 1, 0, 0},
   {0, 0, 1, 0, 0, 0},
   {0, 0, 1, 1, 0, 0},
   {0, 0, 0, 0, 0, 0},
   {0, 0, 0, 0, 0, 1}
};

bool bipartiteMatch(int u, bool visited[], int assign[]) {
   for (int v = 0; v < N; v++) {    //for all jobs 0 to N-1
      if (bipartiteGraph[u][v] && !visited[v]) {    //when job v is not visited and u is interested
         visited[v] = true;    //mark as job v is visited
         //when v is not assigned or previously assigned
         if (assign[v] < 0 || bipartiteMatch(assign[v], visited, assign)) {
            assign[v] = u;    //assign job v to applicant u
            return true;
         }
      }
   }
   return false;
}

int maxMatch() {
   int assign[N];    //an array to track which job is assigned to which applicant
   for(int i = 0; i<N; i++)
      assign[i] = -1;    //initially set all jobs are available
   int jobCount = 0;

   for (int u = 0; u < M; u++) {    //for all applicants
      bool visited[N];
      for(int i = 0; i<N; i++)
         visited[i] = false;    //initially no jobs are visited
      if (bipartiteMatch(u, visited, assign))    //when u get a job
         jobCount++;
   }
   return jobCount;
}

int main() {
   cout << "Maximum number of applicants matching for job: " << maxMatch();
}

आउटपुट

Maximum number of applicants matching for job: 5