#1002415 (C++17) No.2494 Sum within Components

• 問題: No.2494 Sum within Components
• ユーザー: elphe
• 提出日時: 2024-08-18 12:47:48
• 言語: C++17 (gcc 12.3.0 + boost 1.83.0)
• 結果: AC
• 実行時間: 75 ms / 2,000 ms
• コード長: 2,431 bytes
• コンパイル時間: 1,295 ms
• コンパイル使用メモリ: 80,500 KB
• 実行使用メモリ: 9,472 KB
• 最終ジャッジ日時: 2024-08-18 12:47:53
• 合計ジャッジ時間: 3,580 ms
• ジャッジサーバーID （参考情報）: judge2 / judge1

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	2 ms; 5,248 KB
testcase_01	AC	2 ms; 5,248 KB
testcase_02	AC	2 ms; 5,376 KB
testcase_03	AC	2 ms; 5,376 KB
testcase_04	AC	2 ms; 5,376 KB
testcase_05	AC	2 ms; 5,376 KB
testcase_06	AC	2 ms; 5,376 KB
testcase_07	AC	2 ms; 5,376 KB
testcase_08	AC	2 ms; 5,376 KB
testcase_09	AC	5 ms; 5,376 KB
testcase_10	AC	6 ms; 5,376 KB
testcase_11	AC	4 ms; 5,376 KB
testcase_12	AC	8 ms; 5,376 KB
testcase_13	AC	6 ms; 5,376 KB
testcase_14	AC	58 ms; 7,296 KB
testcase_15	AC	56 ms; 6,144 KB
testcase_16	AC	28 ms; 7,168 KB
testcase_17	AC	32 ms; 9,344 KB
testcase_18	AC	36 ms; 9,472 KB
testcase_19	AC	75 ms; 9,344 KB

ソースコード

#include <iostream>
#include <cstdint>
#include <vector>

#define MOD   998244353

using namespace std;

class UnionFind
{
protected:
	vector<size_t> root_of, size_of;
	size_t group;
	virtual size_t retrieve_true_root_of(const size_t index) { return root_of[index] == index ? index : root_of[index] = retrieve_true_root_of(root_of[index]); }

public:
	UnionFind(const size_t N) : root_of(vector<size_t>(N)), size_of(N, 1), group(N) { for (size_t i = 0; i != N; ++i) root_of[i] = i; }
	virtual bool is_connected(const size_t a, const size_t b) { return retrieve_true_root_of(a) == retrieve_true_root_of(b); }
	virtual bool merge(const size_t a, const size_t b)
	{
		if (retrieve_true_root_of(a) != retrieve_true_root_of(b))
		{
			size_of[root_of[a]] += size_of[root_of[b]];
			root_of[b] = root_of[root_of[b]] = root_of[a];
			--group;
			return true;
		}
		else
			return false;
	}
	size_t size_of_group_of(const size_t index) { return size_of[retrieve_true_root_of(index)]; }
	size_t groups() { return group; }
};

class MergingUnionFind : public UnionFind
{
protected:
	vector<long long> value_of;
	vector<int> data_of;

public:
	MergingUnionFind(const size_t N, const vector<int>& initializer) : UnionFind(N), value_of(N), data_of(initializer) { for (size_t i = 0; i != N; ++i) value_of[i] = initializer[i]; }
	virtual bool merge(const size_t a, const size_t b)
	{
		if (retrieve_true_root_of(a) != retrieve_true_root_of(b))
		{
			size_of[root_of[a]] += size_of[root_of[b]];
			value_of[root_of[a]] += value_of[root_of[b]];
			root_of[b] = root_of[root_of[b]] = root_of[a];
			--group;
			return true;
		}
		else
			return false;
	}

	int get_individual_value_of(const size_t index) { return data_of[index]; }
	long long get_total_value_of(const size_t index) { return value_of[retrieve_true_root_of(index)]; }

	int modify(const size_t index, const int value)
	{
		value_of[retrieve_true_root_of(index)] -= data_of[index];
		data_of[index] = value;
		value_of[root_of[index]] += data_of[index];
		return value;
	}
};

int main()
{
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	uint32_t N, M, i, U, V;
	cin >> N >> M;
	int32_t ans = 1;
	vector<int32_t> A(N);
	for (i = 0; i != N; ++i) cin >> A[i];

	MergingUnionFind muf(N, A);
	for (i = 0; i != M; ++i)
	{
		cin >> U >> V;
		muf.merge(U - 1, V - 1);
	}

	for (i = 0; i != N; ++i)
		ans = ans * (muf.get_total_value_of(i) % MOD) % MOD;

	cout << ans << '\n';
	return 0;
}