Problema de emparejamiento piloto | Flujo de red: coincidencia binaria máxima (algoritmo húngaro)

Problema de emparejamiento piloto

Los grados	10	hora de apertura	Martes, 21 de abril de 2020 10:10
descuento	0,8	Tiempo de descuento	Sábado, 30 de mayo de 2020 23:55
Se permite la presentación tardía	No	Hora de cierre	Sábado, 30 de mayo de 2020 23:55

Descripción del problema: durante la Segunda Guerra Mundial, la Royal Air Force reclutó un gran número de pilotos extranjeros de los países ocupados. Cada avión enviado por la Royal Air Force debe estar equipado con dos pilotos que puedan cooperar entre sí en cuanto a navegación e idioma, uno de ellos Uno es un piloto británico y el otro es un piloto extranjero. Entre los muchos pilotos, cada piloto extranjero puede cooperar bien con varios otros pilotos británicos. Cómo elegir un par de pilotos para enviar la mayor cantidad de aviones a la vez.

Diseño de algoritmos: para una cooperación determinada entre pilotos extranjeros y pilotos británicos, averigüe el número máximo de pilotos que la Royal Air Force puede enviar.

Entrada de datos: hay dos números enteros positivos myn en la primera línea. N es el número total de pilotos en la Royal Air Force (n <100); m es el número de pilotos extranjeros. Los pilotos extranjeros se numeran 1 ~ m, y los pilotos británicos se numeran m + 1 ~ n. Los siguientes dos enteros i y j en cada línea indican que el piloto extranjero i puede cooperar con el piloto británico j. Finalmente, termina con 2 -1.

Salida de resultados: La Royal Air Force puede enviar la mayor cantidad de pilotos.

	Entrada de prueba	Rendimiento esperado	límite de tiempo	Limite de memoria	Proceso extra
Caso de prueba 1	Mostrar como texto 5 10↵ 1 7↵ 1 8↵ 2 6↵ 2 9↵ 2 10↵ 3 7↵ 3 8↵ 4 7↵ 4 8↵ 5 10↵ -1 -1 ↵	Mostrar como texto 4↵	1 segundo	Los 64M	0

---

        Este es un problema de coincidencia de gráficos bipartitos , que se puede convertir en un algoritmo de flujo máximo para resolverlo, o se puede usar directamente el algoritmo húngaro. Este artículo utiliza el algoritmo húngaro directamente.

        Para comprender el principio y el proceso del algoritmo, puede leer este artículo: Algoritmo húngaro (simple y fácil de entender) . El algoritmo húngaro es simple y fácil de entender, esencialmente codicioso. El código AC del algoritmo húngaro se pega directamente a continuación, y los comentarios amistosos deben ser fáciles de entender ~

//匈牙利算法解决二部图的最大流问题

#include <cstdio>
#include <cstring>

#define MAXN 105

int m, n;   //二部图左侧有m个，总计有n个
bool connected[MAXN][MAXN];   //图的连接关系
int pre[MAXN] = {0};   //next[j]=i:左侧的 i 点与右侧的 j 点匹配

/* 处理输入与初始化 */
void Init() {
    scanf("%d %d", &m, &n);
    int i, j;
    while (true) {
        scanf("%d %d", &i, &j);
        if (i == -1 && j == -1)
            break;
        connected[i][j] = true;
    }
}

bool vis[MAXN];

/* 寻找左侧的点与右侧匹配 */
bool Find(int left) {
    //依次遍历右部顶点
    for (int right = m + 1; right <= n; right++) {
        //寻找 相邻 且 此次查找没有被考虑过 的右侧点
        if (connected[left][right] && !vis[right]) {
            vis[right] = true;
            //寻找 没有匹配 或 该点的匹配点可以另有匹配 的右侧点
            if(pre[right] == 0 || Find(pre[right])) {
                pre[right] = left;   //匹配
                return true;
            }
        }
    }
    return false;
}

int CalcAns(){
    int ans = 0;
    /* 讨论每一个左部顶点 */
    for(int left = 1; left <= m; left++) {
        memset(vis, false, sizeof(vis));   //每次寻找前需要初始化
        if(Find(left))  //如果能找到
            ans++;  //匹配数字加一
    }
    return ans;
}

int main() {
    Init();
    printf("%d\n", CalcAns());
}