28 const ArcIndex num_arcs = arc_cost_.size();

29 num_nodes_ = std::max(num_nodes_, left_node + 1);

30 num_nodes_ = std::max(num_nodes_, right_node + 1);

31 arc_tail_.push_back(left_node);

32 arc_head_.push_back(right_node);

33 arc_cost_.push_back(cost);

34 return num_arcs;

35}

38 const {

39 return num_nodes_;

40}

43 return arc_cost_.size();

44}

48 return arc_tail_[arc];

49}

53 return arc_head_[arc];

54}

58 return arc_cost_[arc];

59}

62 optimal_cost_ = 0;

63 assignment_arcs_.clear();

65

66

67

68 const CostValue max_supported_arc_cost =

69 std::numeric_limits<CostValue>::max() / (NumNodes() + 1);

70 for (const CostValue unscaled_arc_cost : arc_cost_) {

71 if (unscaled_arc_cost > max_supported_arc_cost) return POSSIBLE_OVERFLOW;

72 }

73

74 const ArcIndex num_arcs = arc_cost_.size();

77 num_nodes_);

78 for (ArcIndex arc = 0; arc < num_arcs; ++arc) {

79 graph.AddArc(arc_tail_[arc], num_nodes_ + arc_head_[arc]);

80 assignment.SetArcCost(arc, arc_cost_[arc]);

81 }

82

83

86 optimal_cost_ = assignment.GetCost();

87 for (NodeIndex node = 0; node < num_nodes_; ++node) {

88 assignment_arcs_.push_back(assignment.GetAssignmentArc(node));

89 }

91}

void SetArcCost(ArcIndex arc, CostValue cost)

ArcIndex GetAssignmentArc(NodeIndex left_node) const

CostValue GetCost() const

ArcIndex NumArcs() const

Definition assignment.cc:42

SimpleLinearSumAssignment()

Definition assignment.cc:24

NodeIndex NumNodes() const

Definition assignment.cc:37

Status Solve()

Definition assignment.cc:61

NodeIndex RightNode(ArcIndex arc) const

Definition assignment.cc:51

ArcIndex AddArcWithCost(NodeIndex left_node, NodeIndex right_node, CostValue cost)

Definition assignment.cc:26

CostValue Cost(ArcIndex arc) const

Definition assignment.cc:56

NodeIndex LeftNode(ArcIndex arc) const

Definition assignment.cc:46

ArcIndexType AddArc(NodeIndexType tail, NodeIndexType head)