docs: def min_cost_flow(self, display = None, **args):
          '''
          API:
              min_cost_flow(self, display='off', **args)
          Description:
              Solves minimum cost flow problem using node/edge attributes with
              the algorithm specified.
          Pre:
              (1) Assumes a directed graph in which each arc has 'capacity' and
              'cost' attributes.
              (2) Nodes should have 'demand' attribute. This value should be
              positive for supply and negative for demand, and 0 for transhipment
              nodes.
              (3) The graph should be connected.
              (4) Assumes (i,j) and (j,i) does not exist together. Needed when
              solving max flow. (max flow problem is solved to get a feasible
              flow).
          Input:
              display: 'off' for no display, 'pygame' for live update of tree
              args: may have the following
                  display: display method, if not given current mode (the one
                      specified by __init__ or set_display) will be used.
                  algo: determines algorithm to use, can be one of the following
                      'simplex': network simplex algorithm
                      'cycle_canceling': cycle canceling algorithm
                      'simplex' is used if not given.
                      see Network Flows by Ahuja et al. for details of algorithms.
                  pivot: valid if algo is 'simlex', determines pivoting rule for
                      simplex, may be one of the following; 'first_eligible',
                      'dantzig' or 'scaled'.
                      'dantzig' is used if not given.
                      see Network Flows by Ahuja et al. for pivot rules.
                  root: valid if algo is 'simlex', specifies the root node for
                      simplex algorithm. It is name of the one of the nodes. It
                      will be chosen randomly if not provided.
          Post:
              The 'flow' attribute of each arc gives the optimal flows.
              'distance' attribute of the nodes are also changed during max flow
              solution process.
          Examples:
              g.min_cost_flow():
                  solves minimum cost feasible flow problem using simplex
                  algorithm with dantzig pivoting rule.
                  See pre section for details.
              g.min_cost_flow(algo='cycle_canceling'):
                  solves minimum cost feasible flow problem using cycle canceling
                  agorithm.
              g.min_cost_flow(algo='simplex', pivot='scaled'):
                  solves minimum cost feasible flow problem using network simplex
                  agorithm with scaled pivot rule.
          '''
          if display is None:
              display = self.attr['display']
          if 'algo' in args:
              algorithm = args['algo']
          else:
              algorithm = 'simplex'
          if algorithm is 'simplex':
              if 'root' in args:
                  root = args['root']
              else:
                  for k in self.neighbors:
                      root = k
                      break
              if 'pivot' in args:
                  if not self.network_simplex(display, args['pivot'], root):
                      print('problem is infeasible')
              else:
                  if not self.network_simplex(display, 'dantzig', root):
                      print('problem is infeasible')
          elif algorithm is 'cycle_canceling':
              if not self.cycle_canceling(display):
                  print('problem is infeasible')
          else:
              print(args['algo'], 'is not a defined algorithm. Exiting.')
              return