結果

問題 No.11 カードマッチ
ユーザー plasma_eplasma_e
提出日時 2017-02-06 23:43:28
言語 C++14
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 3 ms / 5,000 ms
コード長 13,388 bytes
コンパイル時間 987 ms
コンパイル使用メモリ 103,636 KB
実行使用メモリ 5,248 KB
最終ジャッジ日時 2024-12-24 08:43:16
合計ジャッジ時間 1,749 ms
ジャッジサーバーID
(参考情報)
judge3 / judge1
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
other AC * 19
権限があれば一括ダウンロードができます
コンパイルメッセージ
main.cpp:78:101: warning: friend declaration 'constexpr decltype(auto) utility::operator+(const addable<T>&, const addable<T>&)' declares a non-template function [-Wnon-template-friend]
   78 |                 friend constexpr decltype(auto) operator+(addable<T>const& lhs, addable<T>const& rhs);
      |                                                                                                     ^
main.cpp:78:101: note: (if this is not what you intended, make sure the function template has already been declared and add '<>' after the function name here)
main.cpp:87:111: warning: friend declaration 'constexpr decltype(auto) utility::operator-(const subtractable<T>&, const subtractable<T>&)' declares a non-template function [-Wnon-template-friend]
   87 |                 friend constexpr decltype(auto) operator-(subtractable<T>const& lhs, subtractable<T>const& rhs);
      |                                                                                                               ^
main.cpp:95:111: warning: friend declaration 'constexpr decltype(auto) utility::operator*(const multipliable<T>&, const multipliable<T>&)' declares a non-template function [-Wnon-template-friend]
   95 |                 friend constexpr decltype(auto) operator*(multipliable<T>const& lhs, multipliable<T>const& rhs);
      |                                                                                                               ^
main.cpp:103:105: warning: friend declaration 'constexpr decltype(auto) utility::operator/(const dividable<T>&, const dividable<T>&)' declares a non-template function [-Wnon-template-friend]
  103 |                 friend constexpr decltype(auto) operator/(dividable<T>const& lhs, dividable<T>const& rhs);
      |                                                                                                         ^

ソースコード

diff #
プレゼンテーションモードにする

#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
#include<queue>
#include<functional>
#include<numeric>
#include<limits>
#include<map>
#include<bitset>
#include<array>
#include<random>
namespace utility
{
template<class T>struct addable;
template<class T>struct subtractable;
template<class T>struct multipliable;
template<class T>struct dividable;
template<class T,class U>constexpr decltype(auto) operator+(T const& lhs, U const& rhs)
{
auto x = lhs;
x += rhs;
return x;
}
template<class T, class U>constexpr decltype(auto) operator-(T const& lhs, U const& rhs)
{
auto x = lhs;
x -= rhs;
return x;
}
template<class T, class U>constexpr decltype(auto) operator*(T const& lhs, U const& rhs)
{
auto x = lhs;
x *= rhs;
return x;
}
template<class T, class U>constexpr decltype(auto) operator/(T const& lhs, U const& rhs)
{
auto x = lhs;
x /= rhs;
return x;
}
template<class T>struct equality_comparable
{
constexpr decltype(auto) operator!=(equality_comparable<T>const& rhs)const
{
return !(static_cast<T const&>(*this) == static_cast<T const&>(rhs));
}
};
template<class T>struct less_than_comparable
{
constexpr decltype(auto)operator<(equality_comparable<T>const& rhs)const
{
return static_cast<T const&>(*this) < static_cast<T const&>(rhs);
}
constexpr decltype(auto)operator>(T const& rhs)const
{
return rhs < *this;
}
constexpr decltype(auto)operator<=(T const& rhs)const
{
return !(rhs < *this);
}
constexpr decltype(auto)operator>=(T const& rhs)const
{
return !(*this < rhs);
}
};
template<class T>struct addable
{
constexpr decltype(auto) operator+=(addable<T>const& rhs)
{
return static_cast<T const&>(*this) += static_cast<T const&>(rhs);
}
friend constexpr decltype(auto) operator+(addable<T>const& lhs, addable<T>const& rhs);
};
template<class T>struct subtractable
{
constexpr decltype(auto) operator-=(subtractable<T>const& rhs)
{
return static_cast<T const&>(*this) -= static_cast<T const&>(rhs);
}
friend constexpr decltype(auto) operator-(subtractable<T>const& lhs, subtractable<T>const& rhs);
};
template<class T>struct multipliable
{
constexpr decltype(auto) operator*=(multipliable<T>const& rhs)
{
return static_cast<T const&>(*this) *= static_cast<T const&>(rhs);
}
friend constexpr decltype(auto) operator*(multipliable<T>const& lhs, multipliable<T>const& rhs);
};
template<class T>struct dividable
{
constexpr decltype(auto) operator/=(dividable<T>const& rhs)
{
return static_cast<T const&>(*this) /= static_cast<T const&>(rhs);
}
friend constexpr decltype(auto) operator/(dividable<T>const& lhs, dividable<T>const& rhs);
};
struct nullopt_t
{
};
constexpr nullopt_t nullopt{};
template<class T>class optional:private equality_comparable<optional<T>>
{
union
{
T val;
nullopt_t null;
};
bool flag;
public:
constexpr optional(nullopt_t n = nullopt) : null(), flag(false)
{
}
constexpr T& operator*()
{
if (flag)
{
return val;
}
throw std::invalid_argument("this optional value has not any value");
}
constexpr T const& operator*()const
{
if (flag)
{
return val;
}
throw std::invalid_argument("this optional value has not any value");
}
constexpr void reset()
{
null = nullopt;
flag = false;
}
constexpr operator bool()const
{
return flag;
}
template<class... Us>void emplace(Us&&... args)
{
val = T(std::forward<Us>(args)...);
flag = true;
}
constexpr auto& operator=(T const& v)
{
val = v;
flag = true;
return *this;
}
constexpr auto& operator=(T&& v)
{
val = v;
flag = true;
return *this;
}
constexpr auto& operator=(nullopt_t)
{
null = nullopt;
flag = false;
return *this;
}
constexpr optional(T const& v) :optional()
{
*this = v;
}
constexpr optional(T&& v) : optional()
{
*this = std::move(v);
}
constexpr bool operator==(optional const& rhs)const
{
return flag&&rhs.flag ? val == rhs.val : flag == rhs.flag;
}
optional(optional const&) = default;
optional(optional&&) = default;
optional& operator=(optional const&) = default;
optional& operator=(optional&&) = default;
~optional() = default;
};
}
namespace math
{
template<class T>constexpr T pow(T val, std::uint64_t p)
{
return p == 0 ? T(1) :
p == 1 ? val :
p == 2 ? val*val :
p % 2 == 0 ? pow(pow(val, p / 2), 2) :
pow(pow(val, p / 2), 2)*val;
}
template<class T,class U>constexpr int ilog(T val, U base)
{
T v(1);
for (int i{};;++i)
{
if (val <= v)
{
return i;
}
v *= base;
}
}
template<std::uint64_t Mod>class mod_number:
private utility::equality_comparable<mod_number<Mod>>,
private utility::addable<mod_number<Mod>>,
private utility::subtractable<mod_number<Mod>>,
private utility::multipliable<mod_number<Mod>>,
private utility::dividable<mod_number<Mod>>
{
std::uint64_t value;
public:
mod_number(std::uint64_t v = 0) :value(v%Mod)
{
}
mod_number(int v) :value(v%Mod)
{
}
mod_number(std::int64_t v) :value(v%Mod)
{
}
mod_number(std::uint32_t v) :value(v%Mod)
{
}
bool operator==(mod_number const& rhs)
{
return value == rhs.value;
}
auto& operator+=(mod_number const& rhs)
{
value += rhs.value;
value %= Mod;
return *this;
}
auto& operator-=(mod_number const& rhs)
{
value += Mod - rhs.value;
value %= Mod;
return *this;
}
auto& operator*=(mod_number const& rhs)
{
value *= rhs.value;
value %= Mod;
return *this;
}
auto& operator/=(mod_number const& rhs)
{
return operator*=(pow(rhs, Mod - 2));
}
};
constexpr int bitcount(unsigned int x)
{
x = (x & 0x55555555) + ((x & 0xAAAAAAAA) >> 1);
x = (x & 0x33333333) + ((x & 0xCCCCCCCC) >> 2);
x = (x & 0x0F0F0F0F) + ((x & 0xF0F0F0F0) >> 4);
x = (x & 0x00FF00FF) + ((x & 0xFF00FF00) >> 8);
x = (x & 0x0000FFFF) + ((x & 0xFFFF0000) >> 16);
return static_cast<int>(x);
}
constexpr int bitcount(unsigned long long x)
{
x = (x & 0b0101010101010101010101010101010101010101010101010101010101010101) + ((x &
            0b1010101010101010101010101010101010101010101010101010101010101010) >> 1);
x = (x & 0b0011001100110011001100110011001100110011001100110011001100110011) + ((x &
            0b1100110011001100110011001100110011001100110011001100110011001100) >> 2);
x = (x & 0b0000111100001111000011110000111100001111000011110000111100001111) + ((x &
            0b1111000011110000111100001111000011110000111100001111000011110000) >> 4);
x = (x & 0b0000000011111111000000001111111100000000111111110000000011111111) + ((x &
            0b1111111100000000111111110000000011111111000000001111111100000000) >> 8);
x = (x & 0b0000000000000000111111111111111100000000000000001111111111111111) + ((x &
            0b1111111111111111000000000000000011111111111111110000000000000000) >> 16);
x = (x & 0b0000000000000000000000000000000011111111111111111111111111111111) + ((x &
            0b1111111111111111111111111111111100000000000000000000000000000000) >> 32);
return static_cast<int>(x);
}
constexpr int bitcount(int x)
{
return bitcount(static_cast<unsigned int>(x));
}
constexpr int bitcount(long long x)
{
return bitcount(static_cast<unsigned long long>(x));
}
constexpr auto infinity = utility::nullopt;
template<class T>class infable :
private utility::addable<T>,
private utility::subtractable<T>,
private utility::multipliable<T>,
private utility::dividable<T>,
private utility::equality_comparable<T>,
private utility::less_than_comparable<T>
{
utility::optional<T> val;
public:
constexpr infable(T v = T()) :val(v)
{
}
constexpr infable(utility::nullopt_t) : val()
{
}
constexpr T const& get()const
{
return *val;
}
constexpr bool operator<(infable<T>const& rhs)const
{
if (val&&rhs.val)
{
return *val < rhs.get();
}
else if (val && !rhs.val)
{
return true;
}
else
{
return false;
}
}
constexpr bool operator==(infable<T>const& rhs)const
{
return val == rhs.val;
}
constexpr decltype(auto) operator+=(infable<T>const& rhs)
{
if (val)
{
if (rhs.val)
{
*val += rhs.get();
}
else
{
val = infinity;
}
}
return *this;
}
constexpr decltype(auto) operator-=(infable<T>const& rhs)
{
if (val)
{
if (rhs.val)
{
*val -= rhs.get();
}
else
{
val = infinity;
}
}
return *this;
}
constexpr decltype(auto) operator*=(infable<T>const& rhs)
{
if (val)
{
if (rhs.val)
{
*val *= rhs.get();
}
else
{
val = infinity;
}
}
return *this;
}
constexpr decltype(auto) operator/=(infable<T>const& rhs)
{
if (val)
{
if (rhs.val)
{
*val /= rhs.get();
}
else
{
val = infinity;
}
}
return *this;
}
};
}
namespace container
{
namespace detail
{
template<class T, std::size_t Depth>struct tree_array
{
std::array<T, (1 << (Depth + 1)) - 1> ar;
constexpr T& operator()(std::size_t index, std::size_t depth)
{
return ar[(1ull << depth) + index - 1];
}
constexpr T const& operator()(std::size_t index, std::size_t depth)const
{
return ar[(1ull << depth) + index - 1];
}
};
}
template<class T, std::size_t Size = 1 << 13>class addtree
{
std::array<T, 2 * Size - 1> data;
T get(std::size_t left, std::size_t right, std::size_t i, std::size_t l, std::size_t r)
{
if (r <= left || right <= l)
return T();
if (left <= l&&r <= right)
{
return data[i];
}
else
{
return
get(left, right, 2 * i + 1, l, (l + r) / 2) +
get(left, right, 2 * i + 2, (l + r) / 2, r);
}
}
public:
addtree() :data{}
{
}
void change(T const& val, std::size_t index)
{
T from = data[index + Size - 1];
for (std::size_t i = 1, c = math::ilog(Size, 2);i <= Size;(i <<= 1), --c)
{
data[i + (index >> c) - 1] -= from;
data[i + (index >> c) - 1] += val;
}
}
auto begin()const
{
return std::next(data.begin(), Size - 1);
}
auto end()const
{
return data.end();
}
T get(std::size_t left, std::size_t right)
{
return left > right ? T() : get(left, right + 1, 0, 0, Size);
}
};
template<class T, std::size_t Depth = 13>class minmaxtree
{
detail::tree_array<std::pair<T, T>, Depth> data;
T min(std::size_t left, std::size_t right, std::size_t L, std::size_t R, std::size_t depth)const
{
if (right <= L || R <= left)
{
return std::numeric_limits<T>::max();
}
else if (left <= L&&R <= right)
{
return data(L >> (Depth - depth), depth).first;
}
else
{
return std::min(
min(left, right, L, (L + R) / 2, depth + 1),
min(left, right, (L + R) / 2, R, depth + 1));
}
}
T max(std::size_t left, std::size_t right, std::size_t L, std::size_t R, std::size_t depth)const
{
if (right <= L || R <= left)
{
return std::numeric_limits<T>::min();
}
else if (left <= L&&R <= right)
{
return data(L >> (Depth - depth), depth).second;
}
else
{
return std::max(
max(left, right, L, (L + R) / 2, depth + 1),
max(left, right, (L + R) / 2, R, depth + 1));
}
}
public:
void change(T const& val, std::size_t index)
{
data(index, Depth).first = val;
data(index, Depth).second = val;
for (int i = 1;i <= Depth;++i)
{
data(index >> i, Depth - i).first = std::min(
data((index >> i) << 1, Depth - i + 1).first,
data(((index >> i) << 1) + 1, Depth - i + 1).first);
data(index >> i, Depth - i).second = std::max(
data((index >> i) << 1, Depth - i + 1).second,
data(((index >> i) << 1) + 1, Depth - i + 1).second);
}
}
T min(std::size_t left, std::size_t right)const
{
return right < left ? std::numeric_limits<T>::max() : min(left, right + 1, 0, 1 << Depth, 0);
}
T max(std::size_t left, std::size_t right)const
{
return right < left ? std::numeric_limits<T>::min() : max(left, right + 1, 0, 1 << Depth, 0);
}
minmaxtree() :data{}
{
}
};
template<class T>using dijkstra_queue = std::priority_queue<T, std::vector<T>, std::greater<>>;
}
namespace algorithm
{
template<class RandomAccessRange>void sort(RandomAccessRange& range)
{
std::sort(std::begin(range), std::end(range));
}
template<class T, std::size_t I>void sort(T(&range)[I])
{
std::sort(std::begin(range), std::end(range));
}
}
void Main();
int main()
{
std::ios::sync_with_stdio(false);
Main();
}
//����������
void Main()
{
int W, H, N;
std::cin >> W >> H >> N;
std::set<int> X, Y;
for (int i{};i < N;++i)
{
int w, h;
std::cin >> w >> h;
X.emplace(w);
Y.emplace(h);
}
std::cout << W*Y.size() + H*X.size() - X.size()*Y.size() - N << std::endl;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0