dl_range_select.h

浏览该文件的文档.

#pragma once
 
#include <limits>
#include <vector>
#include <numeric>
#include <type_traits>

namespace dl::Select
{
template<typename C>
constexpr auto Max(const C& container)
{
    using V = std::decay_t<decltype(container)>;
    using T = typename V::value_type;
    T ret = std::numeric_limits<T>::lowest();
    for (auto& iter : container)
    {
        ret = (std::max)(ret, iter);
    }
    return ret;
}

template<typename C>
constexpr auto Min(const C& container)
{
    using V = std::decay_t<decltype(container)>;
    using T = typename V::value_type;
    T ret = (std::numeric_limits<T>::max)();
    for (auto& iter : container)
    {
        ret = (std::min)(ret, iter);
    }
    return ret;
}
 

template<typename C, typename F>
constexpr auto Max(const C& container, F func)
{
    using V = std::decay_t<decltype(container)>;
    using T = typename V::value_type;
    using T1 = decltype(func(T{}));
    T1 ret = (std::numeric_limits<T1>::min)();
    for (auto& iter : container)
    {
        ret = (std::max)(ret, func(iter));
    }
    return ret;
}

template<typename C, typename F>
constexpr auto Min(const C& container, F func)
{
    using V = std::decay_t<decltype(container)>;
    using T = typename V::value_type;
    using T1 = decltype(func(T{}));
    T1 ret = (std::numeric_limits<T1>::max)();
    for (auto& iter : container)
    {
        ret = (std::min)(ret, func(iter));
    }
    return ret;
}
 

template<typename C, typename F>
constexpr auto& MaxRef(C& container, F func)
{
    using V = std::decay_t<decltype(container)>;
    using T = typename V::value_type;
    using T_RET = std::invoke_result_t<F, T&>;
    T_RET v_max = (std::numeric_limits<T_RET>::min)();
    T& ret = *container.begin();
    for (auto& iter : container)
    {
        T_RET v = func(iter);
        if (v > v_max)
        {
            v_max = v;
            ret = iter;
        }
    }
    return ret;
}

template<typename C, typename F>
constexpr auto& MinRef(C& container, F func)
{
    using V = std::decay_t<decltype(container)>;
    using T = typename V::value_type;
    using T_RET = std::invoke_result_t<F, T&>;
    T_RET v_min = (std::numeric_limits<T_RET>::max)();
    T& ret = *container.begin();
    for (auto& iter : container)
    {
        T_RET v = func(iter);
        if (v < v_min)
        {
            v_min = v;
            ret = iter;
        }
    }
    return ret;
}
 

template<typename T>
T& CreateIfEmpty(std::vector<T>& vec, std::size_t n)
{
    if (n >= vec.size())
        vec.resize(n + 1);
    return vec[n];
}

template<typename T>
T* CreateIfEmpty(std::vector<T>* vec, std::size_t n)
{
    if (n >= vec->size())
        vec->resize(n + 1);
    return &(*vec)[n];
}

template<typename T>
T& CreateIfEmpty(std::vector<std::vector<T>>& vec, std::size_t n0, std::size_t n1)
{
    if (n0 >= vec.size())
        vec.resize(n0 + 1);
    return CreateIfEmpty(vec[n0], n1);
}
}