Src/Utility/U32Pair.hpp

• View this file on GitHub
• Last update: 2023-12-16 19:11:08+09:00
• Include: #include "Src/Utility/U32Pair.hpp"

Depends on

• 標準データ型のエイリアス (Src/Template/TypeAlias.hpp)

Required by

• Src/Graph/Flow/BurnBury.hpp
• Dinic (最大流・最小カット) (Src/Graph/Flow/Dinic.hpp)
• SuccessiveShortestPath (最小費用流、最短路反復法) (Src/Graph/Flow/SuccessiveShortestPath.hpp)

Verified with

• Test/AOJ/1163.test.cpp
• AOJ2828 マトリョーシカ (Test/AOJ/2828.test.cpp)
• AOJ2872 最短距離を伸ばすえびちゃん (Test/AOJ/2872.test.cpp)
• AOJ2943 イルミネーション (Test/AOJ/2943.test.cpp)
• Test/AOJ/3168.test.cpp
• Test/AOJ/GRL_6_A.test.cpp
• Test/AOJ/GRL_6_B.test.cpp
• Test/AOJ/GRL_7_A.test.cpp
• ABC193-F Zebraness (Test/AtCoder/abc193_f.test.cpp)
• ABC205-F Grid and Tokens (Test/AtCoder/abc205_f.test.cpp)
• ABC247-G Dream Team (Test/AtCoder/abc247_g.test.cpp)
• ABC263-G Erasing Prime Pairs (Test/AtCoder/abc263_g.test.cpp)
• ABC318-G Typical Path Problem (Test/AtCoder/abc318_g.test.cpp)
• Test/LC/bipartitematching.test.cpp
• Test/Manual/abc004_d.test.cpp
• ABC239-G Builder Takahashi (Test/Manual/abc239_g.test.cpp)
• ABC317-G Rearranging (Test/Manual/abc317_g.test.cpp)
• Kyoto University Programming Contest 2016-E 柵 (Test/Manual/kupc2016_e.test.cpp)
• AtCoder Library Practice Contest - D Maxflow (Test/Manual/practice2_d.test.cpp)
• AtCoder Library Practice Contest - E MinCostFlow (Test/Manual/practice2_e.test.cpp)
• 競プロ典型90問-040 Get More Money (Test/Manual/typical90_an.test.cpp)
• Test/Manual/typical90_by.test.cpp
• Test/My/Utility/U32Pair.test.cpp

Code

#pragma once

#include "../Template/TypeAlias.hpp"

#include <functional>
#include <iostream>

namespace zawa {

class U32Pair {
private:
    static constexpr u32 SHIFT{32};
    static constexpr u32 MASK{static_cast<u32>((1LL << SHIFT) - 1)};
    u64 value_{};
public:
    constexpr U32Pair() {}
    constexpr U32Pair(u32 first, u32 second) {
        value_ = (static_cast<u64>(first) << SHIFT) | second;
    }
    constexpr u32 first() const noexcept {
        return static_cast<u32>(value_ >> SHIFT);
    }
    constexpr u32 second() const noexcept {
        return static_cast<u32>(value_ & MASK);
    }
    constexpr u64 combined() const noexcept {
        return value_;
    }
    constexpr U32Pair& operator=(const U32Pair& rhs) {
        value_ = rhs.value_;
        return *this;
    }
    friend constexpr bool operator==(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ == rhs.value_;
    }
    friend constexpr bool operator!=(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ != rhs.value_;
    }
    friend constexpr bool operator<(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ < rhs.value_;
    }
    friend constexpr bool operator<=(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ <= rhs.value_;
    }
    friend constexpr bool operator>(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ > rhs.value_;
    }
    friend constexpr bool operator>=(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ >= rhs.value_;
    }
    friend std::ostream& operator<<(std::ostream& os, const U32Pair& pair) {
        os << '(' << pair.first() << ',' << pair.second() << ')';
        return os;
    }
};

struct U32PairHash {
    usize operator()(const U32Pair& pair) const noexcept {
        return std::hash<u64>{}(pair.combined());
    }
};

} // namespace zawa

#line 2 "Src/Utility/U32Pair.hpp"

#line 2 "Src/Template/TypeAlias.hpp"

#include <cstdint>
#include <cstddef>

namespace zawa {

using i16 = std::int16_t;
using i32 = std::int32_t;
using i64 = std::int64_t;
using i128 = __int128_t;

using u8 = std::uint8_t;
using u16 = std::uint16_t;
using u32 = std::uint32_t;
using u64 = std::uint64_t;

using usize = std::size_t;

} // namespace zawa
#line 4 "Src/Utility/U32Pair.hpp"

#include <functional>
#include <iostream>

namespace zawa {

class U32Pair {
private:
    static constexpr u32 SHIFT{32};
    static constexpr u32 MASK{static_cast<u32>((1LL << SHIFT) - 1)};
    u64 value_{};
public:
    constexpr U32Pair() {}
    constexpr U32Pair(u32 first, u32 second) {
        value_ = (static_cast<u64>(first) << SHIFT) | second;
    }
    constexpr u32 first() const noexcept {
        return static_cast<u32>(value_ >> SHIFT);
    }
    constexpr u32 second() const noexcept {
        return static_cast<u32>(value_ & MASK);
    }
    constexpr u64 combined() const noexcept {
        return value_;
    }
    constexpr U32Pair& operator=(const U32Pair& rhs) {
        value_ = rhs.value_;
        return *this;
    }
    friend constexpr bool operator==(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ == rhs.value_;
    }
    friend constexpr bool operator!=(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ != rhs.value_;
    }
    friend constexpr bool operator<(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ < rhs.value_;
    }
    friend constexpr bool operator<=(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ <= rhs.value_;
    }
    friend constexpr bool operator>(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ > rhs.value_;
    }
    friend constexpr bool operator>=(const U32Pair& lhs, const U32Pair& rhs) {
        return lhs.value_ >= rhs.value_;
    }
    friend std::ostream& operator<<(std::ostream& os, const U32Pair& pair) {
        os << '(' << pair.first() << ',' << pair.second() << ')';
        return os;
    }
};

struct U32PairHash {
    usize operator()(const U32Pair& pair) const noexcept {
        return std::hash<u64>{}(pair.combined());
    }
};

} // namespace zawa

Back to top page