/**
* 𝓞(n³) implementation of the Hungarian algorithm
*
* Copyright (C) 2011, 2014, 2020 Mattias Andrée
*
* This program is free software. It comes without any warranty, to
* the extent permitted by applicable law. You can redistribute it
* and/or modify it under the terms of the Do What The Fuck You Want
* To Public License, Version 2, as published by Sam Hocevar. See
* http://sam.zoy.org/wtfpl/COPYING for more details.
*/
#include <sys/types.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
/**
* Cell markings
**/
enum {
UNMARKED = 0,
MARKED,
PRIME
};
/**
* Value type for marking
*/
typedef int_fast8_t Mark;
/**
* Value type for cells
*/
typedef signed long int Cell;
typedef int_fast8_t Boolean;
typedef int_fast64_t BitSetLimb;
/**
* Bit set, a set of fixed number of bits/booleans
*/
typedef struct {
/**
* The set of all limbs, a limb consist of 64 bits
*/
BitSetLimb *limbs;
/**
* Singleton array with the index of the first non-zero limb
*/
size_t first;
/**
* Array the the index of the previous non-zero limb for each limb
*/
size_t *prev;
/**
* Array the the index of the next non-zero limb for each limb
*/
size_t *next;
char _buf[];
} BitSet;
typedef struct {
size_t row;
size_t col;
} CellPosition;
/**
* Calculates the floored binary logarithm of a positive integer
*
* @param value The integer whose logarithm to calculate
* @return The floored binary logarithm of the integer
*/
#if defined(__GNUC__)
__attribute__((__const__))
#endif
static size_t
lb(BitSetLimb value)
{
size_t rc = 0;
BitSetLimb v = value;
if (v & (int_fast64_t)0xFFFFFFFF00000000LL) { rc |= 32L; v >>= 32; }
if (v & (int_fast64_t)0x00000000FFFF0000LL) { rc |= 16L; v >>= 16; }
if (v & (int_fast64_t)0x000000000000FF00LL) { rc |= 8L; v >>= 8; }
if (v & (int_fast64_t)0x00000000000000F0LL) { rc |= 4L; v >>= 4; }
if (v & (int_fast64_t)0x000000000000000CLL) { rc |= 2L; v >>= 2; }
if (v & (int_fast64_t)0x0000000000000002LL) { rc |= 1L; }
return rc;
}
/**
* Constructor for BitSet
*
* @param size The (fixed) number of bits to bit set should contain
* @return The a unique BitSet instance with the specified size
*/
static BitSet *
bitset_create(size_t size)
{
size_t c = (size >> 6) + !!(size & 63L);
BitSet *this = calloc(1, offsetof(BitSet, _buf) + c * sizeof(BitSetLimb) + 2 * (c + 1) * sizeof(size_t));
this->limbs = (BitSetLimb *)&this->_buf[0];
this->prev = (size_t *)&this->_buf[c * sizeof(BitSetLimb)];
this->next = (size_t *)&this->_buf[c * sizeof(BitSetLimb) + c * sizeof(size_t)];
return this;
}
/**
* Gets the index of any set bit in a bit set
*
* @param this The bit set
* @return The index of any set bit
*/
#if defined(__GNUC__)
__attribute__((__pure__))
#endif
static ssize_t
bitset_any(BitSet *this)
{
size_t i;
if (!this->first)
return -1;
i = this->first - 1;
return (ssize_t)(lb(this->limbs[i] & -this->limbs[i]) + (i << 6));
}
/**
* Turns off a bit in a bit set
*
* @param this The bit set
* @param i The index of the bit to turn off
*/
static void
bitset_unset(BitSet *this, size_t i)
{
size_t p, n, j = i >> 6;
BitSetLimb old = this->limbs[j];
this->limbs[j] &= ~(1LL << (i & 63L));
if (!this->limbs[j] ^ !old) {
j++;
p = this->prev[j];
n = this->next[j];
this->prev[n] = p;
this->next[p] = n;
if (this->first == j)
this->first = n;
}
}
/**
* Turns on a bit in a bit set
*
* @param this The bit set
* @param i The index of the bit to turn on
*/
static void
bitset_set(BitSet *this, size_t i)
{
size_t j = i >> 6;
BitSetLimb old = this->limbs[j];
this->limbs[j] |= 1LL << (i & 63L);
if (!this->limbs[j] ^ !old) {
j++;
this->prev[this->first] = j;
this->prev[j] = 0;
this->next[j] = this->first;
this->first = j;
}
}
/**
* Reduces the values on each rows so that, for each row, the
* lowest cells value is zero, and all cells' values is decrease
* with the same value [the minium value in the row].
*
* @param n The table's height
* @param m The table's width
* @param t The table in which to perform the reduction
*/
static void
kuhn_reduce_rows(size_t n, size_t m, Cell **t)
{
size_t i, j;
Cell min, *ti;
for (i = 0; i < n; i++) {
ti = t[i];
min = *ti;
for (j = 1; j < m; j++)
if (min > ti[j])
min = ti[j];
for (j = 0; j < m; j++)
ti[j] -= min;
}
}
/**
* Determines whether the marking is complete, that is
* if each row has a marking which is on a unique column.
*
* @param n The table's height
* @param m The table's width
* @param marks The marking matrix
* @param col_covered Column cover array
* @return Whether the marking is complete
*/
static Boolean
kuhn_is_done(size_t n, size_t m, Mark **marks, Boolean col_covered[m])
{
size_t i, j, count = 0;
memset(col_covered, 0, m * sizeof(*col_covered));
for (j = 0; j < m; j++) {
for (i = 0; i < n; i++) {
if (marks[i][j] == MARKED) {
col_covered[j] = 1;
break;
}
}
}
for (j = 0; j < m; j++)
count += (size_t)col_covered[j];
return count == n;
}
/**
* Create a matrix with marking of cells in the table whose
* value is zero [minimal for the row]. Each marking will
* be on an unique row and an unique column.
*
* @param n The table's height
* @param m The table's width
* @param t The table in which to perform the reduction
* @return A matrix of markings as described in the summary
*/
static Mark **
kuhn_mark(size_t n, size_t m, Cell **t)
{
size_t i, j;
Mark **marks;
Boolean *row_covered, *col_covered;
marks = malloc(n * sizeof(Mark *));
for (i = 0; i < n; i++)
marks[i] = calloc(m, sizeof(Mark)); /* UNMARKED == 0 */
row_covered = calloc(n, sizeof(Boolean));
col_covered = calloc(m, sizeof(Boolean));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (!row_covered[i] && !col_covered[j] && !t[i][j]) {
marks[i][j] = MARKED;
row_covered[i] = 1;
col_covered[j] = 1;
}
}
}
free(row_covered);
free(col_covered);
return marks;
}
/**
* Finds a prime
*
* @param n The table's height
* @param m The table's width
* @param t The table
* @param marks The marking matrix
* @param row_covered Row cover array
* @param col_covered Column cover array
* @param primep Output parameter for the row and column of the found prime
* @return 1 if a prime was found, 0 otherwise
*/
static Boolean
kuhn_find_prime(size_t n, size_t m, Cell **t, Mark **marks, Boolean row_covered[n], Boolean col_covered[m], CellPosition *primep)
{
size_t i, j, row, col;
ssize_t p;
Boolean mark_in_row;
BitSet *zeroes = bitset_create(n * m);
for (i = 0; i < n; i++)
if (!row_covered[i])
for (j = 0; j < m; j++)
if (!col_covered[j] && !t[i][j])
bitset_set(zeroes, i * m + j);
for (;;) {
p = bitset_any(zeroes);
if (p < 0) {
free(zeroes);
return 0;
}
row = (size_t)p / m;
col = (size_t)p % m;
marks[row][col] = PRIME;
mark_in_row = 0;
for (j = 0; j < m; j++) {
if (marks[row][j] == MARKED) {
mark_in_row = 1;
col = j;
}
}
if (mark_in_row) {
row_covered[row] = 1;
col_covered[col] = 0;
for (i = 0; i < n; i++) {
if (!t[i][col] && row != i) {
if (!row_covered[i] && !col_covered[col])
bitset_set(zeroes, i * m + col);
else
bitset_unset(zeroes, i * m + col);
}
}
for (j = 0; j < m; j++) {
if (!t[row][j] && col != j) {
if (!row_covered[row] && !col_covered[j])
bitset_set(zeroes, row * m + j);
else
bitset_unset(zeroes, row * m + j);
}
}
if (!row_covered[row] && !col_covered[col])
bitset_set(zeroes, row * m + col);
else
bitset_unset(zeroes, row * m + col);
} else {
free(zeroes);
primep->row = row;
primep->col = col;
return 1;
}
}
}
/**
* Removes all prime marks and modifies the marking
*
* @param n The table's height
* @param m The table's width
* @param marks The marking matrix
* @param alt Marking modification paths
* @param col_marks Markings in the columns
* @param row_primes Primes in the rows
* @param prime The last found prime
*/
static void
kuhn_alt_marks(size_t n, size_t m, Mark **marks, CellPosition alt[n * m],
ssize_t col_marks[m], ssize_t row_primes[n], const CellPosition *prime)
{
size_t i, j, index = 0;
ssize_t row, col;
Mark *markx, *marksi;
alt[0].row = prime->row;
alt[0].col = prime->col;
for (i = 0; i < n; i++)
row_primes[i] = -1;
for (i = 0; i < m; i++)
col_marks[i] = -1;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (marks[i][j] == MARKED)
col_marks[j] = (ssize_t)i;
else if (marks[i][j] == PRIME)
row_primes[i] = (ssize_t)j;
}
}
while ((row = col_marks[alt[index].col]) >= 0) {
index++;
alt[index].row = (size_t)row;
alt[index].col = alt[index - 1].col;
col = row_primes[alt[index].row];
index++;
alt[index].row = alt[index - 1].row;
alt[index].col = (size_t)col;
}
for (i = 0; i <= index; i++) {
markx = &marks[alt[i].row][alt[i].col];
*markx = *markx == MARKED ? UNMARKED : MARKED;
}
for (i = 0; i < n; i++) {
marksi = marks[i];
for (j = 0; j < m; j++)
if (marksi[j] == PRIME)
marksi[j] = UNMARKED;
}
}
/**
* Depending on whether the cells' rows and columns are covered,
* the the minimum value in the table is added, subtracted or
* neither from the cells.
*
* @param n The table's height
* @param m The table's width
* @param t The table to manipulate
* @param row_covered Array that tell whether the rows are covered
* @param col_covered Array that tell whether the columns are covered
*/
static void
kuhn_add_and_subtract(size_t n, size_t m, Cell **t, Boolean row_covered[n], Boolean col_covered[m])
{
size_t i, j;
Cell min = 0x7FFFFFFFL;
for (i = 0; i < n; i++)
if (!row_covered[i])
for (j = 0; j < m; j++)
if (!col_covered[j] && min > t[i][j])
min = t[i][j];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (row_covered[i])
t[i][j] += min;
if (!col_covered[j])
t[i][j] -= min;
}
}
}
/**
* Creates a list of the assignment cells
*
* @param n The table's height
* @param m The table's width
* @param marks Matrix markings
* @return The assignment, an array of row–coloumn pairs
*/
static CellPosition *
kuhn_assign(size_t n, size_t m, Mark **marks)
{
CellPosition *assignment = malloc(n * sizeof(CellPosition));
size_t i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (marks[i][j] == MARKED) {
assignment[i].row = i;
assignment[i].col = j;
}
}
}
return assignment;
}
/**
* Calculates an optimal bipartite minimum weight matching using an
* O(n³)-time implementation of The Hungarian Algorithm, also known
* as Kuhn's Algorithm.
*
* @param n The height of the table
* @param m The width of the table
* @param table The table in which to perform the matching
* @return The optimal assignment, an array of row–coloumn pairs
*/
static CellPosition *
kuhn_match(size_t n, size_t m, Cell **table)
{
size_t i;
ssize_t *row_primes, *col_marks;
Mark **marks;
Boolean *row_covered, *col_covered;
CellPosition *ret, prime, *alt;
/* Not copying table since it will only be used once. */
row_covered = calloc(n, sizeof(Boolean));
col_covered = calloc(m, sizeof(Boolean));
row_primes = malloc(n * sizeof(ssize_t));
col_marks = malloc(m * sizeof(ssize_t));
alt = malloc(n * m * sizeof(CellPosition));
kuhn_reduce_rows(n, m, table);
marks = kuhn_mark(n, m, table);
while (!kuhn_is_done(n, m, marks, col_covered)) {
while (!kuhn_find_prime(n, m, table, marks, row_covered, col_covered, &prime))
kuhn_add_and_subtract(n, m, table, row_covered, col_covered);
kuhn_alt_marks(n, m, marks, alt, col_marks, row_primes, &prime);
memset(row_covered, 0, n * sizeof(*row_covered));
memset(col_covered, 0, m * sizeof(*col_covered));
}
free(row_covered);
free(col_covered);
free(alt);
free(row_primes);
free(col_marks);
ret = kuhn_assign(n, m, marks);
for (i = 0; i < n; i++)
free(marks[i]);
free(marks);
return ret;
}
static void
print(size_t n, size_t m, Cell **t, CellPosition assignment[n])
{
size_t i, j, (*assigned)[n][m];
assigned = calloc(1, sizeof(ssize_t [n][m]));
if (assignment)
for (i = 0; i < n; i++)
(*assigned)[assignment[i].row][assignment[i].col] += 1;
for (i = 0; i < n; i++) {
printf(" ");
for (j = 0; j < m; j++) {
if ((*assigned)[i][j])
printf("\033[%im", (int)(30 + (*assigned)[i][j]));
printf("%5li%s\033[m ", (Cell)t[i][j], (*assigned)[i][j] ? "^" : " ");
}
printf("\n\n");
}
free(assigned);
}
int
main(int argc, char *argv[])
{
FILE *urandom;
unsigned int seed;
size_t i, j, n, m;
Cell **t, **table, x, sum = 0;
CellPosition *assignment;
urandom = fopen("/dev/urandom", "r");
fread(&seed, sizeof(unsigned int), 1, urandom);
srand(seed);
fclose(urandom);
n = argc < 3 ? 10 : (size_t)atol(argv[1]);
m = argc < 3 ? 15 : (size_t)atol(argv[2]);
t = malloc(n * sizeof(Cell *));
table = malloc(n * sizeof(Cell *));
if (argc < 3) {
for (i = 0; i < n; i++) {
t[i] = malloc(m * sizeof(Cell));
table[i] = malloc(m * sizeof(Cell));
for (j = 0; j < m; j++)
table[i][j] = t[i][j] = (Cell)(random() & 63);
}
} else {
for (i = 0; i < n; i++) {
t[i] = malloc(m * sizeof(Cell));
table[i] = malloc(m * sizeof(Cell));
for (j = 0; j < m; j++) {
scanf("%li", &x);
table[i][j] = t[i][j] = x;
}
}
}
printf("\nInput:\n\n");
print(n, m, t, NULL);
assignment = kuhn_match(n, m, table);
printf("\nOutput:\n\n");
print(n, m, t, assignment);
for (i = 0; i < n; i++) {
sum += t[assignment[i].row][assignment[i].col];
free(table[i]);
free(t[i]);
}
free(assignment);
free(table);
free(t);
printf("\n\nSum: %li\n\n", sum);
return 0;
}
