結果

問題 No.3 ビットすごろく
コンテスト
ユーザー plasma_e
提出日時 2017-02-06 14:54:38
言語 C++14
(gcc 13.3.0 + boost 1.87.0)
結果
TLE  
実行時間 -
コード長 9,574 bytes
コンパイル時間 917 ms
コンパイル使用メモリ 101,172 KB
実行使用メモリ 16,960 KB
最終ジャッジ日時 2024-12-24 10:38:23
合計ジャッジ時間 164,497 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge5
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
other AC * 5 WA * 1 TLE * 27
権限があれば一括ダウンロードができます
コンパイルメッセージ
main.cpp:55:116: warning: friend declaration 'decltype(auto) utility::operator!=(const equality_comparable<T>&, const equality_comparable<T>&)' declares a non-template function [-Wnon-template-friend]
   55 |                 friend decltype(auto) operator!=(equality_comparable<T>const& lhs, equality_comparable<T>const& rhs);
      |                                                                                                                    ^
main.cpp:55:116: 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:63:91: warning: friend declaration 'decltype(auto) utility::operator+(const addable<T>&, const addable<T>&)' declares a non-template function [-Wnon-template-friend]
   63 |                 friend decltype(auto) operator+(addable<T>const& lhs, addable<T>const& rhs);
      |                                                                                           ^
main.cpp:72:101: warning: friend declaration 'decltype(auto) utility::operator-(const subtractable<T>&, const subtractable<T>&)' declares a non-template function [-Wnon-template-friend]
   72 |                 friend decltype(auto) operator-(subtractable<T>const& lhs, subtractable<T>const& rhs);
      |                                                                                                     ^
main.cpp:80:101: warning: friend declaration 'decltype(auto) utility::operator*(const multipliable<T>&, const multipliable<T>&)' declares a non-template function [-Wnon-template-friend]
   80 |                 friend decltype(auto) operator*(multipliable<T>const& lhs, multipliable<T>const& rhs);
      |                                                                                                     ^
main.cpp:88:95: warning: friend declaration 'decltype(auto) utility::operator/(const dividable<T>&, const dividable<T>&)' declares a non-template function [-Wnon-template-friend]
   88 |

ソースコード

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 equality_comparable;
	template<class T>struct addable;
	template<class T>struct subtractable;
	template<class T>struct multipliable;
	template<class T>struct dividable;
	template<class T>decltype(auto) operator!=(equality_comparable<T>const& lhs, equality_comparable<T>const& rhs)
	{
		return !lhs.operator==(rhs);
	}
	template<class T>decltype(auto) operator+(addable<T>const& lhs, addable<T>const& rhs)
	{
		auto x = lhs;
		x += rhs;
		return x;
	}
	template<class T>decltype(auto) operator-(subtractable<T>const& lhs, subtractable<T>const& rhs)
	{
		auto x = lhs;
		x -= rhs;
		return x;
	}
	template<class T>decltype(auto) operator*(multipliable<T>const& lhs, multipliable<T>const& rhs)
	{
		auto x = lhs;
		x *= rhs;
		return x;
	}
	template<class T>decltype(auto) operator/(dividable<T>const& lhs, dividable<T>const& rhs)
	{
		auto x = lhs;
		x /= rhs;
		return x;
	}
	template<class T>struct equality_comparable
	{
		decltype(auto) operator==(equality_comparable<T>const& rhs)const
		{
			return static_cast<T const&>(*this) == static_cast<T const&>(rhs);
		}
		friend decltype(auto) operator!=(equality_comparable<T>const& lhs, equality_comparable<T>const& rhs);
	};
	template<class T>struct addable
	{
		decltype(auto) operator+=(addable<T>const& rhs)
		{
			return static_cast<T const&>(*this) += static_cast<T const&>(rhs);
		}
		friend decltype(auto) operator+(addable<T>const& lhs, addable<T>const& rhs);
	};
	template<class T>struct subtractable
	{
		decltype(auto) operator-=(subtractable<T>const& rhs)
		{
			return static_cast<T const&>(*this) -= static_cast<T const&>(rhs);
		}

		friend decltype(auto) operator-(subtractable<T>const& lhs, subtractable<T>const& rhs);
	};
	template<class T>struct multipliable
	{
		decltype(auto) operator*=(multipliable<T>const& rhs)
		{
			return static_cast<T const&>(*this) *= static_cast<T const&>(rhs);
		}
		friend decltype(auto) operator*(multipliable<T>const& lhs, multipliable<T>const& rhs);
	};
	template<class T>struct dividable
	{
		decltype(auto) operator/=(dividable<T>const& rhs)
		{
			return static_cast<T const&>(*this) /= static_cast<T const&>(rhs);
		}
		friend decltype(auto) operator/(dividable<T>const& lhs, dividable<T>const& rhs);
	};

}
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));
	}

}
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{}
		{

		}

	};
}

void Main();
int main()
{
	std::ios::sync_with_stdio(false);
	Main();
}
//撣

int count(int x, std::vector<int>& passed, int N)
{
	if (x<1 || x>N || passed[x - 1])
	{
		return 999999;
	}
	passed[x - 1] = 1;
	if (x == N)
	{
		return 1;
	}
	int a = count(x + math::bitcount(x), passed, N);
	int b = count(x - math::bitcount(x), passed, N);
	passed[x - 1] = 0;
	return std::min(a, b) + 1;
}

void Main()
{
	int N;
	std::cin >> N;
	std::vector<int> passed(N);
	auto c = count(1, passed, N);
	std::cout << (c >= 999999 ? -1 : c )<< std::endl;
}
0