## Munkres/Hungarian algorithm/Kuhn-Munkres algorithm

This is the place for queries that don't fit in any of the other categories.

### Munkres/Hungarian algorithm/Kuhn-Munkres algorithm

I downloaded this code online to solve the assignment problem. However, this code seems to work for list with non zero values only. Can someone help me execute it for list with values = 0? I'm new to python and dont know python classes that well. Please help!
Code: Select all
`# ---------------------------------------------------------------------------# Imports# ---------------------------------------------------------------------------import sys# ---------------------------------------------------------------------------# Exports# ---------------------------------------------------------------------------__all__     = ['Munkres', 'make_cost_matrix']# ---------------------------------------------------------------------------# Globals# ---------------------------------------------------------------------------# Info about the module__version__   = "1.0.5.4"__author__    = "Brian Clapper, bmc@clapper.org"__url__       = "http://bmc.github.com/munkres/"__copyright__ = "(c) 2008 Brian M. Clapper"__license__   = "BSD-style license"# ---------------------------------------------------------------------------# Classes# ---------------------------------------------------------------------------class Munkres:    """    Calculate the Munkres solution to the classical assignment problem.    See the module documentation for usage.    """    def __init__(self):        """Create a new instance"""        self.C = None        self.row_covered = []        self.col_covered = []        self.n = 0        self.Z0_r = 0        self.Z0_c = 0        self.marked = None        self.path = None    def make_cost_matrix(profit_matrix, inversion_function):        """        **DEPRECATED**        Please use the module function ``make_cost_matrix()``.        """        import munkres        return munkres.make_cost_matrix(profit_matrix, inversion_function)    make_cost_matrix = staticmethod(make_cost_matrix)    def pad_matrix(self, matrix, pad_value=0):        """        Pad a possibly non-square matrix to make it square.        :Parameters:            matrix : list of lists                matrix to pad            pad_value : int                value to use to pad the matrix        :rtype: list of lists        :return: a new, possibly padded, matrix        """        max_columns = 0        total_rows = len(matrix)        for row in matrix:            max_columns = max(max_columns, len(row))        total_rows = max(max_columns, total_rows)        new_matrix = []        for row in matrix:            row_len = len(row)            new_row = row[:]            if total_rows > row_len:                # Row too short. Pad it.                new_row += [0] * (total_rows - row_len)            new_matrix += [new_row]        while len(new_matrix) < total_rows:            new_matrix += [[0] * total_rows]        return new_matrix    def compute(self, cost_matrix):        """        Compute the indexes for the lowest-cost pairings between rows and        columns in the database. Returns a list of (row, column) tuples        that can be used to traverse the matrix.        :Parameters:            cost_matrix : list of lists                The cost matrix. If this cost matrix is not square, it                will be padded with zeros, via a call to ``pad_matrix()``.                (This method does *not* modify the caller's matrix. It                operates on a copy of the matrix.)                **WARNING**: This code handles square and rectangular                matrices. It does *not* handle irregular matrices.        :rtype: list        :return: A list of ``(row, column)`` tuples that describe the lowest                 cost path through the matrix        """        self.C = self.pad_matrix(cost_matrix)        #self.C=self.__find_a_zero        self.n = len(self.C)        self.original_length = len(cost_matrix)        self.original_width = len(cost_matrix[0])        self.row_covered = [False for i in range(self.n)]        self.col_covered = [False for i in range(self.n)]        self.Z0_r = 0        self.Z0_c = 0        self.path = self.__make_matrix(self.n * 2, 0)        self.marked = self.__make_matrix(self.n, 0)        done = False        step = 1        steps = { 1 : self.__step1,                  2 : self.__step2,                  3 : self.__step3,                  4 : self.__step4,                  5 : self.__step5,                  6 : self.__step6 }        while not done:            try:                func = steps[step]                step = func()            except KeyError:                done = True        # Look for the starred columns        results = []        for i in range(self.original_length):            for j in range(self.original_width):                if self.marked[i][j] == 1:                    results += [(i, j)]        return results    def __copy_matrix(self, matrix):        """Return an exact copy of the supplied matrix"""        return copy.deepcopy(matrix)    def __make_matrix(self, n, val):        """Create an *n*x*n* matrix, populating it with the specific value."""        matrix = []        for i in range(n):            matrix += [[val for j in range(n)]]        return matrix    def __step1(self):        """        For each row of the matrix, find the smallest element and        subtract it from every element in its row. Go to Step 2.        """        C = self.C        n = self.n        for i in range(n):            minval = min(self.C[i])            # Find the minimum value for this row and subtract that minimum            # from every element in the row.            for j in range(n):                self.C[i][j] -= minval        return 2    def __step2(self):        """        Find a zero (Z) in the resulting matrix. If there is no starred        zero in its row or column, star Z. Repeat for each element in the        matrix. Go to Step 3.        """        n = self.n        for i in range(n):            for j in range(n):                if (self.C[i][j] == 0) and \                   (not self.col_covered[j]) and \                   (not self.row_covered[i]):                    self.marked[i][j] = 1                    self.col_covered[j] = True                    self.row_covered[i] = True        self.__clear_covers()        return 3    def __step3(self):        """        Cover each column containing a starred zero. If K columns are        covered, the starred zeros describe a complete set of unique        assignments. In this case, Go to DONE, otherwise, Go to Step 4.        """        n = self.n        count = 0        for i in range(n):            for j in range(n):                if self.marked[i][j] == 1:                    self.col_covered[j] = True                    count += 1        if count >= n:            step = 7 # done        else:            step = 4        return step    def __step4(self):        """        Find a noncovered zero and prime it. If there is no starred zero        in the row containing this primed zero, Go to Step 5. Otherwise,        cover this row and uncover the column containing the starred        zero. Continue in this manner until there are no uncovered zeros        left. Save the smallest uncovered value and Go to Step 6.        """        step = 0        done = False        row = -1        col = -1        star_col = -1        while not done:            (row, col) = self.__find_a_zero()            if row < 0:                done = True                step = 6            else:                self.marked[row][col] = 2                star_col = self.__find_star_in_row(row)                if star_col >= 0:                    col = star_col                    self.row_covered[row] = True                    self.col_covered[col] = False                else:                    done = True                    self.Z0_r = row                    self.Z0_c = col                    step = 5        return step    def __step5(self):        """        Construct a series of alternating primed and starred zeros as        follows. Let Z0 represent the uncovered primed zero found in Step 4.        Let Z1 denote the starred zero in the column of Z0 (if any).        Let Z2 denote the primed zero in the row of Z1 (there will always        be one). Continue until the series terminates at a primed zero        that has no starred zero in its column. Unstar each starred zero        of the series, star each primed zero of the series, erase all        primes and uncover every line in the matrix. Return to Step 3        """        count = 0        path = self.path        path[count][0] = self.Z0_r        path[count][1] = self.Z0_c        done = False        while not done:            row = self.__find_star_in_col(path[count][1])            if row >= 0:                count += 1                path[count][0] = row                path[count][1] = path[count-1][1]            else:                done = True            if not done:                col = self.__find_prime_in_row(path[count][0])                count += 1                path[count][0] = path[count-1][0]                path[count][1] = col        self.__convert_path(path, count)        self.__clear_covers()        self.__erase_primes()        return 3    def __step6(self):        """        Add the value found in Step 4 to every element of each covered        row, and subtract it from every element of each uncovered column.        Return to Step 4 without altering any stars, primes, or covered        lines.        """        minval = self.__find_smallest()        for i in range(self.n):            for j in range(self.n):                if self.row_covered[i]:                    self.C[i][j] += minval                if not self.col_covered[j]:                    self.C[i][j] -= minval        return 4    def __find_smallest(self):        """Find the smallest uncovered value in the matrix."""        minval = sys.maxint        for i in range(self.n):            for j in range(self.n):                if (not self.row_covered[i]) and (not self.col_covered[j]):                    if minval > self.C[i][j]:                        minval = self.C[i][j]        return minval    def __find_a_zero(self):        """Find the first uncovered element with value 0"""        row = -1        col = -1        i = 0        n = self.n        done = False        while not done:            j = 0            while True:                if (self.C[i][j] == 0) and \                   (not self.row_covered[i]) and \                   (not self.col_covered[j]):                    row = i                    col = j                    done = True                j += 1                if j >= n:                    break            i += 1            if i >= n:                done = True        return (row, col)    def __find_star_in_row(self, row):        """        Find the first starred element in the specified row. Returns        the column index, or -1 if no starred element was found.        """        col = -1        for j in range(self.n):            if self.marked[row][j] == 1:                col = j                break        return col    def __find_star_in_col(self, col):        """        Find the first starred element in the specified row. Returns        the row index, or -1 if no starred element was found.        """        row = -1        for i in range(self.n):            if self.marked[i][col] == 1:                row = i                break        return row    def __find_prime_in_row(self, row):        """        Find the first prime element in the specified row. Returns        the column index, or -1 if no starred element was found.        """        col = -1        for j in range(self.n):            if self.marked[row][j] == 2:                col = j                break        return col    def __convert_path(self, path, count):        for i in range(count+1):            if self.marked[path[i][0]][path[i][1]] == 1:                self.marked[path[i][0]][path[i][1]] = 0            else:                self.marked[path[i][0]][path[i][1]] = 1    def __clear_covers(self):        """Clear all covered matrix cells"""        for i in range(self.n):            self.row_covered[i] = False            self.col_covered[i] = False    def __erase_primes(self):        """Erase all prime markings"""        for i in range(self.n):            for j in range(self.n):                if self.marked[i][j] == 2:                    self.marked[i][j] = 0# ---------------------------------------------------------------------------# Functions# ---------------------------------------------------------------------------def make_cost_matrix(profit_matrix, inversion_function):    """    Create a cost matrix from a profit matrix by calling    'inversion_function' to invert each value. The inversion    function must take one numeric argument (of any type) and return    another numeric argument which is presumed to be the cost inverse    of the original profit.    This is a static method. Call it like this:    .. python::        cost_matrix = Munkres.make_cost_matrix(matrix, inversion_func)    For example:    .. python::        cost_matrix = Munkres.make_cost_matrix(matrix, lambda x : sys.maxint - x)    :Parameters:        profit_matrix : list of lists            The matrix to convert from a profit to a cost matrix        inversion_function : function            The function to use to invert each entry in the profit matrix    :rtype: list of lists    :return: The converted matrix    """    cost_matrix = []    for row in profit_matrix:        cost_matrix.append([inversion_function(value) for value in row])    return cost_matrixdef print_matrix(matrix, msg=None):    """    Convenience function: Displays the contents of a matrix of integers.    :Parameters:        matrix : list of lists            Matrix to print        msg : str            Optional message to print before displaying the matrix    """    import math    if msg is not None:        print msg    # Calculate the appropriate format width.    width = 0    for row in matrix:        for val in row:                width = max(width, int(math.log10(val)) + 1)    # Make the format string    format = '%%%dd' % width    # Print the matrix    for row in matrix:        sep = '['        for val in row:            sys.stdout.write(sep + format % val)            sep = ', '        sys.stdout.write(']\n')# ---------------------------------------------------------------------------# Main# ---------------------------------------------------------------------------if __name__ == '__main__':    matrices = [                # Square                ([[400, 150, 400],                  [400, 450, 600],                  [300, 225, 300]],                 850 # expected cost                ),                # Rectangular variant                ([[400, 150, 400, 1],                  [400, 450, 600, 2],                  [300, 225, 300, 3]],                 452 # expected cost                ),                # Square                ([[10, 10,  8],                  [ 9,  8,  1],                  [ 9,  7,  4]],                 18                ),                # Rectangular variant                ([[10, 10,  8, 11],                  [ 9,  8,  1, 1],                  [ 9,  7,  4, 10]],                 15                ),               ]    m = Munkres()    for cost_matrix, expected_total in matrices:        #find_a_zero(matrix)        print_matrix(cost_matrix, msg='cost matrix')        indexes = m.compute(cost_matrix)        total_cost = 0        for r, c in indexes:            x = cost_matrix[r][c]            total_cost += x            print '(%d, %d) -> %d' % (r, c, x)        print 'lowest cost=%d' % total_cost        assert expected_total == total_cost`
Last edited by micseydel on Sat Feb 23, 2013 6:07 am, edited 2 times in total.
Reason: Locked to prevent editing because it looks like homework (so don't quote it).
yamini16

Posts: 2
Joined: Sat Feb 23, 2013 5:00 am

### Re: Munkres/Hungarian algorithm/Kuhn-Munkres algorithm

• This looks like homework: post your assignment
• What is what you've posted? Did you get it from somewhere? Where? (Cite it.)
• We're happy to help with homework, but we aren't going to help you cheat, and if you just got this somewhere and want us to modify it for you then that doesn't sound very honest. Keep that in mind in future posts. (Also that moderators can see your IP address and infer your school.)
Join the #python-forum IRC channel on irc.freenode.net for off-topic chat!

Please prefer not to PM members. The point of the forum is so that anyone can benefit. We don't want to help you over PMs/emails/Skype chats that others can't benefit from

micseydel

Posts: 2038
Joined: Tue Feb 12, 2013 2:18 am
Location: Mountain View, CA

### Re: Munkres/Hungarian algorithm/Kuhn-Munkres algorithm

1. Its not my homework.
2. Its the closest I could get to include a script in my research since I am new to Python.
3. If I were to cheat, I would have pasted the entire code without paying credits to the source which I havent.

So, if you're okay with all this and know how to solve my problem, let me know.

Check out the site:
http://software.clapper.org/munkres/
yamini16

Posts: 2
Joined: Sat Feb 23, 2013 5:00 am