void
PathSum<_Ty, _Compare, _TreeNode>::getPathsOfSumUp(PNode<_Ty> root,
std::vector<_Ty> prev,
_Ty prev_sum,
_Ty const &sum,
std::vector<std::vector<_Ty>> &res)
{
if (root != nullptr)
{
auto &curr = prev;
curr.push_back(root->value());
auto &curr_sum = prev_sum;
curr_sum += root->value();
if (path_type_ == PathType::Whole)
{
if (root->left() == nullptr
&& root->right() == nullptr
&& compare_(curr_sum, sum))
res.push_back(curr);
}
else // path_type_ == PathType::Part
if (compare_(curr_sum, sum))
res.push_back(curr);
getPathsOfSumUp(root->left(), curr, curr_sum, sum, res);
getPathsOfSumUp(root->right(), curr, curr_sum, sum, res);
}
}
VertexId PopMin() {
if (empty())
throw NoSuchVertexException();
--size_;
std::size_t n_min = 1;
while ((n_min <<= 1) < offset_)
n_min |= compare_(d_min_[n_min | 1], d_min_[n_min]);
n_min -= offset_;
// make n_min be minimum unpopped among n and (n + 1)
// and n_sib the other one
std::size_t n_sib = n_min | 1;
n_min ^= (popped_[n_min] || (n_sib < d_.size() && !popped_[n_sib] &&
compare_(d_[n_sib], d_[n_min])));
n_sib = n_min ^ 1;
T d_min = d_[n_min];
T d_sib = (n_sib < d_.size() && !popped_[n_sib] ? d_[n_sib] : d_max_);
// update the tree by replacing the necessary nodes with 2nd min
if (compare_(d_min, d_sib)) {
T d_min2 = d_sib;
for (std::size_t n = n_min + offset_; ;) {
d_min_[n >>= 1] = d_min2;
if (n == 1 || !compare_(d_min, d_sib = d_min_[n ^ 1]))
break;
if (compare_(d_sib, d_min2))
d_min2 = d_sib;
}
}
popped_[n_min] = true;
return n_min;
}
void discover_vertex(vertex_t u, graph_t const& g)
{
if(//g[u].nd == node_)
compare_(g[u]))
{
is_connected_ = true;
}
}
inline
bool
compare_(
S1 const& s1
, S2 const& s2
)
{
return compare_(c_str_data(s1), c_str_len(s1), c_str_data(s2), c_str_len(s2));
}
void Update(VertexId n) {
const T& d_n = d_[n];
std::size_t n_sib = n ^ 1;
T d_sib = (n_sib < d_.size() && !popped_[n_sib] ? d_[n_sib] : d_max_);
if (compare_(d_n, d_sib))
for (std::size_t i = (n + offset_)>>1; compare_(d_n, d_min_[i]); i >>= 1)
d_min_[i] = d_n;
}
inline
bool
compare_and_assign_(
S1 const& input
, V const& v
, S2& output
)
{
if(compare_(c_str_data(input), c_str_len(input), c_str_data(v.first), c_str_len(v.first)))
{
S2(c_str_data(v.second), c_str_len(v.second)).swap(output);
return true;
}
return false;
}
bool compare(const key_interface* p) const override
{
auto rhs = dynamic_cast<const key*>(p);
return rhs && compare_(key_object_, rhs->key_object_);
}
int equal_lispvalue(value_t a, value_t b)
{
if (eq_comparable(a, b))
return (a==b);
return (numval(compare_(a,b,1))==0);
}
value_t fl_equal(value_t a, value_t b)
{
if (eq_comparable(a, b))
return (a == b) ? FL_T : FL_F;
return (numval(compare_(a,b,1))==0 ? FL_T : FL_F);
}
value_t fl_compare(value_t a, value_t b)
{
return compare_(a, b, 0);
}
bool operator() (T const & x1, T const & x2)
{
return x1.index < x2.index;
}
};
void serialize(std::wostream & _Wostream)
{
std::vector<xlsx_border> inst_array;
BOOST_FOREACH(const xlsx_border & inst, borders_)
{
inst_array.push_back(inst);
}
std::sort(inst_array.begin(), inst_array.end(), compare_());
CP_XML_WRITER(_Wostream)
{
CP_XML_NODE(L"borders")
{
CP_XML_ATTR(L"count", inst_array.size());
BOOST_FOREACH( xlsx_border & border, inst_array)
{
cpdoccore::oox::xlsx_serialize(CP_XML_STREAM(), border);
}
}
}
}
private:
