Submission #60077243

---

Source Code Expand

#pragma region headers

#include <algorithm>
#include <bit>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
// #include <queue>
#include <set>
#include <string>
// #include <unordered_map>
// #include <unordered_set>
#include <vector>
// #include <sstream>

#include <cmath>
#include <functional>
#include <numbers>
#include <numeric>
// #include <bit>
// #include <boost/multiprecision/cpp_dec_float.hpp>

#pragma endregion

#pragma region pre

#ifndef _MSC_VER

#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

#endif


using namespace std;
using namespace std::literals;

// #include <atcoder/all>
// using namespace atcoder;

using ll  = long long;
using pll = pair<ll, ll>;
using str = std::string;

template<typename T>
using vec = std::vector<T>;

#define rep(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define reps(i, n, s) for (int i = static_cast<int>(s); i < static_cast<int>(n); i++)
#define all(x) std::begin(x), std::end(x)

template<typename T>
inline bool chmax(T& a, T b) {
	return ((a < b) ? (a = b, true) : (false));
}
template<typename T>
inline bool chmin(T& a, T b) {
	return ((a > b) ? (a = b, true) : (false));
}

int constexpr intmax = numeric_limits<int>().max();
int constexpr intmin = numeric_limits<int>().min();
ll constexpr llmax   = numeric_limits<ll>().max();
ll constexpr llmin   = numeric_limits<ll>().min();

// std::ostream& operator<<(std::ostream& os, const atcoder::modint1000000007& obj) {
// 	return os << obj.val();
// }
//
// std::ostream& operator<<(std::ostream& os, const atcoder::modint998244353& obj) {
// 	return os << obj.val();
// }

template<typename T, typename U>
std::ostream& operator<<(std::ostream& os, const pair<T, U>& obj) {
	return os << "(" << obj.first << ", " << obj.second << ")";
}

template<typename... Args>
void print(Args... args) {
	auto t = tie(args...);
	apply([](auto&&... args) { ((cout << args << ' '), ...); }, t);
	cout << '\n';
}

template<typename... Args>
void prints(Args... args) {
	auto t = tie(args...);
	apply([](auto&&... args) { ((cout << args << ' '), ...); }, t);
	cout << ' ';
}

template<typename T>
void printv(const T& container, int width = 3) {
	for (auto it = container.begin(); it != container.end(); ++it) {
		cout << setw(width - 1) << *it << " ";
	}
	cout << endl;
}

template<typename T>
void printv2(const T& container, int width = 3) {
	for (auto it = container.begin(); it != container.end(); ++it) {
		for (auto it2 = it->begin(); it2 != it->end(); ++it2) {
			cout << setw(width - 1) << *it2 << " ";
		}
		cout << endl;
	}
}

template<typename T>
void printv3(const T& container, int width = 3) {
	for (auto it = container.begin(); it != container.end(); ++it) {
		for (auto it2 = it->begin(); it2 != it->end(); ++it2) {
			for (auto it3 = it->begin(); it3 != it->end(); ++it3) {
				cout << setw(width - 1) << *it3 << " ";
			}
			cout << endl;
		}
		cout << endl
			 << endl;
	}
}

template<typename T>
std::vector<T> create_vec(const T& value, size_t size) {
	return std::vector<T>(size, value);
}

template<typename T, typename... Dims>
auto create_vec(const T& value, size_t first, Dims... dims) {
	return std::vector<decltype(create_vec<T>(value, dims...))>(first, create_vec(value, dims...));
}

void yesno(bool cond) {
	cout << (cond ? "Yes" : "No") << endl;
}

void init_io() {
	std::ios_base::sync_with_stdio(false);
	std::cin.tie(nullptr);
	cout << std::setprecision(24);
}

#pragma endregion

#include <random>
std::random_device seed_gen;
std::mt19937 engine(seed_gen());

ll getRandom(ll min, ll max) { // [min ... max]
	std::uniform_int_distribution<ll> dist(min, max);
	return dist(engine);
}

using P = tuple<ll, ll, ll>;

std::ostream& operator<<(std::ostream& os, const P& obj) {
	return os << "(" << get<0>(obj) << "," << get<1>(obj) << "," << get<2>(obj) << ")";
}
class Solution {
public:
	// using mint = atcoder::modint998244353;
	// using mint = atcoder::modint1000000007;

	void run() {
		ll n;
		cin >> n;

		vec<int> a(n);
		rep(i, n) {
			cin >> a[i];
		}
	
		vec<pair<int, int>> rle;
		int cnt = 0;
		rep(i, n) {
			if (i == n - 1 || a[i + 1] != a[i]) {
				rle.emplace_back(a[i], cnt + 1);
				cnt = 0;
			}
			else {
				++cnt;
			}
		}

		// printv(rle);

		int ans = 0;
		int l = -1;

		set<int> nums;
		rep(i, rle.size()) {
			auto [num, cnt] = rle[i];
			if (l == -1) {
				if (cnt >= 2) {
					l = i;
					nums.insert(num);
					chmax(ans, (int)nums.size() * 2);
					// print(l, i);
				}
			}
			else {
				if (cnt >= 2) {
					if (nums.contains(num)) {
						for (; l < i; ++l) {
							auto [ns, nc] = rle[l];
							nums.erase(ns);
							if (ns == num) {
								break;
							}
						}
						++l;
					}
					nums.insert(num);
					chmax(ans, (int)nums.size() * 2);
					// print(l, i);

					if (cnt > 2) {
						l = i;
						nums.clear();
						nums.insert(num);
					}
				}
				else {
					l = -1;
					nums.clear();
				}
			}
		}

		print(ans);
	}
};

int main() {
	init_io();
	Solution().run();
	return 0;
}

Submission Info

Compile Error

Main.cpp:1: warning: ignoring ‘#pragma region headers’ [-Wunknown-pragmas]
    1 | #pragma region headers
      | 
Main.cpp:24: warning: ignoring ‘#pragma endregion ’ [-Wunknown-pragmas]
   24 | #pragma endregion
      | 
Main.cpp:26: warning: ignoring ‘#pragma region pre’ [-Wunknown-pragmas]
   26 | #pragma region pre
      | 
Main.cpp:147: warning: ignoring ‘#pragma endregion ’ [-Wunknown-pragmas]
  147 | #pragma endregion
      | 

Judge Result