leetcode.cpp

#include "leetcode.h"
#include "templates.h"
#include <algorithm>
#include <bit>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstring>
#include <numeric>
#include <queue>
#include <regex>
#include <sstream>
#include <stack>
#include <unordered_set>

using namespace std;

namespace leetcode {
	bool TreeNode::operator==(const TreeNode &node) const {
		if(this->left != nullptr && node.left == nullptr) {
			return false;
		}
		if(this->left == nullptr && node.left != nullptr) {
			return false;
		}
		if(this->right != nullptr && node.right == nullptr) {
			return false;
		}
		if(this->right == nullptr && node.right != nullptr) {
			return false;
		}
		if(this->left != nullptr && node.left != nullptr && *this->left != *node.left) {
			return false;
		}
		if(this->right != nullptr && node.right != nullptr && *this->right != *node.right) {
			return false;
		}
		return this->val == node.val;
	}

	bool TreeNode::operator!=(const TreeNode &node) const { return !(*this == node); }

	namespace concatenated_words {
		vector<string> Solution::findAllConcatenatedWordsInADict(vector<string> &words) {
			sort(words.begin(), words.end(), [&](const string &a, const string &b) { return a.size() < b.size(); });
			auto ans  = vector<string>();
			auto node = TrieNode(0);
			for(const string &word: words) {
				if(word.length() == 0) {
					continue;
				}
				if(node.dfs(&node, word, 0, false)) {
					ans.push_back(word);
				} else {
					node.insert(word);
				}
			}
			return ans;
		}

		TrieNode::TrieNode(char ch) {
			this->ch     = ch;
			this->is_end = false;
		}

		void TrieNode::insert(const string &str) {
			auto *node = this->nexts[str[0] - 'a'];
			if(node == nullptr) {
				node                      = new TrieNode(str[0]);
				this->nexts[str[0] - 'a'] = node;
			}
			if(str.length() == 1) {
				node->is_end = true;
				return;
			}
			return node->insert(str.substr(1));
		}

		bool TrieNode::dfs(TrieNode *root, const string &str, int start, bool flag) const {
			if(this->ch == 0) {
				//根节点
				const auto *const node = this->nexts[str[start] - 'a'];
				if(node == nullptr) {
					return false;
				}
				return node->dfs(root, str, start, flag);
			}
			//非根节点
			//到一个单词结束处
			if(this->is_end) {
				if(start == str.length() - 1) {
					return flag;
				}
				const auto res = root->dfs(root, str, start + 1, true);
				if(res) {
					return true;
				}
			}
			const TrieNode *node = nullptr;
			if(str[start + 1] - 'a' >= 0) {
				node = this->nexts[str[start + 1] - 'a'];
			}
			return node != nullptr && node->dfs(root, str, start + 1, flag);
		}
	}// namespace concatenated_words

	namespace excel_sheet_column_number {
		int Solution::titleToNumber(const std::string &columnTitle) {
			int sum    = 0;
			int length = static_cast<int>(columnTitle.length());
			for(const char c: columnTitle) {
				sum += static_cast<int>(static_cast<double>(c - 'A' + 1) * pow(26, length-- - 1));
			}
			return sum;
		}
	}// namespace excel_sheet_column_number

	namespace excel_sheet_column_title {
		string Solution::convertToTitle(int columnNumber) {
			auto ans   = string();
			bool round = false;
			while(columnNumber != 0) {
				char ch = 0;
				if(round) {
					ch    = static_cast<char>(columnNumber % 26 + 63);
					round = false;
				} else {
					ch = static_cast<char>(columnNumber % 26 + 64);
				}
				if(ch == '@' && columnNumber >= 26) {
					ch    = 'Z';
					round = true;
				} else if(ch == '?' && columnNumber >= 26) {
					ch    = 'Y';
					round = true;
				}
				if('A' <= ch && ch <= 'Z') {
					ans.insert(0, 1, ch);
				}
				columnNumber /= 26;
			}
			return ans;
		}
	}// namespace excel_sheet_column_title

	namespace majority_element {
		Solution::Solution() { this->m = std::map<int, int>(); }

		int Solution::majorityElement(vector<int> &nums) {
			for(int i: nums) {
				if(m.contains(i)) {
					m[i] = m[i] + 1;
					if(m[i] > nums.size() / 2) {
						return i;
					}
				} else {
					m[i] = 1;
				}
			}
			return 0;
		}
	}// namespace majority_element

	namespace count_special_quadruplets {
		int Solution::countQuadruplets(vector<int> &nums) {
			int sum = 0;
			for(int i = 3; i < nums.size(); i++) {
				for(int j = 0; j < i - 2; j++) {
					if(j == i) {
						continue;
					}
					for(int k = j + 1; k < i - 1; k++) {
						if(k == i) {
							continue;
						}
						for(int l = k + 1; l < i; l++) {
							if(l == i) {
								continue;
							}
							if(nums[k] + nums[j] + nums[l] == nums[i]) {
								sum++;
							}
						}
					}
				}
			}
			return sum;
		}
	}// namespace count_special_quadruplets

	namespace hand_of_straights {
		bool Solution::isNStraightHand(vector<int> &hand, int groupSize) {
			if(hand.size() % groupSize != 0) {
				return false;
			}
			if(groupSize == 1) {
				return true;
			}
			sort(hand.begin(), hand.end());
			const auto len = hand.size() / groupSize;
			for(int i = 0; i < len; i++) {
				int current = *hand.begin();
				hand.erase(hand.begin());
				for(int j = 1; j < groupSize; j++) {
					auto next = find(hand.begin(), hand.end(), current + 1);
					if(next == hand.end()) {
						return false;
					}
					current = *next;
					hand.erase(next);
				}
			}
			return true;
		}
	}// namespace hand_of_straights

	namespace perfect_number {
		bool Solution::checkPerfectNumber(int num) {
			int sum = 0;
			int max = num;
			for(int i = 1; i < max; i++) {
				if(num % i == 0) {
					sum += i;
					if(i != 1) {
						sum += num / i;
					}
					max = num / i;
				}
			}
			return sum == num;
		}
	}// namespace perfect_number

	namespace convert_bst_to_greater_tree {
		TreeNode *Solution::convertBST(TreeNode *root) {
			if(root == nullptr) {
				return nullptr;
			}
			FriendTreeNode *sum = copy(root);
			get_sum(sum);
			sum->val = sum->sum - (sum->left == nullptr ? 0 : sum->left->sum);
			convert(sum);
			return root;
		}

		FriendTreeNode *Solution::copy(TreeNode *node) {
			auto *ret = new FriendTreeNode(node->val, node);
			if(node->left != nullptr) {
				ret->left = copy(node->left);
			}
			if(node->right != nullptr) {
				ret->right = copy(node->right);
			}
			return ret;
		}

		void Solution::get_sum(FriendTreeNode *node) {
			if(node->left != nullptr) {
				get_sum(node->left);
				node->sum += node->left->sum;
			}
			if(node->right != nullptr) {
				get_sum(node->right);
				node->sum += node->right->sum;
			}
		}

		void Solution::convert(FriendTreeNode *sum_node) {
			if(sum_node->right != nullptr) {
				sum_node->right->val = sum_node->val - sum_node->friend_node->val -
				                       (sum_node->right->left == nullptr ? 0 : sum_node->right->left->sum);
				convert(sum_node->right);
			}
			if(sum_node->left != nullptr) {
				sum_node->left->val = sum_node->val + sum_node->left->friend_node->val +
				                      (sum_node->left->right == nullptr ? 0 : sum_node->left->right->sum);
				convert(sum_node->left);
			}
			sum_node->friend_node->val = sum_node->val;
		}
	}// namespace convert_bst_to_greater_tree

	namespace convert_1d_array_into_2d_array {
		vector<vector<int>> Solution::construct2DArray(vector<int> &original, int m, int n) {
			if(original.size() != static_cast<unsigned long long>(m) * static_cast<unsigned long long>(n)) {
				return {};
			}
			auto ans  = vector<vector<int>>();
			int count = 0;
			for(int i = 0; i < m; i++) {
				auto row = vector<int>();
				for(int j = 0; j < n; j++) {
					row.push_back(original[count++]);
				}
				ans.push_back(row);
			}
			return ans;
		}
	}// namespace convert_1d_array_into_2d_array

	namespace elimination_game {
		int Solution::lastRemaining(int n) {
			int num_amount = n;
			int loop_cnt   = 0;
			int a0         = 1;//初项
			int d          = 1;//差
			while(num_amount != 1) {
				//剩下的数目不为1时
				if(num_amount % 2 == 1) {
					// 奇数个数字
					a0 = a0 + d;
				} else if(num_amount % 2 == 0) {
					// 偶数个数字
					const bool left_to_right = loop_cnt % 2 == 0;
					if(left_to_right) {
						a0 = a0 + d;
					} else {
						a0 = a0;
					}
				}
				loop_cnt++;
				d *= 2;
				num_amount /= 2;
			}
			return a0;
		}
	}// namespace elimination_game

	namespace check_if_all_as_appears_before_all_bs {
		bool Solution::checkString(const string &s) {
			bool flag = true;
			for(const char ch: s) {
				if(ch == 'a') {
					if(!flag) {
						return false;
					}
				} else if(ch == 'b') {
					flag = false;
				}
			}
			return true;
		}
	}// namespace check_if_all_as_appears_before_all_bs

	namespace number_of_laser_beams_in_a_bank {
		int Solution::numberOfBeams(vector<string> &bank) {
			if(bank.size() == 1) {
				return 0;
			}
			int count   = 0;
			int i       = 0;
			int count_i = deviceCount(bank[i]);
			int j       = 1;
			while(i < j && i < bank.size() && j < bank.size()) {
				if(deviceCount(bank[j]) == 0) {
					j++;
					continue;
				}
				const int count_j = deviceCount(bank[j]);
				count += count_i * count_j;
				count_i = count_j;
				i       = j;
				j++;
			}
			return count;
		}

		int Solution::deviceCount(const string &str) {
			int count = 0;
			for(const char c: str) {
				if(c == '1') {
					count++;
				}
			}
			return count;
		}
	}// namespace number_of_laser_beams_in_a_bank

	namespace destroying_asteroids {
		bool Solution::asteroidsDestroyed(int mass, vector<int> &asteroids) {
			long long m = mass;
			sort(asteroids.begin(), asteroids.end());
			for(const int i: asteroids) {
				if(m < i) {
					return false;
				}
				m += i;
			}
			return true;
		}
	}// namespace destroying_asteroids

	/*namespace maximum_employees_to_be_invited_to_a_meeting {
		int Solution::maximumInvitations(vector<int>& favorite) {
			int n = static_cast<int>(favorite.size());
			vector<vector<int >> g(n), rg(n); // rg 为图 g 的反图
			vector<int> deg(n); // 图 g 上每个节点的入度
			for (int v = 0; v < n; ++v) {
				int w = favorite[v];
				g[v].emplace_back(w);
				rg[w].emplace_back(v);
				++deg[w];
			}

			// 拓扑排序，剪掉图 g 上的所有树枝
			queue<int> q;
			for (int i = 0; i < n; ++i) {
				if (deg[i] == 0) {
					q.emplace(i);
				}
			}
			while (!q.empty()) {
				int v = q.front();
				q.pop();
				for (int w : g[v]) {
					if (--deg[w] == 0) {
						q.emplace(w);
					}
				}
			}

			// 寻找图 g 上的基环
			vector<int> ring;
			vector<int> vis(n);

			function<void(int)> dfs = [&](int v) {
				vis[v] = true;
				ring.emplace_back(v);
				for (int w : g[v]) {
					if (!vis[w]) {
						dfs(w);
					}
				}
			};

			// 通过反图 rg 寻找树枝上最深的链
			int max_depth = 0;

			function<void(int, int, int)> rdfs = [&](int v, int fa, int depth) {
				max_depth = max(max_depth, depth);
				for (int w : rg[v]) {
					if (w != fa) {
						rdfs(w, v, depth + 1);
					}
				}
			};

			int max_ring_size = 0, sum_chian_size = 0;
			for (int i = 0; i < n; ++i) {
				if (!vis[i] && deg[i]) { // 遍历基环上的点（拓扑排序后入度不为 0）
					ring.resize(0);
					dfs(i);
					int sz = static_cast<int>(ring.size());
					if (sz == 2) { // 基环大小为 2
						int v = ring[0], w = ring[1];
						max_depth = 0;
						rdfs(v, w, 1);
						sum_chian_size += max_depth; // 累加 v 这一侧的最长链的长度
						max_depth = 0;
						rdfs(w, v, 1);
						sum_chian_size += max_depth; // 累加 w 这一侧的最长链的长度
					}
					else {
						max_ring_size = max(max_ring_size, sz); // 取所有基环的最大值
					}
				}
			}
			return max(max_ring_size, sum_chian_size);
		}
	}*/
	/**
	 * \brief LeetCode 1185. 一周中的第几天
	 */
	namespace day_of_the_week {
		string Solution::dayOfTheWeek(int day, int month, int year) {
			const string output[]   = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
			const int dayofmonths[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
			int count               = 5;
			count += (year - 1971) * 365;
			count += (year - 1) / 4 - 1970 / 4;
			for(int m = 0; m < month - 1; m++) {
				count += dayofmonths[m];
			}
			if(month > 2 && year % 4 == 0 && year % 100 != 0) {
				count++;
			}
			count += day - 1;
			count %= 7;
			return output[count];
		}
	}// namespace day_of_the_week

	namespace cat_and_mouse {
		int Solution::catMouseGame(vector<vector<int>> &graph) {
			this->n     = graph.size();
			this->graph = graph;
			memset(dp, -1, sizeof dp);
			return getResult(1, 2, 0);
		}

		int Solution::getResult(int mouse, int cat, int turns) {
			if(turns == n * 2) {
				return DRAW;
			}
			if(dp[mouse][cat][turns] < 0) {
				if(mouse == 0) {
					dp[mouse][cat][turns] = MOUSE_WIN;
				} else if(cat == mouse) {
					dp[mouse][cat][turns] = CAT_WIN;
				} else {
					getNextResult(mouse, cat, turns);
				}
			}
			return dp[mouse][cat][turns];
		}

		void Solution::getNextResult(int mouse, int cat, int turns) {
			const int curMove       = turns % 2 == 0 ? mouse : cat;
			const int defaultResult = curMove == mouse ? CAT_WIN : MOUSE_WIN;
			int result              = defaultResult;
			for(int next: graph[curMove]) {
				if(curMove == cat && next == 0) {
					continue;
				}
				const int nextMouse  = curMove == mouse ? next : mouse;
				const int nextCat    = curMove == cat ? next : cat;
				const int nextResult = getResult(nextMouse, nextCat, turns + 1);
				if(nextResult != defaultResult) {
					result = nextResult;
					if(result != DRAW) {
						break;
					}
				}
			}
			dp[mouse][cat][turns] = result;
		}
	}// namespace cat_and_mouse

	namespace replace_all_s_to_avoid_consecutive_repeating_characters {
		string Solution::modifyString(string s) {
			for(int i = 0; i < s.size(); i++) {
				if(s[i] == '?') {
					for(char ch = 'a'; ch < 'z' + 1; ch++) {
						if(0 <= i - 1 && s[i - 1] == ch) {
							continue;
						}
						if(i + 1 < s.size() && s[i + 1] == ch) {
							continue;
						}
						s[i] = ch;
						break;
					}
				}
			}
			return s;
		}
	}// namespace replace_all_s_to_avoid_consecutive_repeating_characters

	namespace simplify_path {
		string Solution::simplifyPath(const string &path) {
			auto *const str_cpy = new char[path.size() + 1];
			memcpy(str_cpy, path.c_str(), path.size() + 1);
			auto *next = strtok(str_cpy, "/");
			auto stck  = deque<string>();
			while(next != nullptr) {
				auto nextstr = string(next);
				if(nextstr == "..") {
					if(!stck.empty()) {
						stck.pop_back();
					}
					next = strtok(nullptr, "/");
					continue;
				}
				if(nextstr == ".") {
					next = strtok(nullptr, "/");
					continue;
				}
				stck.emplace_back(next);
				next = strtok(nullptr, "/");
			}
			auto oss = ostringstream();
			if(stck.empty()) {
				oss << '/';
			} else {
				while(!stck.empty()) {
					auto pname = stck.front();
					oss << '/' << pname;
					stck.pop_front();
				}
			}
			delete[] str_cpy;
			return oss.str();
		}
	}// namespace simplify_path

	namespace maximum_nesting_depth_of_the_parentheses {
		int Solution::maxDepth(const string &s) {
			int max     = 0;
			int current = 0;
			for(const char ch: s) {
				if(ch == '(') {
					current++;
				} else if(ch == ')') {
					current--;
				}
				if(max < current) {
					max = current;
				}
			}
			return max;
		}
	}// namespace maximum_nesting_depth_of_the_parentheses

	namespace gray_code {
		vector<int> Solution::grayCode(int n) {
			vector<int> ret(1 << n);
			for(int i = 0; i < ret.size(); i++) {
				ret[i] = i >> 1 ^ i;
			}
			return ret;
		}
	}// namespace gray_code

	namespace check_if_every_row_and_column_contains_all_numbers {
		bool Solution::checkValid(vector<vector<int>> &matrix) {
			const unsigned int n = matrix.size();
			for(int i = 0; i < n; i++) {
				auto *const row = new bool[n + 1];
				memset(row, 1, (n + 1) * sizeof(bool));
				for(int j = 0; j < n; j++) {
					if(!row[matrix[i][j]]) {
						delete[] row;
						return false;
					}
					row[matrix[i][j]] = false;
				}
				delete[] row;
			}

			for(int j = 0; j < n; j++) {
				auto *const column = new bool[n + 1];
				memset(column, 1, (n + 1) * sizeof(bool));
				for(int i = 0; i < n; i++) {
					if(!column[matrix[i][j]]) {
						delete[] column;
						return false;
					}
					column[matrix[i][j]] = false;
				}
				delete[] column;
			}
			return true;
		}
	}// namespace check_if_every_row_and_column_contains_all_numbers

	namespace minimum_swaps_to_group_all_1s_together_ii {
		int Solution::minSwaps(vector<int> &nums) {
			int onecount = 0;
			for(const int num: nums) {
				if(num == 1) {
					onecount++;
				}
			}
			if(onecount == 0) {
				return 0;
			}

			int zerocount = 0;
			for(int i = 0; i < onecount; i++) {
				if(nums[i] == 0) {
					zerocount++;
				}
			}
			int min = zerocount;

			for(int i = 0; i < nums.size(); i++) {
				if(nums[i] == 0) {
					zerocount--;
				}
				if(nums[(onecount + i) % nums.size()] == 0) {
					zerocount++;
				}
				if(zerocount < min) {
					min = zerocount;
				}
			}
			return min;
		}
	}// namespace minimum_swaps_to_group_all_1s_together_ii

	namespace count_words_obtained_after_adding_a_letter {
		int Solution::wordCount(vector<string> &startWords,
		                        vector<string> &targetWords) {
			int count  = 0;
			auto start = unordered_set<unsigned int>();
			for(const string &word: startWords) {
				auto bin = str2bin(word);
				start.insert(bin);
			}
			for(const string &word: targetWords) {
				const auto bin = str2bin(word);
				for(int i = 0; i < 26; i++) {
					if((bin & 1 << i) != 0 && start.contains(bin - (1 << i))) {
						//bin有第i个字母且bin去掉第i个字母在start中仍然存在
						count++;
						break;
					}
				}
			}
			return count;
		}

		unsigned int Solution::str2bin(const string &str) {
			unsigned int ret = 0;
			for(const char ch: str) {
				ret |= 1 << ch - 'a';
			}
			return ret;
		}
	}// namespace count_words_obtained_after_adding_a_letter

	namespace slowest_key {
		char Solution::slowestKey(vector<int> &releaseTimes, string keysPressed) {
			int max  = releaseTimes[0];
			int maxi = 0;
			for(int i = 1; i < releaseTimes.size(); i++) {
				const int time = releaseTimes[i] - releaseTimes[i - 1];
				if(max < time) {
					max  = time;
					maxi = i;
				} else if(max == time) {
					if(keysPressed[i] > keysPressed[maxi]) {
						maxi = i;
					}
				}
			}
			return keysPressed[maxi];
		}
	}// namespace slowest_key

	namespace additive_number {
		bool Solution::isAdditiveNumber(string num) {
			if(num.length() < 3) {
				return false;
			}
			auto *const nums = new char[num.length()];
			for(int i = 0; i < num.length(); i++) {
				nums[i] = num[i];
			}
			for(int i = 1; i <= num.length() - i; i++) {
				const auto n1 = str2ui(nums, 0, i);
				for(int j = i + 1; j - i <= num.length() - j; j++) {
					const auto n2 = str2ui(nums, i, j - i);
					if(dfs(n1, n2, nums, num.length(), j)) {
						return true;
					}
					if(n2 == 0) {
						break;
					}
				}
				if(n1 == 0) {
					break;
				}
			}
			delete[] nums;
			return false;
		}

		bool Solution::dfs(unsigned long long n1, unsigned long long n2, const char *nums, unsigned short length, unsigned short current) {
			const auto sum = to_string(n1 + n2);
			if(sum.length() > length - current) {
				//前两位和的位数超过剩余的位数
				return false;
			}
			if(!equal(sum, nums, current, length)) {
				//不包含下一个数字
				return false;
			}
			if(current + sum.length() == length) {
				//终止条件
				return true;
			}
			const auto n3 = str2ui(nums, current, sum.length());
			return dfs(n2, n3, nums, length, current + sum.length());
		}

		unsigned long long Solution::str2ui(const char *str, unsigned short start, unsigned short length) {
			unsigned long long ans = 0;
			for(int i = start; i < start + length; i++) {
				ans *= 10;
				ans += str[i] - '0';
			}
			return ans;
		}

		bool Solution::equal(string sum, const char *nums, unsigned short start, unsigned short length) {
			int j = 0;
			for(int i = start; j < sum.length() && i < length; i++, j++) {
				if(sum[j] != nums[i]) {
					return false;
				}
			}
			return j == sum.length();
		}
	}// namespace additive_number

	namespace decode_the_slanted_ciphertext {
		string Solution::decodeCiphertext(string encodedText, int rows) {
			if(encodedText.empty()) {
				return "";
			}
			const int columns = encodedText.length() / rows;
			auto *const table = new char *[rows];
			for(int i = 0; i < rows; i++) {
				table[i] = new char[columns - rows + 2];
				for(int j = i; j - i < columns - rows + 2; j++) {
					if(i * columns + j < encodedText.length()) {
						table[i][j - i] = encodedText[i * columns + j];
					} else {
						table[i][j - i] = ' ';
					}
				}
			}
			auto oss = ostringstream();
			for(int j = 0; j < columns - rows + 2; j++) {
				for(int i = 0; i < rows; i++) {
					oss << table[i][j];
				}
			}
			string ans = oss.str();
			for(int i = 0; i < rows; i++) {
				delete[] table[i];
			}
			delete[] table;
			return rtrim(ans);
		}

		string Solution::rtrim(string &s) {
			for(int i = s.length() - 1; i >= 0; i--) {
				if(s[i] != ' ') {
					string ans = s.substr(0, i + 1);
					return ans;
				}
			}
			return s;
		}
	}// namespace decode_the_slanted_ciphertext

	namespace escape_a_large_maze {
		bool Solution::isEscapePossible(vector<vector<int>> &blocked, vector<int> &source, vector<int> &target) {
			const int limit = blocked.size() * (blocked.size() - 1) / 2;
			if(blocked.empty()) {
				return true;
			}
			auto *p_source          = new point(source[0], source[1], 0, nullptr);
			auto *p_target          = new point(target[0], target[1], 0, nullptr);
			auto blocked_set_source = unordered_set<point, point_hash>();
			auto blocked_set_target = unordered_set<point, point_hash>();
			for(auto block: blocked) {
				blocked_set_source.insert(point(block[0], block[1], 0, nullptr));
				blocked_set_target.insert(point(block[0], block[1], 0, nullptr));
			}
			const unsigned int source_status = search(blocked_set_source, p_source, p_target, limit);
			if(source_status == 0) {
				return false;
			}
			if(source_status == 1) {
				return true;
			}
			const unsigned int target_status = search(blocked_set_target, p_target, p_source, limit);
			delete p_source;
			delete p_target;
			return target_status != 0;
		}

		unsigned int Solution::search(unordered_set<point, point_hash> &block_set, point *source, point *target, unsigned int limit) {
			auto pq = priority_queue<point>();
			pq.push(point(source->x, source->y, 0, target));
			int count = 0;
			while(!pq.empty()) {
				if(count > limit || pq.size() > limit) {
					return 2;//不包围
				}
				count++;
				const auto p = pq.top();
				pq.pop();
				point nexts[] = {point(p.x + 1, p.y, p.distance + 1, target), point(p.x - 1, p.y, p.distance + 1, target), point(p.x, p.y + 1, p.distance + 1, target), point(p.x, p.y - 1, p.distance + 1, target)};
				for(auto next: nexts) {
					if(0 <= next.x && next.x < 1000000 && 0 <= next.y && next.y < 1000000 && !block_set.contains(next)) {
						if(next.x == target->x && next.y == target->y) {
							return 1;//连通
						}
						pq.push(next);
						block_set.insert(next);
					}
				}
			}
			return 0;//不连通
		}

		bool point::operator<(const point &p) const { return this->distance + (abs(static_cast<int>(this->x - target->x)) + abs(static_cast<int>(this->y - target->y))) < p.distance + (abs(static_cast<int>(p.x - target->x)) + abs(static_cast<int>(p.y - target->y))); }
		bool point::operator==(const point &p) const { return this->x == p.x && this->y == p.y; }

		size_t point_hash::operator()(const point &p) const { return p.x * 1000000 + p.y; }
	}// namespace escape_a_large_maze

	namespace increasing_triplet_subsequence {
		bool Solution::increasingTriplet(vector<int> &nums) {
			if(nums.size() < 3) {
				return false;
			}
			auto *min            = new int[nums.size()];
			auto *max            = new int[nums.size()];
			min[0]               = nums[0];
			max[nums.size() - 1] = nums[nums.size() - 1];
			for(int i = 1, j = nums.size() - 2; i < nums.size() && j >= 0; i++, j--) {
				if(min[i - 1] > nums[i]) {
					min[i] = nums[i];
				} else {
					min[i] = min[i - 1];
				}

				if(max[j + 1] < nums[j]) {
					max[j] = nums[j];
				} else {
					max[j] = max[j + 1];
				}
			}
			for(int i = 0; i < nums.size(); i++) {
				if(nums[i] > min[i] && nums[i] < max[i]) {
					delete[] min;
					delete[] max;
					return true;
				}
			}
			delete[] min;
			delete[] max;
			return false;
		}
	}// namespace increasing_triplet_subsequence

	namespace largest_number_at_least_twice_of_others {
		int Solution::dominantIndex(vector<int> &nums) {
			if(nums.size() < 2) {
				return 0;
			}
			unsigned int max;
			unsigned int index;
			unsigned int second;
			if(nums[0] < nums[1]) {
				max    = nums[1];
				index  = 1;
				second = nums[0];
			} else {
				max    = nums[0];
				index  = 0;
				second = nums[1];
			}
			for(int i = 2; i < nums.size(); i++) {
				if(nums[i] > max) {
					second = max;
					index  = i;
					max    = nums[i];
				} else if(nums[i] > second) {
					second = nums[i];
				}
			}
			if(max >= 2 * second) {
				return index;
			}
			return -1;
		}
	}// namespace largest_number_at_least_twice_of_others

	namespace find_k_pairs_with_smallest_sums {
		vector<vector<int>> Solution::kSmallestPairs(vector<int> &nums1, vector<int> &nums2, int k) {
			auto ans = vector<vector<int>>();
			auto pq  = priority_queue<pair>();
			for(int i = 0; i < k && i < nums1.size(); i++) {
				for(int j = 0; j < k && j < nums2.size(); j++) {
					pq.push(pair(nums1[i], nums2[j]));
				}
			}
			for(int i = 0; i < k && i < nums1.size() * nums2.size(); i++) {
				const pair p = pq.top();
				pq.pop();
				auto to_add = vector<int>();
				to_add.resize(2);
				to_add[0] = p.u;
				to_add[1] = p.v;
				ans.push_back(to_add);
			}
			return ans;
		}

		bool pair::operator<(const pair &p) const { return this->u + this->v > p.u + p.v; }
	}// namespace find_k_pairs_with_smallest_sums

	namespace permutations {
		vector<vector<int>> Solution::permute(vector<int> &nums) {
			auto ans = vector<vector<int>>();
			if(nums.size() == 1) {
				auto next_ans = vector<int>();
				next_ans.push_back(nums[0]);
				ans.push_back(next_ans);
				return ans;
			}
			for(auto num: nums) {
				auto next = vector(nums);
				next.erase(find(next.begin(), next.end(), num));
				auto next_permutations = permute(next);
				auto new_ans           = vector<int>();
				new_ans.push_back(num);
				for(auto next_permutation: next_permutations) {
					auto next_ans = vector(new_ans);
					next_ans.insert(next_ans.end(), next_permutation.begin(), next_permutation.end());
					ans.push_back(next_ans);
				}
			}
			return ans;
		}
	}// namespace permutations

	namespace calculate_money_in_leetcode_bank {
		int Solution::totalMoney(int n) {
			int sum = n / 7 * (28 + 7 * (n / 7 + 3)) / 2;
			for(int i = 0; i < n % 7; i++) {
				sum += n / 7 + 1 + i;
			}
			return sum;
		}
	}// namespace calculate_money_in_leetcode_bank

	namespace linked_list_random_node {
		int Solution::getRandom() const {
			int i   = 1;
			int ans = 0;
			for(const auto *node = head; node != nullptr; node = node->next, i++) {
				if(rand() % i == 0) {
					// 1/i 的概率选中（替换为答案）
					ans = node->val;
				}
			}
			return ans;
		}
	}// namespace linked_list_random_node

	namespace divide_a_string_into_groups_of_size_k {
		vector<string> Solution::divideString(const string &s, int k, char fill) {
			auto ans = vector<string>();
			int i    = 0;
			for(; i * k + k < s.length(); i++) {
				ans.push_back(s.substr(i * k, k));
			}
			if(i * k != s.length()) {
				string last = s.substr(i * k);
				for(int j = last.length(); j < k; j++) {
					last += fill;
				}
				ans.push_back(last);
			}
			return ans;
		}
	}// namespace divide_a_string_into_groups_of_size_k

	namespace minimum_moves_to_reach_target_score {
		int Solution::minMoves(int target, int maxDoubles) {
			int count = 0;
			while(target != 1) {
				if(maxDoubles == 0) {
					return count + target - 1;
				}
				if(target % 2 == 0 && maxDoubles != 0) {
					target /= 2;
					maxDoubles--;
				} else {
					target--;
				}
				count++;
			}
			return count;
		}
	}// namespace minimum_moves_to_reach_target_score

	namespace solving_questions_with_brainpower {
		long long Solution::mostPoints(vector<vector<int>> &questions) {
			vector<long long> f(questions.size() + 1);
			for(int i = questions.size() - 1; i >= 0; --i) {
				auto &q     = questions[i];
				const int j = i + q[1] + 1;
				f[i]        = max(f[i + 1], q[0] + (j < questions.size() ? f[j] : 0));
			}
			return f[0];
		}
	}// namespace solving_questions_with_brainpower

	namespace maximum_running_time_of_n_computers {
		long long Solution::maxRunTime(int n, vector<int> &batteries) {
			auto check = [&](long long t) {
				long long sum = 0;
				for(const int i: batteries) {
					sum += min(t, static_cast<long long>(i));
				}
				return sum / t >= n;
			};

			long long l = 1;
			long long r = 1e16;
			while(l < r) {
				const long long m = (l + r) / 2;
				if(check(m)) {
					l = m + 1;
				} else {
					r = m;
				}
			}
			return l - 1;
		}
	}// namespace maximum_running_time_of_n_computers

	namespace coun_vowels_permutation {
		int Solution::countVowelPermutation(int n) {
			/// \brief a-0 e-1 i-2 o-3 u-4
			unsigned long long end[5] = {1, 1, 1, 1, 1};
			for(int _i = 1; _i < n; _i++) {
				const unsigned long long a = (end[1] + end[2] + end[4]) % 1000000007;
				const unsigned long long e = (end[0] + end[2]) % 1000000007;
				const unsigned long long i = (end[1] + end[3]) % 1000000007;
				const unsigned long long o = end[2] % 1000000007;
				const unsigned long long u = (end[2] + end[3]) % 1000000007;
				end[0]                     = a;
				end[1]                     = e;
				end[2]                     = i;
				end[3]                     = o;
				end[4]                     = u;
			}
			return (end[0] + end[1] + end[2] + end[3] + end[4]) % 1000000007;
		}
	}// namespace coun_vowels_permutation

	namespace minimum_time_difference {
		int Solution::findMinDifference(vector<string> &timePoints) {
			auto vec = vector<int>();
			for(string timePoint: timePoints) {
				vec.push_back(((timePoint[0] - '0') * 10 + (timePoint[1] - '0')) * 60 + (timePoint[3] - '0') * 10 + (timePoint[4] - '0'));
			}
			sort(vec.begin(), vec.end());
			int minimum = INT_MAX;
			for(int i = 0; i + 1 < vec.size(); i++) {
				minimum = min(minimum, vec[i + 1] - vec[i]);
			}
			minimum = min(minimum, vec[0] + 24 * 60 - vec[vec.size() - 1]);
			return minimum;
		}
	}// namespace minimum_time_difference

	namespace contains_duplicate_ii {
		bool Solution::containsNearbyDuplicate(vector<int> &nums, int k) {
			auto um = unordered_map<int, vector<int>>();
			for(int i = 0; i < nums.size(); i++) {
				if(!um.contains(nums[i])) {
					um.insert(pair(nums[i], vector<int>()));
				}
				auto pos = lower_bound(um[nums[i]].begin(), um[nums[i]].end(), i);
				if(pos != um[nums[i]].end() && abs(*pos - i) <= k || pos != um[nums[i]].begin() && abs(*(pos - 1) - i) <= k) {
					return true;
				}
				um[nums[i]].insert(pos, i);
			}
			for(auto i: um) {
				sort(i.second.begin(), i.second.end());
			}
			return false;
		}
	}// namespace contains_duplicate_ii

	namespace stone_game_ix {
		bool Solution::stoneGameIX(vector<int> &stones) {
			unsigned int remove    = 0;
			unsigned int counts[3] = {0, 0, 0};
			for(auto stone: stones) {
				stone %= 3;
				counts[stone]++;
			}
			if(stones.size() == 1) {
				return false;
			}
			if(counts[1] + counts[2] == 2) {
				if(counts[1] == 2 || counts[2] == 2) {
					return false;
				}
			}
			if(counts[1] == 0 && counts[2] == 0) {
				return false;
			}
			if(abs(static_cast<int>(counts[1]) - static_cast<int>(counts[2])) <= 2) {
				return counts[0] % 2 == 0;
			}
			return true;
		}
	}// namespace stone_game_ix

	namespace jump_game_iv {
		int Solution::minJumps(vector<int> &arr) {
			if(arr.size() == 1) {
				return 0;
			}
			auto pq    = queue<pair<int, int>>();//<下标,step>
			auto *flag = new bool[arr.size()];
			memset(flag, 0, arr.size() * sizeof(bool));
			auto um = unordered_map<int, vector<int>>();//<值,下标>
			for(int i = 0; i < arr.size(); i++) {
				if(!um.contains(arr[i])) {
					auto vec = vector<int>();
					vec.push_back(i);
					um.insert(pair(arr[i], vec));
				} else {
					um[arr[i]].push_back(i);
				}
			}
			pq.push(pair(0, 0));
			flag[0] = true;
			while(!pq.empty()) {
				auto [current_i, current_count] = pq.front();
				pq.pop();
				if(current_i == arr.size() - 1) {
					return current_count;
				}
				if(um.contains(arr[current_i])) {
					for(auto i: um[arr[current_i]]) {
						if(i != current_i && !flag[i]) {
							pq.push(pair(i, current_count + 1));
							flag[i] = true;
						}
					}
				}
				um.erase(arr[current_i]);
				if(current_i - 1 >= 0 && !flag[current_i - 1]) {
					pq.push(pair(current_i - 1, current_count + 1));
					flag[current_i - 1] = true;
				}
				if(current_i + 1 < arr.size() && !flag[current_i + 1]) {
					pq.push(pair(current_i + 1, current_count + 1));
					flag[current_i + 1] = true;
				}
			}
			delete[] flag;
			return 0;
		}
	}// namespace jump_game_iv

	namespace remove_palindromic_subsequences {
		int Solution::removePalindromeSub(string s) {
			for(int i = 0, j = s.length() - 1; i < j; i++, j--) {
				if(s[i] != s[j]) {
					return 2;
				}
			}
			return 1;
		}
	}// namespace remove_palindromic_subsequences

	namespace UhWRSj {
		string Solution::replaceWords(vector<string> &dictionary, const string &sentence) {
			auto oss         = ostringstream();
			auto *const nstr = new char[sentence.length() + 1];
			auto tn          = TrieNode();
			for(const auto &root: dictionary) {
				tn.insert(root);
			}
			strcpy(nstr, sentence.c_str());
			char *word = strtok(nstr, " ");
			while(word != nullptr) {
				oss << tn.get_prefix("", string(word)) << " ";
				word = strtok(nullptr, " ");
			}
			const string ans = oss.str();
			delete[] nstr;
			return ans.substr(0, ans.length() - 1);
		}

		void TrieNode::insert(const string &str) {
			if(str.empty()) {
				this->endroot = true;
				return;
			}
			if(this->next[str[0] - 'a'] == nullptr) {
				this->next[str[0] - 'a'] = new TrieNode(str[0]);
			}
			this->next[str[0] - 'a']->insert(str.substr(1));
		}

		string TrieNode::get_prefix(string root, const string &str) const {
			if(this->endroot || str.empty()) {
				return root;
			}
			if(this->next[str[0] - 'a'] == nullptr) {
				return root + str;
			}
			return this->next[str[0] - 'a']->get_prefix(root + str[0], str.substr(1));
		}
	}// namespace UhWRSj

	namespace minimum_cost_of_buying_candies_with_discount {
		int Solution::minimumCost(vector<int> &cost) {
			if(cost.size() == 1) {
				return cost[0];
			}
			if(cost.size() == 2) {
				return cost[0] + cost[1];
			}
			int count = 0;
			sort(cost.rbegin(), cost.rend());
			for(int i = 0; i < cost.size(); i++) {
				if(i % 3 != 2) {
					count += cost[i];
				}
			}
			return count;
		}
	}// namespace minimum_cost_of_buying_candies_with_discount

	namespace count_the_hidden_sequences {
		int Solution::numberOfArrays(vector<int> &differences, int lower, int upper) {
			long long current = 0;
			long long maximum = 0;
			long long minimum = 0;
			for(const auto difference: differences) {
				current += difference;
				maximum = max(maximum, current);
				minimum = min(minimum, current);
			}
			return max(static_cast<long long>(0), upper - lower - (maximum - minimum) + 1);
		}
	}// namespace count_the_hidden_sequences

	namespace k_highest_ranked_items_within_a_price_range {
		vector<vector<int>> Solution::highestRankedKItems(vector<vector<int>> &grid, vector<int> &pricing, vector<int> &start, int k) {
			const auto m    = grid.size();
			const auto n    = grid[0].size();
			auto ans        = vector<vector<int>>();
			const auto low  = pricing[0];
			const auto high = pricing[1];
			const auto row  = start[0];
			const auto col  = start[1];
			auto pq         = priority_queue<item>();
			pq.push(item(0, grid[row][col], row, col));
			grid[row][col] = 0;
			while(pq.empty() && k != 0) {
				auto current = pq.top();
				pq.pop();
				if(current.price != 1 && current.price >= low && current.price <= high) {
					k--;
					auto vec = vector<int>();
					vec.push_back(current.row);
					vec.push_back(current.col);
					ans.push_back(vec);
				}
				pair<int, int> nexts[4] = {pair(current.row + 1, current.col),
				                           pair(current.row - 1, current.col),
				                           pair(current.row, current.col + 1),
				                           pair(current.row, current.col - 1)};
				for(const pair<int, int> next: nexts) {
					if(0 <= next.first && next.first < m && 0 <= next.second && next.second < n && grid[next.first][next.second] != 0) {
						pq.push(item(current.distance + 1, grid[next.first][next.second], next.first, next.second));
						grid[next.first][next.second] = 0;
					}
				}
			}
			return ans;
		}

		bool item::operator<(const item &i) const {
			if(this->distance != i.distance) {
				return this->distance > i.distance;
			}
			if(this->price != i.price) {
				return this->price > i.price;
			}
			if(this->row != i.row) {
				return this->row > i.row;
			}
			return this->col > i.col;
		}
	}// namespace k_highest_ranked_items_within_a_price_range

	namespace number_of_ways_to_divide_a_long_corridor {
		int Solution::numberOfWays(string corridor) {
			unsigned int s_count = 0;
			auto p               = vector<unsigned int>();
			for(const char ch: corridor) {
				if(ch == 'S') {
					s_count++;
				}
			}
			if(s_count == 0 || s_count % 2 != 0) {
				return 0;
			}
			if(s_count == 2) {
				return 1;
			}
			unsigned int start = 0;
			unsigned int end   = corridor.length() - 1;
			for(; start < end; start++) {
				if(corridor[start] == 'S') {
					break;
				}
			}
			for(; end > start; end--) {
				if(corridor[end] == 'S') {
					break;
				}
			}
			s_count              = 1;
			unsigned int p_count = 0;
			bool flag            = false;//是否在边界
			for(unsigned int i = start + 1; i <= end; i++) {
				if(corridor[i] == 'S') {
					s_count++;
				} else {
					if(s_count == 0) {
						p_count++;
					}
				}
				s_count %= 2;
				if(s_count == 0) {
					flag = true;
				} else if(s_count == 1) {
					if(flag) {
						p.push_back(p_count + 1);
						p_count = 0;
					}
					flag = false;
				}
			}
			unsigned long long ans = 1;
			for(const auto i: p) {
				ans *= i;
				ans %= 1000000007;
			}
			return ans;
		}
	}// namespace number_of_ways_to_divide_a_long_corridor

	namespace count_elements_with_strictly_smaller_and_greater_elements {
		int Solution::countElements(vector<int> &nums) {
			int maximum = nums[0];
			int minimum = nums[0];
			for(auto num: nums) {
				maximum = max(maximum, num);
				minimum = min(minimum, num);
			}
			unsigned int count = 0;
			for(const auto num: nums) {
				if(maximum != num && minimum != num) {
					count++;
				}
			}
			return count;
		}
	}// namespace count_elements_with_strictly_smaller_and_greater_elements

	namespace rearrange_array_elements_by_sign {
		vector<int> Solution::rearrangeArray(vector<int> &nums) {
			const auto size = nums.size();
			auto ans        = vector<int>();
			auto positive   = vector<int>();
			auto negative   = vector<int>();
			for(auto num: nums) {
				if(num > 0) {
					positive.push_back(num);
				} else {
					negative.push_back(num);
				}
			}
			for(int i = 0; i < size / 2; i++) {
				ans.push_back(positive[i]);
				ans.push_back(negative[i]);
			}
			return ans;
		}
	}// namespace rearrange_array_elements_by_sign

	namespace find_all_lonely_numbers_in_the_array {
		vector<int> Solution::findLonely(vector<int> &nums) {
			if(nums.size() == 1) {
				return nums;
			}
			sort(nums.begin(), nums.end());
			auto ans = vector<int>();
			if(nums[1] - nums[0] > 1) {
				ans.push_back(nums[0]);
			}
			if(nums[nums.size() - 1] - nums[nums.size() - 2] > 1) {
				ans.push_back(nums[nums.size() - 1]);
			}
			for(int i = 1; i < nums.size() - 1; i++) {
				if(nums[i] - nums[i - 1] > 1 && nums[i + 1] - nums[i] > 1) {
					ans.push_back(nums[i]);
				}
			}
			return ans;
		}
	}// namespace find_all_lonely_numbers_in_the_array

	namespace maximum_good_people_based_on_statements {
		int Solution::maximumGood(vector<vector<int>> &statements) {
			int maximum = 0;
			auto dup    = unordered_map<int, bool>();
			for(int i = 0; i < statements.size(); i++) {
				if(dup[i]) {
					continue;
				}
				const auto um = unordered_map<int, bool>();
				auto que      = queue<msg>();
				que.push(msg(i, true));
				auto ans = dfs(statements, um, que);
				maximum  = max(maximum, ans.first);
				for(auto it: ans.second) {
					if(it.second) {
						dup.insert(it);
					}
				}
			}
			return maximum;
		}

		pair<int, unordered_map<int, bool>> Solution::dfs(vector<vector<int>> &statements, unordered_map<int, bool> um, queue<msg> que) {
			int maximum     = 0;
			bool contradict = false;
			while(!que.empty()) {
				auto current = que.front();
				que.pop();
				if(um.contains(current.person)) {
					//已经存在
					if(um[current.person] != current.good) {
						//矛盾
						return pair<int, unordered_map<int, bool>>(0, {});
					}
				} else {
					um.insert(pair(current.person, current.good));
				}
				if(current.good) {
					//是好人
					for(int j = 0; j < statements.size(); j++) {
						if(statements[current.person][j] != 2 && j != current.person) {
							auto nmsg = msg(j, statements[current.person][j] == 1);
							if(um.contains(nmsg.person)) {
								//已经有了
								if(um[nmsg.person] != nmsg.good) {
									//矛盾
									contradict = true;
									return pair<int, unordered_map<int, bool>>(0, {});
								}
							} else {
								//还没有
								que.push(nmsg);
							}
						}
					}
				}
			}
			if(!contradict) {
				//不矛盾
				auto dup = unordered_map<int, bool>();
				for(int i = 0; i < statements.size(); i++) {
					if(dup[i]) {
						continue;
					}
					if(!um.contains(i)) {
						bool all2 = true;
						for(auto v: statements[i]) {
							if(v != 2) {
								all2 = false;
							}
						}
						if(all2) {
							um.insert(pair(i, true));
							continue;
						}
						auto nque = queue<msg>();
						nque.push(msg(i, true));
						auto ans = dfs(statements, um, nque);
						maximum  = max(maximum, ans.first);
						for(auto it: ans.second) {
							if(it.second) {
								dup.insert(it);
							}
						}
					}
				}

				int good_count = 0;
				for(auto i: um) {
					if(i.second) {
						good_count++;
					}
				}
				maximum = max(maximum, good_count);
			}
			return pair(maximum, um);
		}
	}// namespace maximum_good_people_based_on_statements

	namespace stock_price_fluctuation {
		StockPrice::StockPrice() {
			ms = multiset<int>();
			m  = map<int, int>();
		}

		void StockPrice::update(int timestamp, int price) {
			if(!m.contains(timestamp)) {
				m.insert(pair(timestamp, price));
			} else {
				ms.erase(ms.find(m[timestamp]));
				m[timestamp] = price;
			}
			ms.insert(price);
		}

		int StockPrice::current() const { return (*m.rbegin()).second; }

		int StockPrice::maximum() const { return *ms.rbegin(); }

		int StockPrice::minimum() const { return *ms.begin(); }
	}// namespace stock_price_fluctuation

	namespace second_minimum_time_to_reach_destination {
		int Solution::secondMinimum(int n, vector<vector<int>> &edges, int time, int change) {
			auto record = unordered_map<int, vector<int>>();
			for(int i = 1; i <= n; i++) {
				record.insert(pair(i, vector<int>()));
			}
			auto um = unordered_map<int, unordered_set<int>>();
			for(auto edge: edges) {
				if(!um.contains(edge[0])) {
					auto us = unordered_set<int>();
					us.insert(edge[1]);
					um.insert(pair(edge[0], us));
				} else {
					um[edge[0]].insert(edge[1]);
				}
				if(!um.contains(edge[1])) {
					auto us = unordered_set<int>();
					us.insert(edge[0]);
					um.insert(pair(edge[1], us));
				} else {
					um[edge[1]].insert(edge[0]);
				}
			}
			auto pq = priority_queue<status>();
			pq.push(status(1, 0));
			bool flag = false;//已经到达一次终点
			int prev  = 0;
			while(!pq.empty()) {
				status current = pq.top();
				pq.pop();
				if(current.position == n) {
					if(!flag) {
						flag = true;
						prev = current.time;
					} else {
						if(current.time != prev) {
							return current.time;
						}
					}
				}

				if(record[current.position].empty() || record[current.position].size() == 1 && current.time != *record[current.position].rbegin()) {
					//可以继续
					record[current.position].push_back(current.time);
				} else {
					continue;
				}

				for(int next: um[current.position]) {
					int next_time;
					if(current.time / change % 2 == 1) {
						//当前为红灯
						next_time = (current.time / change + 1) * change + time;
					} else {
						next_time = current.time + time;
					}
					auto next_status = status(next, next_time);
					if(record[next_status.position].empty() || record[next_status.position].size() == 1 && next_status.time != *record[next_status.position].rbegin()) {
						//可以继续
						pq.push(next_status);
					}
				}
			}
			return 0;
		}

		bool status::operator<(const status &s) const { return this->time > s.time; }
	}// namespace second_minimum_time_to_reach_destination

	namespace count_of_matches_in_tournament {
		int Solution::numberOfMatches(int n) { return n - 1; }
	}// namespace count_of_matches_in_tournament

	namespace detect_squares {
		DetectSquares::DetectSquares() { ms = multiset<pair<int, int>>(); }

		void DetectSquares::add(vector<int> point) { ms.insert(pair(point[0], point[1])); }

		int DetectSquares::count(vector<int> point) const {
			int count = 0;
			for(auto p: ms) {
				if(p.first != point[0] && p.second != point[1] && abs(p.first - point[0]) == abs(p.second - point[1])) {
					count += ms.count(pair(p.first, point[1])) * ms.count(pair(point[0], p.second));
				}
			}
			return count;
		}
	}// namespace detect_squares

	namespace number_of_valid_words_in_a_sentence {
		int Solution::countValidWords(const string &sentence) {
			auto *str = new char[sentence.length() + 1];
			strcpy(str, sentence.c_str());
			int count = 0;///< 有效单词数
			for(const char *token = strtok(str, " "); token != nullptr; token = strtok(nullptr, " ")) {
				bool is_valid = true; ///< 是否是有效单词
				bool hyphen   = false;///< 是否已经存在连接符'-'
				for(int i = 0; token[i] != '\0'; i++) {
					const char ch = token[i];///当前字符
					if(ch == '-') {
						//当前字符是连接符'-'
						if(hyphen) {
							//已经存在过连接符'-'
							is_valid = false;
							break;
						}
						hyphen = true;
						if(i == 0 || token[i + 1] == '\0') {
							//是否在字符串的开头或结尾
							is_valid = false;
							break;
						}
						if(isalpha(token[i - 1]) == 0 || isalpha(token[i + 1]) == 0) {
							//前后是否是字母
							is_valid = false;
							break;
						}
					} else if(token[i + 1] != '\0' && isalpha(ch) == 0) {
						//不是最后一个字符是否不是字母
						is_valid = false;
						break;
					} else if(isdigit(ch) != 0) {
						//是否是数字
						is_valid = false;
						break;
					}
				}
				if(is_valid) {
					count++;
				}
			}
			delete[] str;
			return count;
		}
	}// namespace number_of_valid_words_in_a_sentence

	namespace the_number_of_weak_characters_in_the_game {
		int Solution::numberOfWeakCharacters(vector<vector<int>> &properties) {
			//按攻击值从大到小排序。攻击值相同时，按照其防御值从小到大排序
			sort(properties.begin(), properties.end(), [](const vector<int> &a, const vector<int> &b) { return a[0] == b[0] ? a[1] < b[1] : a[0] > b[0]; });

			int maxDef = 0;///< 最大防御值
			int count  = 0;
			for(const auto &p: properties) {
				if(p[1] < maxDef) {
					count++;
				} else {
					maxDef = p[1];
				}
			}
			return count;
		}
	}// namespace the_number_of_weak_characters_in_the_game

	namespace pattern_matching_lcci {
		bool Solution::patternMatching(const string &pattern, const string &value) {
			int a_count = 0;
			int b_count = 0;
			for(const char ch: pattern) {
				if(ch == 'a') {
					a_count++;
				} else {
					b_count++;
				}
			}
			if(a_count == 0 || b_count == 0) {
				int size  = 0;
				int count = 0;
				if(b_count == 0) {
					if(value.length() % a_count != 0) {
						return false;
					}
					size  = value.length() / a_count;
					count = a_count;
				} else {
					if(value.length() % b_count != 0) {
						return false;
					}
					size  = value.length() / b_count;
					count = b_count;
				}
				const string str = value.substr(0, size);
				for(int i = 0; i < count; i++) {
					auto s = value.substr(i * size, size);
					if(s != str) {
						return false;
					}
				}
				return true;
			}
			for(int a_size = 0; a_size <= value.length() / a_count; a_size++) {
				string a;
				string b;
				if((value.length() - a_size * a_count) % b_count == 0) {
					const int b_size   = (value.length() - a_size * a_count) / b_count;
					string value_local = value;
					for(const char ch: pattern) {
						if(ch == 'a') {
							string a_local = value_local.substr(0, a_size);
							if(a.empty()) {
								a = a_local;
							} else if(a_local != a) {
								goto next_loop;
							}
							value_local = value_local.substr(a_size);
						} else {
							string b_local = value_local.substr(0, b_size);
							if(b.empty()) {
								b = b_local;
							} else if(b_local != b) {
								goto next_loop;
							}
							value_local = value_local.substr(b_size);
						}
					}
					if(a == b) {
						goto next_loop;
					}
					return true;
				}
			next_loop:;
			}
			return false;
		}
	}// namespace pattern_matching_lcci

	namespace map_of_highest_peak {
		vector<vector<int>> Solution::highestPeak(vector<vector<int>> &isWater) {
			const int m    = isWater.size();
			const int n    = isWater[0].size();
			auto *occupied = new bool *[m];
			for(int i = 0; i < m; i++) {
				occupied[i] = new bool[n];
				memset(occupied[i], 0, n * sizeof(bool));
			}
			auto que = queue<pair<int, int>>();
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					if(isWater[i][j] == 1) {
						que.push(pair(i, j));
						isWater[i][j]  = 0;
						occupied[i][j] = true;
					} else {
						isWater[i][j] = 1;
					}
				}
			}
			while(!que.empty()) {
				pair<int, int> current = que.front();
				que.pop();
				pair<int, int> nexts[4] = {pair(current.first + 1, current.second),
				                           pair(current.first - 1, current.second),
				                           pair(current.first, current.second + 1),
				                           pair(current.first, current.second - 1)};
				for(auto next: nexts) {
					if(0 <= next.first && next.first < m && 0 <= next.second && next.second < n && !occupied[next.first][next.second]) {
						isWater[next.first][next.second]  = isWater[current.first][current.second] + 1;
						occupied[next.first][next.second] = true;
						que.push(next);
					}
				}
			}
			delete[] occupied;
			return isWater;
		}
	}// namespace map_of_highest_peak

	namespace uncommon_words_from_two_sentences {
		vector<string> Solution::uncommonFromSentences(const string &s1, const string &s2) {
			auto ans           = vector<string>();
			auto um            = unordered_map<string, unsigned int>();
			auto *const s1_str = new char[s1.length() + 1];
			auto *const s2_str = new char[s2.length() + 1];
			strcpy(s1_str, s1.c_str());
			strcpy(s2_str, s2.c_str());
			for(char *word = strtok(s1_str, " "); word != nullptr; word = strtok(nullptr, " ")) {
				auto word_str = string(word);
				if(!um.contains(word_str)) {
					um.insert(pair(word_str, 1));
				} else {
					um[word_str]++;
				}
			}
			for(char *word = strtok(s2_str, " "); word != nullptr; word = strtok(nullptr, " ")) {
				auto word_str = string(word);
				if(!um.contains(word_str)) {
					um.insert(pair(word_str, 1));
				} else {
					um[word_str]++;
				}
			}
			for(const auto &p: um) {
				if(p.second == 1) {
					ans.push_back(p.first);
				}
			}
			delete[] s1_str;
			delete[] s2_str;
			return ans;
		}
	}// namespace uncommon_words_from_two_sentences

	namespace keep_multiplying_found_values_by_two {
		int Solution::findFinalValue(vector<int> &nums, int original) {
		restart:;
			for(const auto num: nums) {
				if(num == original) {
					original *= 2;
					goto restart;
				}
			}
			return original;
		}
	}// namespace keep_multiplying_found_values_by_two

	namespace all_divisions_with_the_highest_score_of_a_binary_array {
		vector<int> Solution::maxScoreIndices(vector<int> &nums) {
			const auto n       = nums.size();
			auto left_0_count  = vector<int>();
			auto right_1_count = vector<int>();
			left_0_count.push_back(0);
			right_1_count.push_back(0);
			int count = 0;
			for(int i = 0; i < n; i++) {
				if(nums[i] == 0) {
					count++;
				}
				left_0_count.push_back(count);
			}
			count = 0;
			for(int i = n - 1; i >= 0; i--) {
				if(nums[i] == 1) {
					count++;
				}
				right_1_count.push_back(count);
			}
			right_1_count = vector(right_1_count.rbegin(), right_1_count.rend());
			int maximum   = 0;
			for(int i = 0; i <= n; i++) {
				maximum = max(maximum, left_0_count[i] + right_1_count[i]);
			}
			auto ans = vector<int>();
			for(int i = 0; i <= n; i++) {
				if(maximum == left_0_count[i] + right_1_count[i]) {
					ans.push_back(i);
				}
			}
			return ans;
		}
	}// namespace all_divisions_with_the_highest_score_of_a_binary_array

	namespace find_substring_with_given_hash_value {
		string Solution::subStrHash(string s, int power, int modulo, int k, int hashValue) {
			power %= modulo;
			auto *const pn = new int[k];
			pn[0]          = 1;
			for(int i = 1; i < k; i++) {
				pn[i] = static_cast<unsigned long long>(pn[i - 1]) * static_cast<unsigned long long>(power) % modulo;
			}

			for(int i = 0; i < s.length(); i++) {
				unsigned long long hash = 0;
				for(int j = 0; j < k; j++) {
					hash += static_cast<unsigned long long>((s[i + j] - 'a' + 1) % modulo) * pn[j];
					hash %= modulo;
				}
				if(hash == hashValue) {
					return s.substr(i, k);
				}
			}
			delete[] pn;
			return "";
		}
	}// namespace find_substring_with_given_hash_value

	namespace groups_of_strings {
		vector<int> Solution::groupStrings(vector<string> &words) {
			auto ans  = vector<int>();
			auto nums = vector<unsigned int>();
			for(const auto &word: words) {
				auto num = compress(word);
				nums.push_back(num);
				insert(num);
			}
			for(const auto num: nums) {
				for(int i = 0; i < 26; i++) {
					auto next = num ^ 1 << i;//添加或删除字符 i
					if(parent.contains(next)) {
						to_union(num, next);
					}
					if((num >> i & 1) == 1) {
						//存在字符i
						for(int j = 0; j < 26; j++) {
							if((num >> j & 1) == 0) {
								//不存在字符j
								auto next = num ^ 1 << i | 1 << j;
								if(parent.contains(next)) {
									to_union(num, num ^ 1 << i | 1 << j);// 替换字符 i 为 j
								}
							}
						}
					}
				}
			}
			ans.push_back(groups);
			ans.push_back(max_size);
			return ans;
		}

		unsigned int Solution::compress(const string &word) {
			unsigned int ans = 0;
			for(const char ch: word) {
				ans |= 1 << ch - 'a';
			}
			return ans;
		}

		void Solution::insert(unsigned int num) {
			parent.insert(pair(num, num));
			rank.insert(pair(num, 0));
			if(!size.contains(num)) {
				size.insert(pair(num, 1));
				groups++;
			} else {
				size[num]++;
				max_size = size[num];
			}
		}

		unsigned int Solution::find(unsigned int x) { return x == parent[x] ? x : parent[x] = find(parent[x]); }

		void Solution::to_union(unsigned int x1, unsigned int x2) {
			const int f1 = find(x1);
			const int f2 = find(x2);
			if(f1 == f2) {
				return;
			}
			groups--;
			if(rank[f1] > rank[f2]) {
				parent[f2] = f1;
				size[f1] += size[f2];
				max_size = max(max_size, size[f1]);
			} else {
				parent[f1] = f2;
				size[f2] += size[f1];
				max_size = max(max_size, size[f2]);
				if(rank[f1] == rank[f2]) {
					++rank[f2];
				}
			}
		}
	}// namespace groups_of_strings

	namespace number_of_steps_to_reduce_a_number_to_zero {
		int Solution::numberOfSteps(int num) {
			if(num == 0) {
				return 0;
			}
			int count = 0;
			while(num != 0) {
				if((num & 1) == 0) {
					count += 1;
				} else {
					count += 2;
				}
				num >>= 1;
			}
			return count - 1;
		}
	}// namespace number_of_steps_to_reduce_a_number_to_zero

	namespace longest_nice_substring {
		string Solution::longestNiceSubstring(const string &s) {
			auto [max_start, max_len] = dfs(s, 0, s.length() - 1);
			if(max_len == 0) {
				return "";
			}
			return s.substr(max_start, max_len);
		}

		pair<int, int> Solution::dfs(string s, int start, int end) {
			if(start == end) {
				return {start, 0};
			}
			int lower     = 0;
			int upper     = 0;
			int max_start = 0;
			int max_len   = 0;
			for(int i = start; i <= end; i++) {
				const char ch = s[i];
				if(islower(ch) != 0) {
					lower |= 1 << ch - 'a';
				} else {
					//isupper
					upper |= 1 << ch - 'A';
				}
			}
			if(lower == upper) {
				//是美好字符串
				return {start, end - start + 1};
			}
			//不是美好字符串
			const int not_nice = lower ^ upper;//无法构成美好字符串的字符
			int i              = start;
			while(i <= end) {
				if((not_nice >> tolower(s[i]) - 'a' & 1) == 1) {
					//在not_nice中
					i++;
					continue;
				}
				int j = i + 1;
				while(j <= end && (not_nice >> tolower(s[j]) - 'a' & 1) != 1) {
					j++;
				}
				auto [next_start, next_len] = dfs(s, i, j - 1);
				if(max_len < next_len) {
					max_len   = next_len;
					max_start = next_start;
				}
				i = j;
			}
			return {max_start, max_len};
		}
	}// namespace longest_nice_substring

	namespace reverse_prefix_of_word {
		string Solution::reversePrefix(string word, char ch) {
			int i = 0;
			for(; i < word.length(); i++) {
				if(ch == word[i]) {
					break;
				}
			}
			if(i == word.length()) {
				return word;
			}
			string prefix       = word.substr(0, i + 1);
			const string suffix = word.substr(i + 1);
			const auto xiferp   = string(prefix.rbegin(), prefix.rend());
			return xiferp + suffix;
		}
	}// namespace reverse_prefix_of_word

	namespace find_the_minimum_number_of_fibonacci_numbers_whose_sum_is_k {
		int Solution::findMinFibonacciNumbers(int k) {
			auto fibb = set<int, greater<>>();
			fibb.insert(1);
			int prev_1 = 1;
			int next   = 2;
			while(next <= k) {
				fibb.insert(next);
				const int prev_2 = prev_1;
				prev_1           = next;
				next             = prev_1 + prev_2;
			}
			return find_min(fibb, k, fibb.begin());
		}

		int Solution::find_min(set<int, greater<>> &fibb, int k, set<int, greater<>>::iterator begin) {
			const auto i = lower_bound(begin, fibb.end(), k, greater<int>());
			if(k == *i) {
				return 1;
			}
			return 1 + find_min(fibb, k - *i, i);
		}
	}// namespace find_the_minimum_number_of_fibonacci_numbers_whose_sum_is_k

	namespace number_of_rectangles_that_can_form_the_largest_square {
		int Solution::countGoodRectangles(vector<vector<int>> &rectangles) {
			auto m = map<int, int>();
			for(auto rectangle: rectangles) {
				int k = min(rectangle[0], rectangle[1]);
				m[k]++;
			}
			return (*m.rbegin()).second;
		}
	}// namespace number_of_rectangles_that_can_form_the_largest_square

	namespace path_with_maximum_gold {
		int Solution::getMaximumGold(vector<vector<int>> &grid) {
			const int m = grid.size();
			const int n = grid[0].size();
			int ans     = 0;
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					if(grid[i][j] != 0) {
						auto *occupied = new bool *[m];
						for(int k = 0; k < m; k++) {
							occupied[k] = new bool[n];
							memset(occupied[k], 0, n * sizeof(bool));
						}
						occupied[i][j] = true;
						ans            = max(ans, get_sum(grid[i][j], i, j, m, n, grid, occupied));
						for(int k = 0; k < m; k++) {
							delete[] occupied[k];
						}
						delete[] occupied;
					}
				}
			}
			return ans;
		}

		int Solution::get_sum(int current, int x, int y, int m, int n, vector<vector<int>> &grid, bool **occupied) {
			pair<int, int> nexts[] = {make_pair(x + 1, y), make_pair(x - 1, y), make_pair(x, y + 1), make_pair(x, y - 1)};
			int maximum            = current;
			for(auto [next_x, next_y]: nexts) {
				if(0 <= next_x && next_x < m && 0 <= next_y && next_y < n && grid[next_x][next_y] != 0 && !occupied[next_x][next_y]) {
					auto *occupied_cpy = new bool *[m];
					for(int i = 0; i < m; i++) {
						occupied_cpy[i] = new bool[n];
						memcpy(occupied_cpy[i], occupied[i], n * sizeof(bool));
					}
					occupied_cpy[next_x][next_y] = true;
					maximum                      = max(maximum, get_sum(current + grid[next_x][next_y], next_x, next_y, m, n, grid, occupied_cpy));
					for(int i = 0; i < m; i++) {
						delete[] occupied_cpy[i];
					}
					delete[] occupied_cpy;
				}
			}
			return maximum;
		}
	}// namespace path_with_maximum_gold

	namespace minimum_sum_of_four_digit_number_after_splitting_digits {
		int Solution::minimumSum(int num) {
			auto oss = ostringstream();
			oss << num;
			const string str = oss.str();
			int nums[4];
			for(int i = 0; i < 4; i++) {
				nums[i] = str[i] - '0';
			}
			sort(nums, nums + 4);
			return nums[0] * 10 + nums[1] * 10 + nums[2] + nums[3];
		}
	}// namespace minimum_sum_of_four_digit_number_after_splitting_digits

	namespace partition_array_according_to_given_pivot {
		vector<int> Solution::pivotArray(vector<int> &nums, int pivot) {
			auto less    = vector<int>();
			auto equal   = vector<int>();
			auto greater = vector<int>();
			for(auto num: nums) {
				if(num < pivot) {
					less.push_back(num);
				} else if(num == pivot) {
					equal.push_back(num);
				} else {
					greater.push_back(num);
				}
			}
			less.insert(less.end(), equal.begin(), equal.end());
			less.insert(less.end(), greater.begin(), greater.end());
			return less;
		}
	}// namespace partition_array_according_to_given_pivot

	namespace minimum_cost_to_set_cooking_time {
		int Solution::minCostSetTime(int startAt, int moveCost, int pushCost, int targetSeconds) {
			int ans    = (moveCost + pushCost) * 4;
			int minute = targetSeconds / 60;
			int second = targetSeconds % 60;
			while(minute > 99) {
				minute -= 1;
				second += 60;
			}
			const int num[4] = {minute / 10, minute % 10, second / 10, second % 10};
			ans              = min(ans, get_cost(startAt, moveCost, pushCost, num));
			if(second + 60 < 100 && minute - 1 >= 0) {
				second += 60;
				minute -= 1;
				const int num[4] = {minute / 10, minute % 10, second / 10, second % 10};
				ans              = min(ans, get_cost(startAt, moveCost, pushCost, num));
			}
			return ans;
		}

		int Solution::get_cost(int startAt, int moveCost, int pushCost, const int num[4]) {
			int cost    = 0;
			int current = startAt;
			bool flag   = true;
			for(int i = 0; i < 4; i++) {
				if(num[i] == 0 && flag) {
					continue;
				}
				flag = false;
				if(num[i] != current) {
					cost += moveCost;
					current = num[i];
				}
				cost += pushCost;
			}
			return cost;
		}
	}// namespace minimum_cost_to_set_cooking_time

	namespace minimum_difference_in_sums_after_removal_of_elements {
		long long Solution::minimumDifference(vector<int> &nums) {
			const int n         = nums.size() / 3;
			auto *left_sum      = new long long[n];
			auto *right_sum     = new long long[n];
			long long left_min  = 0;
			long long right_max = 0;
			auto left_n         = priority_queue<int>();
			auto right_n        = priority_queue<int, vector<int>, greater<>>();
			for(int i = 0; i < n; i++) {
				left_n.push(nums[i]);
				left_min += nums[i];
			}
			for(int i = 3 * n - 1; i >= 2 * n; i--) {
				right_n.push(nums[i]);
				right_max += nums[i];
			}
			const long long left_min_preserve  = left_min;
			const long long right_max_preserve = right_max;
			left_sum[0]                        = left_min;
			right_sum[n - 1]                   = right_max;
			for(int i = n; i < 2 * n; i++) {
				if(nums[i] < left_n.top()) {
					left_min += nums[i] - left_n.top();
					left_n.pop();
					left_n.push(nums[i]);
				}
				left_sum[i - n] = left_min;
			}
			for(int i = 2 * n - 1; i >= n; i--) {
				if(nums[i] > right_n.top()) {
					right_max += nums[i] - right_n.top();
					right_n.pop();
					right_n.push(nums[i]);
				}
				right_sum[i - n] = right_max;
			}
			long long ans = left_min_preserve - right_sum[0];
			for(int i = 0; i < n - 1; i++) {
				ans = min(ans, left_sum[i] - right_sum[i + 1]);
			}
			ans = min(ans, left_sum[n - 1] - right_max_preserve);
			delete[] left_sum;
			delete[] right_sum;
			return ans;
		}
	}// namespace minimum_difference_in_sums_after_removal_of_elements

	namespace sum_of_unique_elements {
		int Solution::sumOfUnique(vector<int> &nums) {
			auto um = unordered_map<int, int>();
			for(auto num: nums) {
				um[num]++;
			}
			int ans = 0;
			for(auto [k, v]: um) {
				if(v == 1) {
					ans += k;
				}
			}
			return ans;
		}
	}// namespace sum_of_unique_elements

	namespace sort_even_and_odd_indices_independently {
		vector<int> Solution::sortEvenOdd(vector<int> &nums) {
			vector<int> even;///< 偶数
			vector<int> odd; ///< 奇数
			vector<int> ans;
			for(int i = 0; i < nums.size(); i++) {
				if(i % 2 == 0) {
					even.push_back(nums[i]);
				} else {
					odd.push_back(nums[i]);
				}
			}
			sort(even.begin(), even.end());
			sort(odd.begin(), odd.end(), greater<int>());
			for(int i = 0; i < odd.size(); i++) {
				ans.push_back(even[i]);
				ans.push_back(odd[i]);
			}
			if(even.size() > odd.size()) {
				ans.push_back(even.back());
			}
			return ans;
		}
	}// namespace sort_even_and_odd_indices_independently

	namespace smallest_value_of_the_rearranged_number {
		long long Solution::smallestNumber(long long num) {
			bool positive = num > 0;
			auto oss      = ostringstream();
			num           = abs(num);
			oss << num;
			vector<int> n;
			for(char ch: oss.str()) {
				n.push_back(ch - '0');
			}
			sort(n.begin(), n.end());
			vector<int> ans;
			if(positive) {
				for(auto i: n) {
					if(i != 0) {
						ans.push_back(i);
					}
				}
				for(auto i: n) {
					if(i == 0) {
						ans.insert(ans.begin() + 1, i);
					}
				}
			} else {
				for(int i = n.size() - 1; i >= 0; i--) {
					ans.push_back(n[i]);
				}
			}
			oss = ostringstream();
			if(!positive) {
				oss << '-';
			}
			for(auto i: ans) {
				oss << i;
			}
			auto iss = istringstream(oss.str());
			long long a;
			iss >> a;
			return a;
		}
	}// namespace smallest_value_of_the_rearranged_number

	namespace design_bitset {
		Bitset::Bitset(int size) {
			this->size = size;
			one1       = new set<unsigned int>();
			zero0      = new set<unsigned int>();
			for(int i = 0; i < size; i++) {
				zero0->insert(i);
			}
		}

		void Bitset::fix(int idx) const {
			zero0->erase(idx);
			one1->insert(idx);
		}

		void Bitset::unfix(int idx) const {
			zero0->insert(idx);
			one1->erase(idx);
		}

		void Bitset::flip() {
			auto *const tmp = one1;
			one1            = zero0;
			zero0           = tmp;
		}

		bool Bitset::all() const { return zero0->empty(); }

		bool Bitset::one() const { return !one1->empty(); }

		int Bitset::count() const { return one1->size(); }

		string Bitset::toString() const {
			auto oss = ostringstream();
			auto c1  = one1->begin();
			auto c0  = zero0->begin();
			for(int i = 0; i < size; i++) {
				if(c1 != one1->end() && *c1 == i) {
					oss << 1;
					++c1;
				} else if(c0 != zero0->end() && *c0 == i) {
					oss << 0;
					++c0;
				}
			}
			return oss.str();
		}
	}// namespace design_bitset

	namespace longest_happy_string {
		string Solution::longestDiverseString(int a, int b, int c) {
			auto oss   = ostringstream();
			int count  = 0;
			char prev  = '0';
			char ch[3] = {};
			sort(ch, a, b, c);
			while(a != 0 || b != 0 || c != 0) {
				if(!(count == 2 && prev == ch[2] && *get_p(ch[2], &a, &b, &c) > 0)) {
					oss << ch[2];
					(*get_p(ch[2], &a, &b, &c))--;
					if(prev == ch[2]) {
						count++;
					} else {
						prev  = ch[2];
						count = 1;
					}
				} else if(!(count == 2 && prev == ch[1]) && *get_p(ch[1], &a, &b, &c) > 0) {
					oss << ch[1];
					(*get_p(ch[1], &a, &b, &c))--;
					if(prev == ch[1]) {
						count++;
					} else {
						prev  = ch[1];
						count = 1;
					}
				} else if(!(count == 2 && prev == ch[0]) && *get_p(ch[0], &a, &b, &c) > 0) {
					oss << ch[0];
					(*get_p(ch[0], &a, &b, &c))--;
					if(prev == ch[0]) {
						count++;
					} else {
						prev  = ch[0];
						count = 1;
					}
				} else {
					return oss.str();
				}
				sort(ch, a, b, c);
			}
			return oss.str();
		}

		void Solution::sort(char *ch, int a, int b, int c) {
			int minimum = a;
			ch[0]       = 'a';
			int maximum = b;
			ch[2]       = 'b';
			if(minimum > b) {
				minimum = b;
				ch[0]   = 'b';
			}
			if(minimum > c) {
				minimum = c;
				ch[0]   = 'c';
			}
			if(maximum < a) {
				maximum = a;
				ch[2]   = 'a';
			}
			if(maximum < c) {
				maximum = c;
				ch[2]   = 'c';
			}
			ch[1] = 'a' + 'b' + 'c' - ch[0] - ch[2];
		}

		int *Solution::get_p(char ch, int *a, int *b, int *c) {
			switch(ch) {
				case 'a': return a;
				case 'b': return b;
				case 'c': return c;
				default: return nullptr;
			}
		}
	}// namespace longest_happy_string

	namespace grid_illumination {
		vector<int> Solution::gridIllumination(int n, vector<vector<int>> &lamps, vector<vector<int>> &queries) {
			auto ls        = unordered_set<pair<int, int>, pair_hash>();
			auto row       = unordered_map<int, int>();
			auto col       = unordered_map<int, int>();
			auto diag_down = unordered_map<int, int>();///< 从左上到右下的对角线
			auto diag_up   = unordered_map<int, int>();///< 从右上到左下的对角线
			for(auto lamp: lamps) {
				int x  = lamp[0];
				int y  = lamp[1];
				auto p = make_pair(x, y);
				if(!ls.contains(p)) {
					ls.insert(p);
					row[x]++;
					col[y]++;
					diag_down[n - x + y]++;
					diag_up[x + y]++;
				}
			}
			auto ans = vector<int>();
			for(auto query: queries) {
				int query_x = query[0];
				int query_y = query[1];
				if(row[query_x] > 0 || col[query_y] > 0 || diag_down[n - query_x + query_y] > 0 || diag_up[query_x + query_y] > 0) {
					ans.push_back(1);
				} else {
					ans.push_back(0);
				}
				pair<int, int> adjacents[9] = {make_pair(query_x + 1, query_y + 1), make_pair(query_x + 1, query_y), make_pair(query_x + 1, query_y - 1),
				                               make_pair(query_x, query_y + 1), make_pair(query_x, query_y), make_pair(query_x, query_y - 1),
				                               make_pair(query_x - 1, query_y + 1), make_pair(query_x - 1, query_y), make_pair(query_x - 1, query_y - 1)};
				for(auto adjacent: adjacents) {
					if(ls.contains(adjacent)) {
						ls.erase(adjacent);
						auto [x, y] = adjacent;
						row[x]--;
						col[y]--;
						diag_down[n - x + y]--;
						diag_up[x + y]--;
					}
				}
			}
			return ans;
		}

		unsigned long long pair_hash::operator()(const pair<int, int> &p) const { return static_cast<unsigned long long>(p.first) * 1000000000 + p.second; }
	}// namespace grid_illumination

	namespace count_number_of_pairs_with_absolute_difference_k {
		int Solution::countKDifference(vector<int> &nums, int k) {
			int ans = 0;
			for(int i = 0; i < nums.size(); i++) {
				for(int j = i + 1; j < nums.size(); j++) {
					if(abs(nums[i] - nums[j]) == k) {
						ans++;
					}
				}
			}
			return ans;
		}
	}// namespace count_number_of_pairs_with_absolute_difference_k

	namespace simplified_fractions {
		vector<string> Solution::simplifiedFractions(int n) {
			auto ans = vector<string>();
			for(int denominator = 2; denominator <= n; denominator++) {
				for(int numerator = 1; numerator < denominator; numerator++) {
					if(gcd(denominator, numerator) != 1) {
						continue;
					}
					auto oss = ostringstream();
					oss << numerator << "/" << denominator;
					ans.push_back(oss.str());
				}
			}
			return ans;
		}

		int Solution::gcd(int m, int n) { return n != 0 ? gcd(n, m % n) : m; }
	}// namespace simplified_fractions

	namespace minimum_difference_between_highest_and_lowest_of_k_scores {
		int Solution::minimumDifference(vector<int> &nums, int k) {
			int ans = 100000;
			sort(nums.begin(), nums.end());
			for(int i = 0; i + k - 1 < nums.size(); i++) {
				ans = min(ans, nums[i + k - 1] - nums[i]);
			}
			return ans;
		}
	}// namespace minimum_difference_between_highest_and_lowest_of_k_scores

	namespace number_of_enclaves {
		int Solution::numEnclaves(vector<vector<int>> &grid) {
			int sum     = 0;
			const int m = grid.size();
			const int n = grid[0].size();
			auto que    = queue<pair<int, int>>();
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					if(grid[i][j] == 1) {
						sum++;
						if(i == 0 || i == m - 1 || j == 0 || j == n - 1) {
							que.push(make_pair(i, j));
							grid[i][j] = 0;
						}
					}
				}
			}
			while(!que.empty()) {
				auto [x, y] = que.front();
				sum--;
				que.pop();
				pair<int, int> nexts[4] = {make_pair(x + 1, y), make_pair(x - 1, y), make_pair(x, y + 1), make_pair(x, y - 1)};
				for(auto next: nexts) {
					auto [next_x, next_y] = next;
					if(0 <= next_x && next_x < m && 0 <= next_y && next_y < n && grid[next_x][next_y] != 0) {
						que.push(next);
						grid[next_x][next_y] = 0;
					}
				}
			}
			return sum;
		}
	}// namespace number_of_enclaves

	namespace maximum_number_of_balloons {
		int Solution::maxNumberOfBalloons(const string &text) {
			int b = 0;
			int a = 0;
			int l = 0;
			int o = 0;
			int n = 0;
			for(const char ch: text) {
				switch(ch) {
					case 'b':
						b++;
						break;
					case 'a':
						a++;
						break;
					case 'l':
						l++;
						break;
					case 'o':
						o++;
						break;
					case 'n':
						n++;
						break;
				}
			}
			l /= 2;
			o /= 2;
			int ans = b;
			ans     = min(ans, a);
			ans     = min(ans, l);
			ans     = min(ans, o);
			ans     = min(ans, n);
			return ans;
		}
	}// namespace maximum_number_of_balloons

	namespace swap_adjacent_in_lr_string {
		bool Solution::canTransform(const string &start, const string &end) {
			auto oss_start = ostringstream();
			auto oss_end   = ostringstream();
			auto i_start   = vector<int>();
			auto i_end     = vector<int>();
			for(int i = 0; i < start.size(); i++) {
				char ch = start[i];
				if(ch == 'R' || ch == 'L') {
					oss_start << ch;
					i_start.push_back(i);
				}
			}
			for(int i = 0; i < end.size(); i++) {
				char ch = end[i];
				if(ch == 'R' || ch == 'L') {
					oss_end << ch;
					i_end.push_back(i);
				}
			}
			string str_start = oss_start.str();
			string str_end   = oss_end.str();
			if(str_start != str_end) {
				return false;
			}
			for(int i = 0; i < i_start.size(); i++) {
				if(str_start[i] == 'R') {
					if(i_start[i] > i_end[i]) {
						return false;
					}
				} else {
					//L
					if(i_start[i] < i_end[i]) {
						return false;
					}
				}
			}
			return true;
		}
	}// namespace swap_adjacent_in_lr_string

	namespace count_operations_to_obtain_zero {
		int Solution::countOperations(int num1, int num2) {
			int count = 0;
			while(num1 != 0 && num2 != 0) {
				if(num1 > num2) {
					count += num1 / num2;
					num1 = num1 % num2;
				} else {
					count += num2 / num1;
					num2 = num2 % num1;
				}
			}
			return count;
		}
	}// namespace count_operations_to_obtain_zero

	namespace minimum_operations_to_make_the_array_alternating {
		int Solution::minimumOperations(vector<int> &nums) {
			int a_sum = 0;
			int b_sum = 0;
			auto a    = unordered_map<int, int>();
			auto b    = unordered_map<int, int>();
			for(int i = 0; i < nums.size(); i++) {
				if(i % 2 == 0) {
					a[nums[i]]++;
					a_sum++;
				} else {
					b[nums[i]]++;
					b_sum++;
				}
			}
			int max_num = 0;
			int maximum = 0;
			int ans1    = 0;
			for(const auto i: a) {
				if(maximum < i.second) {
					maximum = i.second;
					max_num = i.first;
				}
			}
			ans1 += a_sum - maximum;
			maximum = 0;
			for(const auto i: b) {
				if(i.first != max_num && maximum < i.second) {
					maximum = i.second;
				}
			}
			ans1 += b_sum - maximum;

			int ans2 = 0;
			max_num  = 0;
			maximum  = 0;
			for(const auto i: b) {
				if(maximum < i.second) {
					maximum = i.second;
					max_num = i.first;
				}
			}
			ans2 += b_sum - maximum;
			maximum = 0;
			for(const auto i: a) {
				if(i.first != max_num && maximum < i.second) {
					maximum = i.second;
				}
			}
			ans2 += a_sum - maximum;
			return min(ans1, ans2);
		}
	}// namespace minimum_operations_to_make_the_array_alternating

	namespace removing_minimum_number_of_magic_beans {
		long long Solution::minimumRemoval(vector<int> &beans) {
			sort(beans.begin(), beans.end());
			long long sum     = 0;
			long long maximum = 0;
			for(int i = 0; i < beans.size(); i++) {
				sum += beans[i];
				maximum = max(maximum, static_cast<long long>(beans[i] * (beans.size() - i)));
			}
			return sum - maximum;
		}
	}// namespace removing_minimum_number_of_magic_beans

	namespace maximum_and_sum_of_array {
		int Solution::maximumANDSum(vector<int> &nums, int numSlots) {
			int ans = 0;
			vector<int> max_and_sum_of_status(1 << numSlots * 2);
			for(unsigned int status = 0; status < max_and_sum_of_status.size(); ++status) {
				//status:已经放置数字的篮子的集合
				const int one_count = popcount(status);
				if(one_count >= nums.size()) {
					continue;
				}
				for(int next_slot = 0; next_slot < numSlots * 2; ++next_slot) {
					if((status & 1 << next_slot) == 0) {
						// next_slot是空的
						const int next_status              = status | 1 << next_slot;                                                                              ///< 加上next_slot之后的状态
						const auto slot_num                = next_slot / 2 + 1;                                                                                    ///< slot编号
						max_and_sum_of_status[next_status] = max(max_and_sum_of_status[next_status], max_and_sum_of_status[status] + (slot_num & nums[one_count]));//放置第onecount个数字
						ans                                = max(ans, max_and_sum_of_status[next_status]);
					}
				}
			}
			return ans;
		}
	}// namespace maximum_and_sum_of_array

	namespace single_element_in_a_sorted_array {
		int Solution::singleNonDuplicate(vector<int> &nums) {
			int l = 0;
			int r = nums.size() - 1;
			while(l < r) {
				if(l + 1 == r) {
					if(l == 0) {
						return nums[l];
					}
					if(r == nums.size() - 1) {
						return nums[r];
					}
					if(nums[l - 1] == nums[l]) {
						return nums[r];
					}
					return nums[l];
				}
				const int m = (l + r) / 2;
				int tmp     = m;
				if(nums[m + 1] == nums[m]) {
					tmp = m + 1;
				}
				if(tmp % 2 == 0) {
					//在左边
					r = m;
				} else {
					//在右边
					l = m;
				}
			}
			return nums[l];
		}
	}// namespace single_element_in_a_sorted_array

	namespace lucky_numbers_in_a_matrix {
		vector<int> Solution::luckyNumbers(vector<vector<int>> &matrix) {
			auto ans      = vector<int>();
			const auto m  = matrix.size();
			const auto n  = matrix[0].size();
			auto *minimum = new int[m];
			memset(minimum, 50, m * sizeof(int));
			auto *maximum = new int[n];
			memset(maximum, 0, n * sizeof(int));
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					minimum[i] = min(minimum[i], matrix[i][j]);
					maximum[j] = max(maximum[j], matrix[i][j]);
				}
			}
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					if(matrix[i][j] == minimum[i] && matrix[i][j] == maximum[j]) {
						ans.push_back(matrix[i][j]);
					}
				}
			}
			delete[] minimum;
			delete[] maximum;
			return ans;
		}
	}// namespace lucky_numbers_in_a_matrix

	namespace number_of_ways_to_reconstruct_a_tree {
		int Solution::checkWays(vector<vector<int>> &pairs) {
			unordered_map<int, unordered_set<int>> adj;
			for(auto &p: pairs) {
				adj[p[0]].emplace(p[1]);
				adj[p[1]].emplace(p[0]);
			}
			/* 检测是否存在根节点*/
			int root = -1;
			for(auto &[node, neighbours]: adj) {
				if(neighbours.size() == adj.size() - 1) {
					root = node;
					break;
				}
			}
			if(root == -1) {
				return 0;
			}

			int res = 1;
			for(auto &[node, neighbours]: adj) {
				if(node == root) {
					continue;
				}
				const int currDegree = neighbours.size();
				int parent           = -1;
				int parentDegree     = INT_MAX;

				/* 根据 degree 的大小找到 node 的父节点 parent */
				for(const auto &neighbour: neighbours) {
					if(adj[neighbour].size() < parentDegree && adj[neighbour].size() >= currDegree) {
						parent       = neighbour;
						parentDegree = adj[neighbour].size();
					}
				}
				if(parent == -1) {
					return 0;
				}

				/* 检测 neighbours 是否是 adj[parent] 的子集 */
				for(const auto &neighbour: neighbours) {
					if(neighbour == parent) {
						continue;
					}
					if(static_cast<unsigned int>(adj[parent].contains(neighbour)) == 0U) {
						return 0;
					}
				}
				if(parentDegree == currDegree) {
					res = 2;
				}
			}
			return res;
		}
	}// namespace number_of_ways_to_reconstruct_a_tree

	namespace find_center_of_star_graph {
		int Solution::findCenter(vector<vector<int>> &edges) {
			auto um = unordered_map<int, int>();
			for(auto edge: edges) {
				um[edge[0]]++;
				um[edge[1]]++;
				if(um[edge[0]] > 1) {
					return edge[0];
				}
				if(um[edge[1]] > 1) {
					return edge[1];
				}
			}
			return 0;
		}
	}// namespace find_center_of_star_graph

	namespace knight_probability_in_chessboard {
		double Solution::knightProbability(int n, int k, int row, int column) {
			if(k == 0) {
				return 1;
			}
			const auto s = status(k, row, column);
			if(um.count(s) == 1) {
				return um[s];
			}
			int off                 = 0;
			pair<int, int> nexts[8] = {make_pair(row - 2, column - 1),
			                           make_pair(row - 2, column + 1),
			                           make_pair(row + 2, column - 1),
			                           make_pair(row + 2, column + 1),
			                           make_pair(row - 1, column - 2),
			                           make_pair(row - 1, column + 2),
			                           make_pair(row + 1, column - 2),
			                           make_pair(row + 1, column + 2)};
			double sum              = 0;
			for(auto [next_x, next_y]: nexts) {
				if(0 <= next_x && next_x < n && 0 <= next_y && next_y < n) {
					sum += knightProbability(n, k - 1, next_x, next_y);
				}
			}
			const double ans = sum / 8;
			um[s]            = ans;
			return ans;
		}

		unsigned int status_hash::operator()(const status &s) const { return s.k * 25 * 25 + s.row * 25 + s.column; }

		bool status_equal::operator()(const status &s1, const status &s2) const { return s1.k == s2.k && s1.row == s2.row && s1.column == s2.column; }
	}// namespace knight_probability_in_chessboard

	namespace pancake_sorting {
		vector<int> Solution::pancakeSort(vector<int> &arr) {
			auto ans      = vector<int>();
			const int n   = arr.size();
			auto *current = new int[n];
			auto *sorted  = new int[n];
			for(int i = 0; i < n; i++) {
				current[i] = arr[i];
				sorted[i]  = arr[i];
			}
			sort(sorted, sorted + n);
		RESTART:
			for(int i = n - 1; i >= 0; i--) {
				if(current[i] != sorted[i]) {
					const int target = sorted[i];
					int target_i     = -1;
					for(int j = 0; j <= i; j++) {
						if(current[j] == target) {
							target_i = j + 1;
							break;
						}
					}
					if(target_i == 1) {
						target_i = i + 1;
					}
					ans.push_back(target_i);
					for(int j = 0; j < target_i / 2; j++) {
						swap(current[j], current[target_i - j - 1]);
					}
					goto RESTART;
				}
			}
			delete[] current;
			delete[] sorted;
			return ans;
		}
	}// namespace pancake_sorting

	namespace count_equal_and_divisible_pairs_in_an_array {
		int Solution::countPairs(vector<int> &nums, int k) {
			int ans = 0;
			for(int i = 0; i + 1 < nums.size(); i++) {
				for(int j = i + 1; j < nums.size(); j++) {
					if(nums[i] == nums[j] && i * j % k == 0) {
						ans++;
					}
				}
			}
			return ans;
		}
	}// namespace count_equal_and_divisible_pairs_in_an_array

	namespace find_three_consecutive_integers_that_sum_to_a_given_number {
		vector<long long> Solution::sumOfThree(long long int num) {
			if(num % 3 == 0) {
				const long long mid = num / 3;
				vector ans          = {mid - 1, mid, mid + 1};
				return ans;
			}
			return {};
		}
	}// namespace find_three_consecutive_integers_that_sum_to_a_given_number

	namespace maximum_split_of_positive_even_integers {
		vector<long long> Solution::maximumEvenSplit(long long int finalSum) {
			if(finalSum % 2 != 0) {
				return {};
			}
			if(finalSum == 4) {
				return {4};
			}
			auto ans = vector<long long int>();
			ans.push_back(2);
			finalSum -= 2;
			for(long long i = 4; i <= finalSum; i += 2) {
				const long long int next = finalSum - i;
				if(next > i) {
					ans.push_back(i);
					finalSum = next;
				} else {
					ans.push_back(finalSum);
					break;
				}
			}
			return ans;
		}
	}// namespace maximum_split_of_positive_even_integers

	namespace count_good_triplets_in_an_array {
		long long Solution::goodTriplets(vector<int> &nums1, vector<int> &nums2) {
			const int n = nums1.size();
			FenwickTree<int> occur(n);
			unordered_map<int, int> pos;
			for(int i = 0; i < n; ++i) {
				pos[nums2[i]] = i + 1;
			}
			long long ans = 0;
			for(int i = 0; i < n; ++i) {
				const int idx   = pos[nums1[i]];
				const int left  = occur.query(idx);
				const int right = n - idx - (occur.query(n) - occur.query(idx));
				ans += 1LL * left * right;
				occur.update(idx, 1);
			}

			return ans;
		}
	}// namespace count_good_triplets_in_an_array

	namespace count_integers_with_even_digit_sum {
		int Solution::countEven(int num) {
			int ans = 0;
			for(int i = 1; i <= num; i++) {
				stringstream ss;
				ss << i;
				char ch;
				int sum = 0;
				while(ss >> ch) {
					sum += ch - '0';
				}
				if(sum % 2 == 0) {
					ans++;
				}
			}
			return ans;
		}
	}// namespace count_integers_with_even_digit_sum

	namespace merge_nodes_in_between_zeros {
		ListNode *Solution::mergeNodes(ListNode *head) {
			while(head != nullptr && head->val == 0) {
				head = head->next;
			}
			auto *prev = head;
			while(head != nullptr && head->next != nullptr) {
				if(head->next->val != 0) {
					head->val += head->next->val;
					head->next = head->next->next;
				} else {
					head->next = head->next->next;
					head       = head->next;
				}
			}
			return prev;
		}
	}// namespace merge_nodes_in_between_zeros

	namespace construct_string_with_repeat_limit {
		string Solution::repeatLimitedString(const string &s, int repeatLimit) {
			int ch[26] = {};
			for(const char c: s) {
				ch[c - 'a']++;
			}
			auto oss = ostringstream();
			for(int i = 25; i >= 0; i--) {
				int repeat = 0;
				while(ch[i] != 0) {
					oss << static_cast<char>(i + 'a');
					repeat++;
					ch[i]--;
					if(repeat == repeatLimit && ch[i] != 0) {
						for(int j = i - 1; j >= 0; j--) {
							if(ch[j] > 0) {
								oss << static_cast<char>(j + 'a');
								ch[j]--;
								repeat = 0;
								break;
							}
						}
						if(repeat != 0) {
							return oss.str();
						}
					}
				}
			}
			return oss.str();
		}
	}// namespace construct_string_with_repeat_limit

	namespace count_array_pairs_divisible_by_k {
		long long Solution::coutPairs(vector<int> &nums, int k) {
			long long ans = 0;
			// 统计每个数的倍数出现的次数
			auto count = unordered_map<int, int>();
			for(const auto num: nums) {
				count[num]++;
			}
			const int maximum = *max_element(nums.begin(), nums.end());
			// 为什么这个算法是 O(nlnn) 的？因为这个算法的循环次数是 n(1 + 1/2 + 1/3 + ...)，由调和级数可知括号内趋向 lnn
			for(int i = 1; i <= maximum; i++) {
				for(int j = i * 2; j <= maximum; j += i) {
					count[i] += count[j];
				}
			}
			for(const auto num: nums) {
				// 对于每个数统计与它形成好二元组的数有几个
				ans += count[k / gcd(k, num)];
				if(static_cast<long long>(num) * num % k == 0) {
					// 排除自己和自己形成好二元组的情况
					ans--;
				}
			}
			return ans / 2;
		}
	}// namespace count_array_pairs_divisible_by_k

	namespace leetcode717_1_bit_and_2_bit_characters {
		bool Solution::isOneBitCharacter(vector<int> &bits) {
			for(int i = 0; i < bits.size();) {
				int next = i;
				if(bits[i] == 1) {
					next += 2;
				} else {
					next += 1;
				}
				if(next >= bits.size()) {
					return i == bits.size() - 1;
				}
				i = next;
			}
			return false;
		}
	}// namespace leetcode717_1_bit_and_2_bit_characters

	namespace longest_mountain_in_array {
		int Solution::longestMountain(vector<int> &arr) {
			if(arr.size() < 3) {
				return 0;
			}
			auto up_down = vector<int>(arr.size() - 1);
			for(int i = 0; i + 1 < arr.size(); i++) {
				if(arr[i] < arr[i + 1]) {
					up_down[i] = 1;
				} else if(arr[i] > arr[i + 1]) {
					up_down[i] = 0;
				} else {
					up_down[i] = 2;
				}
			}
			auto sector_size = vector<pair<int, int>>();
			int prev         = up_down[0];
			int count        = 1;
			for(int i = 1; i < up_down.size(); i++) {
				if(up_down[i] != prev) {
					sector_size.emplace_back(prev, count);
					count = 1;
				} else {
					count++;
				}
				prev = up_down[i];
			}
			sector_size.emplace_back(prev, count);
			if(sector_size.size() < 2) {
				return 0;
			}
			int maximum = 0;
			for(int i = 0; i + 1 < sector_size.size(); i++) {
				if(sector_size[i].first == 1 && sector_size[i + 1].first == 0) {
					maximum = max(maximum, sector_size[i].second + sector_size[i + 1].second + 1);
				}
			}
			return maximum;
		}
	}// namespace longest_mountain_in_array

	namespace push_dominoes {
		string Solution::pushDominoes(string dominoes) {
			const int n      = dominoes.length();
			auto *left_to_r  = new int[n];
			auto *right_to_l = new int[n];
			auto *left_is    = new char[n];
			auto *right_is   = new char[n];
			int l2r          = 0;
			int r2l          = 0;
			char ch          = '.';
			for(int i = 0; i < n; i++) {
				if(dominoes[i] != '.') {
					ch = dominoes[i];
				}
				left_is[i] = ch;
			}
			ch = '.';
			for(int i = n - 1; i >= 0; i--) {
				if(dominoes[i] != '.') {
					ch = dominoes[i];
				}
				right_is[i] = ch;
			}
			for(int i = 0; i < n; i++) {
				if(dominoes[i] == 'R') {
					l2r = 0;
				} else {
					l2r++;
				}
				left_to_r[i] = l2r;
			}
			for(int i = n - 1; i >= 0; i--) {
				if(dominoes[i] == 'L') {
					r2l = 0;
				} else {
					r2l++;
				}
				right_to_l[i] = r2l;
			}
			for(int i = 0; i < n; i++) {
				if(dominoes[i] == '.') {
					if(left_is[i] == 'R' && right_is[i] == 'L') {
						if(right_to_l[i] > left_to_r[i]) {
							dominoes[i] = 'R';
						} else if(left_to_r[i] > right_to_l[i]) {
							dominoes[i] = 'L';
						}
					} else if(right_is[i] == 'L') {
						dominoes[i] = 'L';
					} else if(left_is[i] == 'R') {
						dominoes[i] = 'R';
					}
				}
			}
			delete[] left_to_r;
			delete[] right_to_l;
			delete[] left_is;
			delete[] right_is;
			return dominoes;
		}
	}// namespace push_dominoes

	namespace the_number_of_good_subsets {
		int Solution::numberOfGoodSubsets(vector<int> &nums) {
			vector<int> freq(num_max + 1);
			for(const int num: nums) {
				freq[num]++;
			}

			vector<int> f(mask_max);
			f[0] = 1;
			for(int i = 0; i < freq[1]; ++i) {
				f[0] = f[0] * 2 % mod;
			}

			for(int i = 2; i <= num_max; ++i) {
				if(freq[i] == 0) {
					continue;
				}

				// 检查 i 的每个质因数是否均不超过 1 个
				int subset  = 0;
				const int x = i;
				bool check  = true;
				for(int j = 0; j < primes.size(); j++) {
					const int prime = primes[j];
					if(x % (prime * prime) == 0) {
						check = false;
						break;
					}
					if(x % prime == 0) {
						subset |= 1 << j;
					}
				}
				if(!check) {
					continue;
				}

				// 动态规划
				for(int mask = mask_max - 1; mask > 0; mask--) {
					if((mask & subset) == subset) {
						f[mask] = (f[mask] + static_cast<long long>(f[mask ^ subset]) * freq[i]) % mod;
					}
				}
			}
			int ans = 0;
			for(int mask = 1; mask < mask_max; mask++) {
				ans = (ans + f[mask]) % mod;
			}
			return ans;
		}
	}// namespace the_number_of_good_subsets

	namespace reverse_only_letters {
		string Solution::reverseOnlyLetters(string s) {
			for(int i = 0, j = s.length() - 1; i < j && i < s.length() && j >= 0;) {
				if(isalpha(s[i]) != 0 && isalpha(s[j]) != 0) {
					const char temp = s[i];
					s[i]            = s[j];
					s[j]            = temp;
					i++;
					j--;
				} else {
					while(i < s.length() && isalpha(s[i]) == 0) {
						i++;
					}
					while(j >= 0 && isalpha(s[j]) == 0) {
						j--;
					}
				}
			}
			return s;
		}
	}// namespace reverse_only_letters

	namespace where_will_the_ball_fall {
		vector<int> Solution::findBall(vector<vector<int>> &grid) {
			const int m = grid.size();
			const int n = grid[0].size();
			vector<int> ans(n);
			for(int i = 0; i < n; i++) {
				int current_x = 0;
				int current_y = i;
				int dir       = 1;// 0 - 左, 1 - 下, 2 - 右
				while(true) {
					if(current_x == m) {
						ans[i] = current_y;
						break;
					}
					if(current_x < 0 || current_y < 0 || current_y >= n) {
						ans[i] = -1;
						break;
					}
					if(dir == 0) {
						//左
						if(grid[current_x][current_y] == 1) {
							ans[i] = -1;
							break;
						}
						dir = 1;
					} else if(dir == 1) {
						//下
						if(grid[current_x][current_y] == 1) {
							dir = 2;
						} else {
							dir = 0;
						}
					} else {
						//右
						if(grid[current_x][current_y] == 1) {
							dir = 1;
						} else {
							ans[i] = -1;
							break;
						}
					}
					if(dir == 0) {
						//左
						current_y--;
					} else if(dir == 1) {
						//下
						current_x++;
					} else {
						//右
						current_y++;
					}
				}
			}
			return ans;
		}
	}// namespace where_will_the_ball_fall

	namespace complex_number_multiplication {
		string Solution::complexNumberMultiply(const string &num1, const string &num2) {
			auto ss = stringstream();
			ss << num1 << num2;
			int r1;
			int i1;
			int r2;
			int i2;
			ss >> r1;
			ss.get();
			ss >> i1;
			ss.get();
			ss >> r2;
			ss.get();
			ss >> i2;
			const int r = r1 * r2 - i1 * i2;
			const int i = r1 * i2 + r2 * i1;
			ss          = stringstream();
			ss << r << '+' << i << 'i';
			return ss.str();
		}
	}// namespace complex_number_multiplication

	namespace maximum_difference_between_increasing_elements {
		int Solution::maximumDifference(vector<int> &nums) {
			int minn     = nums[0];
			int max_diff = -1;
			for(int i = 1; i < nums.size(); i++) {
				if(nums[i] > minn) {
					max_diff = max(max_diff, nums[i] - minn);
				}
				minn = min(minn, nums[i]);
			}
			return max_diff;
		}
	}// namespace maximum_difference_between_increasing_elements

	namespace optimal_division {
		string Solution::optimalDivision(vector<int> &nums) {
			auto oss = ostringstream();
			if(nums.size() == 1) {
				oss << nums[0];
			} else if(nums.size() == 2) {
				oss << nums[0] << '/' << nums[1];
			} else {
				oss << nums[0] << "/(";
				for(int i = 1; i < nums.size() - 1; i++) {
					oss << nums[i] << '/';
				}
				oss << nums[nums.size() - 1] << ')';
			}
			return oss.str();
		}
	}// namespace optimal_division

	namespace counting_words_with_a_given_prefix {
		int Solution::prefixCount(vector<string> &words, string pref) {
			int ans = 0;
			for(auto word: words) {
				bool ok = true;
				for(int i = 0; i < pref.length(); i++) {
					if(pref[i] != word[i]) {
						ok = false;
						break;
					}
				}
				if(ok) {
					ans++;
				}
			}
			return ans;
		}
	}// namespace counting_words_with_a_given_prefix

	namespace minimum_number_of_steps_to_make_two_strings_anagram_ii {
		int Solution::minSteps(const string &s, const string &t) {
			int ans       = 0;
			int s_num[26] = {};
			int t_num[26] = {};
			for(const char ch: s) {
				s_num[ch - 'a']++;
			}
			for(const char ch: t) {
				t_num[ch - 'a']++;
			}
			for(int i = 0; i < 26; i++) {
				ans += abs(s_num[i] - t_num[i]);
			}
			return ans;
		}
	}// namespace minimum_number_of_steps_to_make_two_strings_anagram_ii

	namespace minimum_time_to_complete_trips {
		long long Solution::minimumTime(vector<int> &time, int totalTrips) {
			int max_t = 1;
			int min_t = 100000;
			for(auto t: time) {
				max_t = max(max_t, t);
				min_t = min(min_t, t);
			}
			long long l = static_cast<long long>(totalTrips) / max_t / time.size();
			long long r = static_cast<long long>(totalTrips) * max_t;
			while(l <= r) {
				const long long m = (l + r) / 2;
				long long sum     = 0;
				for(const auto t: time) {
					sum += m / t;
				}
				if(l == r || l + 1 == r) {
					return r;
				}
				if(sum >= totalTrips) {
					r = m;
				} else if(sum < totalTrips) {
					l = m;
				}
			}
			return 0;
		}
	}// namespace minimum_time_to_complete_trips

	namespace minimum_time_to_finish_the_race {
		int Solution::minimumFinishTime(vector<vector<int>> &tires, int changeTime, int numLaps) {
			/* min_times[i] = 用一个轮胎跑 i 圈的最小花费 */
			vector<long long> min_times(20, 1e9);
			for(auto &v: tires) {
				const long long f    = v[0];
				const long long r    = v[1];
				const long long cost = f + changeTime;///< 第一次用该轮胎的耗费
				long long current    = f;
				long long sum        = cost;
				for(int i = 1; i <= 19; i++) {
					min_times[i] = min(min_times[i], sum);
					current *= r;
					if(current > cost) {
						current = f;
						sum += cost;
					} else {
						sum += current;
					}
				}
			}
			/* dp[i] = 跑 i 圈的最小花费 */
			vector<long long> dp(numLaps + 1, 1e9);
			dp[0] = 0;
			for(int i = 1; i <= numLaps; i++) {
				for(int j = 1; j <= min(19, i); j++) {
					dp[i] = min(dp[i], dp[i - j] + min_times[j]);
				}
			}
			/* 最后需要减去一次换轮胎的时间 */
			return dp[numLaps] - changeTime;
		}
	}// namespace minimum_time_to_finish_the_race

	namespace maximum_number_of_achievable_transfer_requests {
		int Solution::maximumRequests(int n, vector<vector<int>> &requests) {
			int ans = 0;
			for(unsigned int i = 0; i < 1 << requests.size(); i++) {
				auto *in  = new int[n];
				auto *out = new int[n];
				memset(in, 0, n * sizeof(int));
				memset(out, 0, n * sizeof(int));
				for(unsigned int j = 0; j < requests.size(); j++) {
					if((i & 1 << j) != 0) {
						out[requests[j][0]]++;
						in[requests[j][1]]++;
					}
				}
				bool ok = true;
				for(int j = 0; j < n; j++) {
					if(out[j] != in[j]) {
						ok = false;
						break;
					}
				}
				if(ok) {
					ans = max(ans, popcount(i));
				}
				delete[] in;
				delete[] out;
			}
			return ans;
		}
	}// namespace maximum_number_of_achievable_transfer_requests

	namespace zigzag_conversion {
		string Solution::convert(string s, int numRows) {
			if(numRows == 1) {
				return s;
			}
			auto oss = ostringstream();
			auto *m  = new char *[numRows];
			for(int i = 0; i < numRows; i++) {
				m[i] = new char[s.length()];
				memset(m[i], ' ', s.length() * sizeof(char));
			}
			int current_x = 0;
			int current_y = 0;
			bool dir      = true;// true = 下, false = 斜
			for(const char ch: s) {
				m[current_x][current_y] = ch;
				if(dir && current_x == numRows - 1 || !dir && current_x == 0) {
					dir = !dir;
				}
				if(dir) {
					current_x++;
				} else {
					current_x--;
					current_y++;
				}
			}
			for(int i = 0; i < numRows; i++) {
				for(int j = 0; j <= min(current_y, static_cast<int>(s.length() - 1)); j++) {
					if(m[i][j] != ' ') {
						oss << m[i][j];
					}
				}
			}
			for(int i = 0; i < numRows; i++) {
				delete[] m[i];
			}
			delete[] m;
			return oss.str();
		}
	}// namespace zigzag_conversion

	namespace find_the_closest_palindrome {
		string Solution::nearestPalindromic(const string &n) {
			const long long num = stoll(n);
			if(num == 10 || num == 11) {
				return "9";
			}
			if(num < 10) {
				return to_string(num - 1);
			}
			int len         = n.length();
			const bool even = n.length() % 2 == 0;
			string prefix   = n.substr(0, n.length() / 2 + (even ? 0 : 1));
			string option_str[3];
			auto rev                      = string(prefix.rbegin() + (even ? 0 : 1), prefix.rend());
			option_str[2]                 = prefix + rev;
			const long long prefix_int[2] = {stoll(prefix) - 1, stoll(prefix) + 1};
			string prefix_str[2]          = {to_string(prefix_int[0]), to_string(prefix_int[1])};
			for(int i = 0; i < 2; i++) {
				if(prefix_str[i].length() == prefix.length()) {
					rev           = string(prefix_str[i].rbegin() + (even ? 0 : 1), prefix_str[i].rend());
					option_str[i] = prefix_str[i] + rev;
				} else if(prefix_str[i].length() > prefix.length()) {
					rev           = string(prefix_str[i].rbegin() + (even ? 1 : 2), prefix_str[i].rend());
					option_str[i] = prefix_str[i] + rev;
				} else if(prefix_str[i].length() < prefix.length()) {
					rev           = string(prefix_str[i].rbegin(), prefix_str[i].rend());
					option_str[i] = prefix_str[i] + (even ? "9" : "") + rev;
				}
			}
			long long option_int[3] = {stoll(option_str[0]), stoll(option_str[1]), stoll(option_str[2])};
			sort(option_int, option_int + 3);
			long long minimum = option_int[0];
			for(int i = 1; i < 3; i++) {
				if(abs(option_int[i] - num) < abs(minimum - num) && option_int[i] != num) {
					minimum = option_int[i];
				}
			}
			return to_string(minimum);
		}
	}// namespace find_the_closest_palindrome

	namespace add_digits {
		int Solution::addDigits(int num) { return (num - 1) % 9 + 1; }
	}// namespace add_digits

	namespace sum_of_subarray_ranges {
		long long Solution::subArrayRanges(vector<int> &nums) {
			long long ans = 0;
			for(int i = 0; i + 1 < nums.size(); i++) {
				int minimum = nums[i];
				int maximum = nums[i];
				for(int j = i + 1; j < nums.size(); j++) {
					minimum = min(minimum, nums[j]);
					maximum = max(maximum, nums[j]);
					ans += maximum - minimum;
				}
			}
			return ans;
		}
	}// namespace sum_of_subarray_ranges

	namespace longest_uncommon_subsequence_i {
		int Solution::findLUSlength(const string &a, const string &b) {
			if(a.length() != b.length() || b.find(a) == string::npos && a.find(b) == string::npos) {
				return max(a.length(), b.length());
			}
			return -1;
		}
	}// namespace longest_uncommon_subsequence_i

	namespace most_frequent_number_following_key_in_an_array {
		int Solution::mostFrequent(vector<int> &nums, int key) {
			unordered_map<int, int> um;
			for(int i = 0; i + 1 < nums.size(); i++) {
				if(nums[i] == key) {
					um[nums[i + 1]]++;
				}
			}
			int max_v = 0;
			int max_k = 0;
			for(auto [k, v]: um) {
				if(v > max_v) {
					max_v = v;
					max_k = k;
				}
			}
			return max_k;
		}
	}// namespace most_frequent_number_following_key_in_an_array

	namespace sort_the_jumbled_numbers {
		vector<int> Solution::sortJumbled(vector<int> &mapping, vector<int> &nums) {
			vector<tuple<int, int, int>> vec;
			for(int i = 0; i < nums.size(); i++) {
				string str = to_string(nums[i]);
				ostringstream oss;
				for(const char ch: str) {
					oss << mapping[ch - '0'];
				}
				vec.emplace_back(i, nums[i], stoi(oss.str()));
			}
			sort(vec.begin(), vec.end(), cmp());
			vector<int> ans;
			ans.reserve(vec.size());
			for(auto [i, num, rev]: vec) {
				ans.push_back(num);
			}
			return ans;
		}
	}// namespace sort_the_jumbled_numbers

	namespace all_ancestors_of_a_node_in_a_directed_acyclic_graph {
		vector<vector<int>> Solution::getAncestors(int n, vector<vector<int>> &edges) {
			for(int i = 0; i < n; i++) {
				nexts[i]     = unordered_set<int>();
				ancestors[i] = set<int>();
			}
			for(auto edge: edges) {
				nexts[edge[0]].insert(edge[1]);
			}
			for(int i = 0; i < n; i++) {
				for(const auto next: nexts[i]) {
					auto *dfsd = new bool[n];
					memset(dfsd, 0, n * sizeof(bool));
					dfs(dfsd, i, next);
					delete[] dfsd;
				}
			}
			vector<vector<int>> ans;
			for(int i = 0; i < n; i++) {
				vector<int> vec;
				for(auto i: ancestors[i]) {
					vec.push_back(i);
				}
				ans.push_back(vec);
			}
			return ans;
		}

		void Solution::dfs(bool *dfsd, int v, int i) {
			ancestors[i].insert(v);
			dfsd[i] = true;
			for(const auto next: nexts[i]) {
				if(!dfsd[next]) {
					dfs(dfsd, v, next);
				}
			}
		}
	}// namespace all_ancestors_of_a_node_in_a_directed_acyclic_graph

	namespace minimum_number_of_moves_to_make_palindrome {
		int Solution::minMovesToMakePalindrome(string s) {
			int ans = 0;
			for(int left = 0, right = s.size() - 1; left < right; left++) {
				bool even = false;
				for(int i = right; left != i; i--) {
					if(s[left] == s[i]) {
						even = true;
						// 字母出现偶数次的情况，模拟交换
						for(; i < right; i++) {
							swap(s[i], s[i + 1]);
							ans++;
						}
						right--;
						break;
					}
				}
				if(!even) {
					// 字母出现奇数次的情况，计算它距离中间还有多少距离
					ans += s.size() / 2 - left;
				}
			}
			return ans;
		}
	}// namespace minimum_number_of_moves_to_make_palindrome

	namespace cells_in_a_range_on_an_excel_sheet {
		vector<string> Solution::cellsInRange(const string &s) {
			vector<string> ans;
			istringstream ss(s);
			char col1;
			char col2;
			int row1;
			int row2;
			ss >> col1 >> row1;
			ss.get();
			ss >> col2 >> row2;
			for(char col = col1; col <= col2; col++) {
				for(int row = row1; row <= row2; row++) {
					ostringstream oss;
					oss << col << row;
					ans.push_back(oss.str());
				}
			}
			return ans;
		}
	}// namespace cells_in_a_range_on_an_excel_sheet

	namespace append_k_integers_with_minimal_sum {
		long long Solution::minimalKSum(vector<int> &nums, int k) {
			long long ans = 0;
			set<int> s;
			for(auto num: nums) {
				s.insert(num);
			}
			long long limit = k;
			for(auto i = s.begin(); i != s.end() && *i <= limit; ++i) {
				limit++;
			}
			ans += limit + limit * (limit - 1) / 2;
			for(auto i = s.begin(); i != s.end() && *i < limit; ++i) {
				ans -= *i;
			}
			return ans;
		}
	}// namespace append_k_integers_with_minimal_sum

	namespace create_binary_tree_from_descriptions {
		TreeNode *Solution::createBinaryTree(vector<vector<int>> &descriptions) {
			unordered_map<int, TreeNode *> um;
			unordered_set<int> nodes;
			unordered_set<int> childs;
			for(auto description: descriptions) {
				nodes.insert(description[0]);
				nodes.insert(description[1]);
				childs.insert(description[1]);
			}
			for(auto node: nodes) {
				um[node] = new TreeNode();
			}
			for(auto description: descriptions) {
				if(description[2] == 1) {
					//childi 是 parenti 的左子节点
					um[description[0]]->left = um[description[1]];
				} else {
					//childi 是 parenti 的右子节点。
					um[description[0]]->right = um[description[1]];
				}
			}
			for(auto node: nodes) {
				if(!childs.contains(node)) {
					return um[node];
				}
			}
			return nullptr;
		}
	}// namespace create_binary_tree_from_descriptions

	namespace replace_non_coprime_numbers_in_array {
		vector<int> Solution::replaceNonCoprimes(vector<int> &nums) {
			vector<int> ans;
			for(int i = 0; i < nums.size(); i++) {
				int num = nums[i];
				while(!ans.empty() && gcd(num, ans.back()) > 1) {
					num = num / gcd(num, ans.back()) * ans.back();
					ans.pop_back();
				}
				ans.push_back(num);
			}
			return ans;
		}
	}// namespace replace_non_coprime_numbers_in_array

	namespace find_good_days_to_rob_the_bank {
		vector<int> Solution::goodDaysToRobBank(vector<int> &security, int time) {
			if(security.size() < 2 * time + 1) {
				return {};
			}
			vector<int> ans;
			if(time == 0) {
				for(int i = 0; i < security.size(); i++) {
					ans.push_back(i);
				}
				return ans;
			}
			vector non_increasing(security.size(), 0);
			vector non_decreasing(security.size(), 0);
			for(int i = 1; i < security.size(); i++) {
				if(security[i] >= security[i - 1]) {
					non_decreasing[i] = non_decreasing[i - 1] + 1;
				} else {
					non_decreasing[i] = 0;
				}
				if(security[i] <= security[i - 1]) {
					non_increasing[i] = non_increasing[i - 1] + 1;
				} else {
					non_increasing[i] = 0;
				}
			}
			for(int i = time; i + time < security.size(); i++) {
				if(non_decreasing[i + time] >= time && non_increasing[i] >= time) {
					ans.push_back(i);
				}
			}
			return ans;
		}
	}// namespace find_good_days_to_rob_the_bank

	namespace base_7 {
		string Solution::convertToBase7(int num) {
			bool pos = true;
			if(num < 0) {
				pos = false;
				num = -num;
			}
			if(num == 0) {
				return "0";
			}
			deque<int> deq;
			while(num != 0) {
				deq.push_front(num % 7);
				num /= 7;
			}
			ostringstream oss;
			if(!pos) {
				oss << '-';
			}
			for(const int n: deq) {
				oss << n;
			}
			return oss.str();
		}
	}// namespace base_7

	namespace plates_between_candles {
		vector<int> Solution::platesBetweenCandles(string s, vector<vector<int>> &queries) {
			vector<int> ans;
			vector<int> plate_count(s.length());
			vector<int> candle_pos;
			if(s[0] == '*') {
				plate_count[0] = 1;
			} else {
				plate_count[0] = 0;
				candle_pos.push_back(0);
			}
			for(int i = 1; i < s.length(); i++) {
				plate_count[i] = plate_count[i - 1];
				if(s[i] == '*') {
					plate_count[i]++;
				} else {
					candle_pos.push_back(i);
				}
			}
			for(auto query: queries) {
				int left  = query[0];
				int right = query[1];
				auto li   = lower_bound(candle_pos.begin(), candle_pos.end(), left);
				if(li == candle_pos.end() || *li > right) {
					ans.push_back(0);
					continue;
				}
				auto ri = lower_bound(candle_pos.rbegin(), candle_pos.rend(), right, greater<int>());
				if(ri == candle_pos.rend() || *ri < left) {
					ans.push_back(0);
					continue;
				}
				ans.push_back(plate_count[*ri] - plate_count[*li]);
			}
			return ans;
		}
	}// namespace plates_between_candles

	namespace smallest_rotation_with_highest_score {
		int Solution::bestRotation(vector<int> &nums) {
			const int n = nums.size();
			vector k_score_diff(n + 1, 0);
			for(int i = 0; i < n; i++) {
				const int low  = (i + 1) % n;
				const int high = (i - nums[i] + n) % n;
				k_score_diff[low]++;
				k_score_diff[high + 1]--;
				if(low > high) {
					k_score_diff[0]++;
					k_score_diff[n]--;
				}
			}
			int ans       = 0;
			int max_score = 0;
			int score     = 0;
			for(int i = 0; i < n; i++) {
				score += k_score_diff[i];
				if(score > max_score) {
					ans       = i;
					max_score = score;
				}
			}
			return ans;
		}
	}// namespace smallest_rotation_with_highest_score

	namespace n_ary_tree_preorder_traversal {
		vector<int> Solution::preorder(Node *root) {
			if(root == nullptr) {
				return {};
			}
			vector<int> ans;
			ans.push_back(root->val);
			for(auto *child: root->children) {
				auto preorder_child = preorder(child);
				ans.insert(ans.end(), preorder_child.begin(), preorder_child.end());
			}
			return ans;
		}
	}// namespace n_ary_tree_preorder_traversal

	namespace count_nodes_with_the_highest_score {
		int Solution::countHighestScoreNodes(vector<int> &parents) {
			int ans     = 0;
			auto nodes  = vector<TreeNode *>(parents.size(), nullptr);
			auto edges  = vector(parents.size(), vector<int>());
			auto scores = vector<unsigned long long>(parents.size(), 0);
			for(int i = 0; i < parents.size(); i++) {
				nodes[i] = new TreeNode(i);
				if(parents[i] != -1) {
					edges[i].push_back(parents[i]);
					edges[parents[i]].push_back(i);
				}
			}
			TreeNode *root = nullptr;
			for(int i = 0; i < parents.size(); i++) {
				if(parents[i] != -1) {
					nodes[parents[i]]->add_child(nodes[i]);
				} else {
					root = nodes[i];
				}
			}
			root->dfs();
			unsigned long long max_score = 0;
			for(int i = 0; i < parents.size(); i++) {
				unsigned long long score = 1;
				const auto *node         = nodes[i];
				for(const auto *child: node->get_children()) {
					score *= child->get_count();
				}
				if(node->get_parent() != nullptr) {
					score *= root->get_count() - node->get_count();
				}
				max_score = max(max_score, score);
				scores[i] = score;
			}
			return count(scores.begin(), scores.end(), max_score);
		}

		void TreeNode::add_child(TreeNode *node) {
			this->children.push_back(node);
			node->parent = this;
		}

		int TreeNode::dfs() {
			int ans = 1;
			for(auto *child: this->children) {
				ans += child->dfs();
			}
			this->count = ans;
			return ans;
		}

		const vector<TreeNode *> &TreeNode::get_children() const { return children; }

		int TreeNode::get_count() const { return count; }

		TreeNode *TreeNode::get_parent() const { return parent; }
	}// namespace count_nodes_with_the_highest_score

	namespace n_ary_tree_postorder_traversal {
		vector<int> Solution::postorder(Node *root) {
			if(root == nullptr) {
				return {};
			}
			vector<int> ans;
			for(auto *child: root->children) {
				auto res = postorder(child);
				ans.insert(ans.end(), res.begin(), res.end());
			}
			ans.push_back(root->val);
			return ans;
		}
	}// namespace n_ary_tree_postorder_traversal

	namespace max_area_of_island {
		int Solution::maxAreaOfIsland(vector<vector<int>> &grid) {
			const int m = grid.size();
			const int n = grid[0].size();
			auto uf     = UnionFind(m, n);
			int ans     = 0;
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					if(grid[i][j] == 1) {
						const pair<int, int> p     = make_pair(i, j);
						ans                        = max(ans, uf.get_size(p));
						pair<int, int> siblings[4] = {
						        make_pair(i + 1, j),
						        make_pair(i - 1, j),
						        make_pair(i, j + 1),
						        make_pair(i, j - 1),
						};
						for(const auto sibling: siblings) {
							if(uf.contains(sibling) && grid[sibling.first][sibling.second] == 1 && !uf.same(p, sibling)) {
								uf.merge(p, sibling);
								ans = max(ans, uf.get_size(p));
							}
						}
					}
				}
			}
			return ans;
		}

		UnionFind::UnionFind(int m, int n)
		    : m(m), n(n) {
			parent = unordered_map<pair<int, int>,
			                       pair<int, int>,
			                       function<unsigned int(const pair<int, int> &)>>(
			        m * n,
			        [](const pair<int, int> &p) { return static_cast<unsigned int>(p.first * 50 + p.second); });
			size = unordered_map<pair<int, int>,
			                     int,
			                     function<unsigned int(const pair<int, int> &)>>(
			        m * n,
			        [](const pair<int, int> &p) { return static_cast<unsigned int>(p.first * 50 + p.second); });
			rank = unordered_map<pair<int, int>,
			                     int,
			                     function<unsigned int(const pair<int, int> &)>>(
			        m * n,
			        [](const pair<int, int> &p) { return static_cast<unsigned int>(p.first * 50 + p.second); });
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					pair<int, int> p = make_pair(i, j);
					parent[p]        = p;
					size[p]          = 1;
					rank[p]          = 0;
				}
			}
		}

		pair<int, int> UnionFind::find(pair<int, int> val) {
			if(parent[val] != val) {
				parent[val] = find(parent[val]);
			}
			return parent[val];
		}

		void UnionFind::merge(pair<int, int> a, pair<int, int> b) {
			const auto pa = find(a);
			const auto pb = find(b);
			if(pa != pb) {
				const int sum = size[pa] + size[pb];
				if(rank[pa] > rank[pb]) {
					parent[pb] = pa;
				} else {
					parent[pa] = pb;
					if(rank[pa] == rank[pb]) {
						++rank[pb];
					}
				}
				size[pa] = sum;
				size[pb] = sum;
			}
		}

		bool UnionFind::same(pair<int, int> a, pair<int, int> b) { return find(a) == find(b); }

		bool UnionFind::contains(pair<int, int> p) const { return parent.contains(p); }

		int UnionFind::get_size(pair<int, int> p) { return size[find(p)]; }
	}// namespace max_area_of_island

	namespace find_all_k_distant_indices_in_an_array {
		vector<int> Solution::findKDistantIndices(vector<int> &nums, int key, int k) {
			set<int> key_set;
			set<int> ans_set;
			for(int i = 0; i < nums.size(); i++) {
				if(nums[i] == key) {
					key_set.insert(i);
				}
			}
			for(const auto ks: key_set) {
				for(int i = ks - k; i <= ks + k; i++) {
					if(0 <= i && i < nums.size()) {
						ans_set.insert(i);
					}
				}
			}
			return vector(ans_set.begin(), ans_set.end());
		}
	}// namespace find_all_k_distant_indices_in_an_array

	namespace count_artifacts_that_can_be_extracted {
		int Solution::digArtifacts(int n, vector<vector<int>> &artifacts, vector<vector<int>> &dig) {
			auto *grid = new bool *[n];
			for(int i = 0; i < n; i++) {
				grid[i] = new bool[n];
				memset(grid[i], 0, n * sizeof(bool));
			}
			for(auto i: dig) {
				grid[i[0]][i[1]] = true;
			}
			int ans = 0;
			for(auto artifact: artifacts) {
				bool flag = true;
				for(int i = artifact[0]; i <= artifact[2]; i++) {
					for(int j = artifact[1]; j <= artifact[3]; j++) {
						if(!grid[i][j]) {
							flag = false;
							break;
						}
					}
					if(!flag) {
						break;
					}
				}
				if(flag) {
					ans++;
				}
			}
			for(int i = 0; i < n; i++) {
				delete[] grid[i];
			}
			delete[] grid;
			return ans;
		}
	}// namespace count_artifacts_that_can_be_extracted

	namespace maximize_the_topmost_element_after_k_moves {
		int Solution::maximumTop(vector<int> &nums, int k) {
			if(nums.size() == 1 && k % 2 == 1) {
				return -1;
			}
			if(k > nums.size()) {
				int ans = -1;
				for(auto num: nums) {
					ans = max(ans, num);
				}
				return ans;
			}
			unordered_map<int, int> element_count;
			set<int> poped_elements;
			for(auto num: nums) {
				element_count[num]++;
			}
			for(int i = 0; i < nums.size() && i < k - 1; i++) {
				poped_elements.insert(nums[i]);
				element_count[nums[i]]--;
			}
			int ans = -1;
			if(k < nums.size()) {
				ans = nums[k];
			}
			int maximum = -1;
			for(const auto i = poped_elements.rbegin(); i != poped_elements.rend();) {
				maximum = *i;
				break;
			}
			return max(ans, maximum);
		}
	}// namespace maximize_the_topmost_element_after_k_moves

	namespace minimum_weighted_subgraph_with_the_required_paths {
		long long Solution::minimumWeight(int n, vector<vector<int>> &edges, int src1, int src2, int dest) {
			auto *graph     = new vector<pair<int, int>>[n];
			auto *graph_rev = new vector<pair<int, int>>[n];
			for(int i = 0; i < n; i++) {
				graph[i]     = vector<pair<int, int>>();
				graph_rev[i] = vector<pair<int, int>>();
			}
			for(auto &edge: edges) {
				auto from   = edge[0];
				auto to     = edge[1];
				auto weight = edge[2];
				graph[from].emplace_back(to, weight);
				graph_rev[to].emplace_back(from, weight);
			}

			long long a = LLONG_MAX;
			vector dist_src1(n, LLONG_MAX);
			vector dist_src2(n, LLONG_MAX);
			vector dist_dest(n, LLONG_MAX);

			calc_dist(src1, graph, dist_src1);
			calc_dist(src2, graph, dist_src2);
			calc_dist(dest, graph_rev, dist_dest);

			long long ans = LLONG_MAX;

			for(int i = 0; i < n; ++i) {
				if(dist_src1[i] != LLONG_MAX && dist_src2[i] != LLONG_MAX && dist_dest[i] != LLONG_MAX) {
					ans = min(ans, dist_src1[i] + dist_src2[i] + dist_dest[i]);
				}
			}
			if(ans == LLONG_MAX) {
				ans = -1;
			}
			delete[] graph;
			delete[] graph_rev;
			return ans;
		}

		void Solution::calc_dist(int s, vector<pair<int, int>> *graph, vector<long long int> &dist) {
			priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<>> pq;
			dist[s] = 0;
			pq.emplace(0, s);
			while(!pq.empty()) {
				auto [weight, node] = pq.top();
				pq.pop();
				if(weight > dist[node]) {
					continue;
				}
				for(auto [next_node, next_weight]: graph[node]) {
					if(weight + next_weight < dist[next_node]) {
						dist[next_node] = weight + next_weight;
						pq.emplace(weight + next_weight, next_node);
					}
				}
			}
		}
	}// namespace minimum_weighted_subgraph_with_the_required_paths

	namespace utf_8_validation {
		bool Solution::validUtf8(vector<int> &data) {
			vector<int> len;
			for(const auto num: data) {
				if(num >> 7 == 0) {
					//0xxxxxxx
					len.push_back(1);
				} else if(num >> 3 == 30) {
					//11110xxx
					len.push_back(4);
				} else if(num >> 4 == 14) {
					//1110xxxx
					len.push_back(3);
				} else if(num >> 5 == 6) {
					//110xxxxx
					len.push_back(2);
				} else if(num >> 6 == 2) {
					//10xxxxxx
					len.push_back(-1);
				} else {
					return false;
				}
			}
			int count = 0;
			for(int i = 0; i < len.size(); i++) {
				if(count != 0) {
					if(len[i] != -1) {
						return false;
					}
				} else {
					count = len[i];
					if(count == -1) {
						return false;
					}
				}
				count--;
			}
			return count == 0;
		}
	}// namespace utf_8_validation

	namespace minimum_index_sum_of_two_lists {
		vector<string> Solution::findRestaurant(vector<string> &list1, vector<string> &list2) {
			unordered_map<string, int> restaurants;
			unordered_map<string, int> index1;
			unordered_map<string, int> index2;
			for(int i = 0; i < list1.size(); i++) {
				restaurants[list1[i]]++;
				index1[list1[i]] = i;
			}
			for(int i = 0; i < list2.size(); i++) {
				restaurants[list2[i]]++;
				index2[list2[i]] = i;
			}
			unordered_set<string> optional_restaurants;
			for(auto [restaurant, count]: restaurants) {
				if(count > 1) {
					optional_restaurants.insert(restaurant);
				}
			}
			int min_index_sum = INT_MAX;
			for(const auto &optional_restaurant: optional_restaurants) {
				int index_sum = index1[optional_restaurant] + index2[optional_restaurant];
				min_index_sum = min(min_index_sum, index_sum);
			}
			vector<string> ans;
			for(const auto &optional_restaurant: optional_restaurants) {
				int index_sum = index1[optional_restaurant] + index2[optional_restaurant];
				if(index_sum == min_index_sum) {
					ans.push_back(optional_restaurant);
				}
			}
			return ans;
		}
	}// namespace minimum_index_sum_of_two_lists

	namespace count_number_of_maximum_bitwise_or_subsets {
		int Solution::countMaxOrSubsets(vector<int> &nums) {
			int max = 0;
			for(const auto num: nums) {
				max |= num;
			}
			return dfs(0, max, nums);
		}

		int Solution::dfs(int current, int target, vector<int> nums) {
			if((current | target) == current) {
				return 1 << nums.size();
			}
			int sum         = 0;
			vector nums_cpy = nums;
			for(int i = 0; i < nums.size(); i++) {
				nums_cpy.erase(nums_cpy.begin());
				sum += dfs(current | nums[i], target, nums_cpy);
			}
			return sum;
		}
	}// namespace count_number_of_maximum_bitwise_or_subsets

	namespace all_oone_data_structure {
		AllOne::AllOne() {
			str_count = unordered_map<string, int>();
			count_str = map<int, unordered_set<string>>();
		}

		void AllOne::inc(const string &key) {
			const int prev = str_count[key]++;
			count_str[prev].erase(key);
			count_str[prev + 1].insert(key);
			if(count_str[prev].empty()) {
				count_str.erase(prev);
			}
			if(!count_str.empty()) {
				min = count_str.begin()->first;
				max = count_str.rbegin()->first;
			} else {
				min = 50000;
				max = 0;
			}
		}

		void AllOne::dec(const string &key) {
			const int prev = str_count[key]--;
			if(str_count[key] == 0) {
				str_count.erase(key);
			}
			count_str[prev].erase(key);
			if(count_str[prev].empty()) {
				count_str.erase(prev);
			}
			if(prev != 1) {
				count_str[prev - 1].insert(key);
			}
			if(!count_str.empty()) {
				min = count_str.begin()->first;
				max = count_str.rbegin()->first;
			} else {
				min = 50000;
				max = 0;
			}
		}

		string AllOne::getMaxKey() {
			if(str_count.empty()) {
				return "";
			}
			return *count_str[max].begin();
		}

		string AllOne::getMinKey() {
			if(str_count.empty()) {
				return "";
			}
			return *count_str[min].begin();
		}
	}// namespace all_oone_data_structure

	namespace longest_word_in_dictionary {
		string Solution::longestWord(vector<string> &words) {
			auto root = TrieNode('0');
			for(const auto &word: words) {
				root.insert(word);
			}
			return dfs("", &root);
		}

		string Solution::dfs(const string &str, TrieNode *node) {
			string ans = str;
			for(auto *next: node->nexts) {
				if(next != nullptr && next->end_of_word) {
					string ret = dfs(str + next->ch, next);
					if(ans.length() < ret.length()) {
						ans = ret;
					}
				}
			}
			return ans;
		}
	}// namespace longest_word_in_dictionary

	namespace simple_bank_system {
		Bank::Bank(vector<long long int> &balance) {
			accounts = unordered_map<int, long long>(balance.size());
			for(int i = 0; i < balance.size(); i++) {
				accounts[i + 1] = balance[i];
			}
		}

		bool Bank::transfer(int account1, int account2, long long int money) {
			if(!accounts.contains(account1) || !accounts.contains(account2)) {
				return false;
			}
			if(accounts[account1] < money) {
				return false;
			}
			accounts[account1] -= money;
			accounts[account2] += money;
			return true;
		}

		bool Bank::deposit(int account, long long int money) {
			if(!accounts.contains(account)) {
				return false;
			}
			accounts[account] += money;
			return true;
		}

		bool Bank::withdraw(int account, long long int money) {
			if(!accounts.contains(account)) {
				return false;
			}
			if(accounts[account] < money) {
				return false;
			}
			accounts[account] -= money;
			return true;
		}
	}// namespace simple_bank_system

	namespace construct_string_from_binary_tree {
		string Solution::tree2str(TreeNode *root) {
			ostringstream oss;
			oss << root->val;
			if(root->left != nullptr) {
				oss << '(' << tree2str(root->left) << ')';
			} else if(root->right != nullptr) {
				oss << "()";
			}
			if(root->right != nullptr) {
				oss << '(' << tree2str(root->right) << ')';
			}
			return oss.str();
		}
	}// namespace construct_string_from_binary_tree

	namespace maximize_number_of_subsequences_in_a_string {
		long long Solution::maximumSubsequenceCount(string text, string pattern) {
			long long ans   = 0;
			long long count = 0;
			vector<long long> p1count(text.length());
			long long p0count          = 0;
			long long p1c              = 0;
			p1count[text.length() - 1] = 0;
			for(int i = text.length() - 1; i >= 0; i--) {
				if(text[i] == pattern[1]) {
					count++;
				} else if(text[i] == pattern[0]) {
					p0count++;
				}
				if(i - 1 >= 0) {
					p1count[i - 1] = count;
				}
			}
			for(int i = 0; i < text.length(); i++) {
				if(text[i] == pattern[0]) {
					ans += p1count[i];
				}
			}
			ans += max(p0count, count);
			return ans;
		}
	}// namespace maximize_number_of_subsequences_in_a_string

	namespace minimum_operations_to_halve_array_sum {
		int Solution::halveArray(vector<int> &nums) {
			long double sum = 0;
			int ans         = 0;
			priority_queue<long double> pq;
			for(const auto num: nums) {
				pq.push(num);
				sum += num;
			}
			const long double target = sum / 2;
			while(sum > target) {
				auto num = pq.top();
				pq.pop();
				num /= 2;
				sum -= num;
				pq.push(num);
				ans++;
			}
			return ans;
		}
	}// namespace minimum_operations_to_halve_array_sum

	namespace minimum_white_tiles_after_covering_with_carpets {
		int Solution::minimumWhiteTiles(string floor, int numCarpets, int carpetLen) {
			const int n = floor.length();
			vector f(numCarpets + 1, vector<int>(n));
			f[0][0] = floor[0] % 2;
			for(int i = 1; i < n; ++i) {
				f[0][i] = f[0][i - 1] + floor[i] % 2;
			}
			for(int i = 1; i <= numCarpets; ++i) {
				// j < carpetLen 的 f[i][j] 均为 0
				for(int j = carpetLen; j < n; ++j) {
					f[i][j] = min(f[i][j - 1] + floor[j] % 2, f[i - 1][j - carpetLen]);
				}
			}
			return f[numCarpets][n - 1];
		}
	}// namespace minimum_white_tiles_after_covering_with_carpets

	namespace count_hills_and_valleys_in_an_array {
		int Solution::countHillValley(vector<int> &nums) {
			int ans      = 0;
			const auto u = unique(nums.begin(), nums.end());
			nums.erase(u, nums.end());
			for(int i = 1; i + 1 < nums.size(); i++) {
				if(nums[i] > nums[i - 1] && nums[i] > nums[i + 1] || nums[i] < nums[i - 1] && nums[i] < nums[i + 1]) {
					ans++;
				}
			}
			return ans;
		}
	}// namespace count_hills_and_valleys_in_an_array

	namespace count_collisions_on_a_road {
		int Solution::countCollisions(const string &directions) {
			int ans = 0;
			vector<char> status;
			vector<int> count;
			int current = 0;
			for(char ch: directions) {
				if(status.empty()) {
					status.push_back(ch);
					current++;
				} else {
					if(status.back() == ch) {
						current++;
					} else {
						status.push_back(ch);
						count.push_back(current);
						current = 1;
					}
				}
			}
			count.push_back(current);
			for(int i = 0; i + 1 < status.size(); i++) {
				if(status[i] == 'R' && status[i + 1] == 'L') {
					ans += count[i] + count[i + 1];
				} else if(status[i] == 'R' && status[i + 1] == 'S') {
					ans += count[i];
				} else if(status[i] == 'S' && status[i + 1] == 'L') {
					ans += count[i + 1];
				}
			}
			return ans;
		}
	}// namespace count_collisions_on_a_road

	namespace maximum_points_in_an_archery_competition {
		vector<int> Solution::maximumBobPoints(int numArrows, vector<int> &aliceArrows) {
			int maximum = 0;
			int max_n   = 0;
			for(unsigned int n = 1; n < 1 << 11; n++) {
				int rest  = numArrows;
				int score = 0;
				for(int i = 0; i <= 10; i++) {
					if((n & 1 << i) != 0) {
						score += 11 - i;
						rest -= aliceArrows[11 - i] + 1;
					}
					if(rest < 0) {
						goto NEXT_N;
					}
				}
				if(maximum < score) {
					maximum = score;
					max_n   = n;
				}
			NEXT_N:;
			}
			vector ans(aliceArrows.size(), 0);
			for(int i = 0; i <= 10; i++) {
				if((max_n & 1 << i) != 0) {
					numArrows -= aliceArrows[11 - i] + 1;
					ans[11 - i] = aliceArrows[11 - i] + 1;
				}
			}
			ans[0] += numArrows;
			return ans;
		}
	}// namespace maximum_points_in_an_archery_competition

	namespace the_time_when_the_network_becomes_idle {
		int Solution::networkBecomesIdle(vector<vector<int>> &edges, vector<int> &patience) {
			unordered_map<int, Node *> um;
			unordered_set<int> nodes;
			for(int i = 0; i < patience.size(); i++) {
				um[i] = new Node(i, patience[i]);
				nodes.insert(i);
			}
			for(auto edge: edges) {
				um[edge[0]]->linked.insert(edge[1]);
				um[edge[1]]->linked.insert(edge[0]);
			}
			auto comp = [](const pair<int, int> &s1, const pair<int, int> &s2) -> bool { return s1.second > s2.second; };
			priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(comp)> pq;
			pq.push(make_pair(0, 0));
			while(!nodes.empty()) {
				auto [num, len] = pq.top();
				pq.pop();
				if(nodes.contains(num)) {
					nodes.erase(num);
					Node *node = um[num];
					node->time = len;
					for(auto next: node->linked) {
						if(nodes.contains(next)) {
							pq.push(make_pair(next, len + 1));
						}
					}
				}
			}
			int ans = 0;
			for(auto [num, node]: um) {
				if(num != 0) {
					int resent_num = node->time * 2 / node->patience;
					if(node->time * 2 % node->patience == 0) {
						resent_num--;
					}
					ans = max(ans, resent_num * node->patience + 2 * node->time + 1);
				}
			}
			return ans;
		}
	}// namespace the_time_when_the_network_becomes_idle

	namespace two_sum_iv_input_is_a_bst {
		bool Solution::findTarget(TreeNode *root, int k) {
			set<int> s;
			unordered_map<int, int> count;
			queue<TreeNode *> que;
			que.push(root);
			while(!que.empty()) {
				const auto *node = que.front();
				que.pop();
				s.insert(node->val);
				count[node->val]++;
				if(node->left != nullptr) {
					que.push(node->left);
				}
				if(node->right != nullptr) {
					que.push(node->right);
				}
			}
			bool ans = false;
			for(auto it = s.begin(); it != s.end(); ++it) {
				int other = k - *it;
				if(other == *it) {
					if(count[other] > 1) {
						ans = true;
						break;
					}
				} else if(s.contains(other)) {
					ans = true;
					break;
				}
			}
			return ans;
		}
	}// namespace two_sum_iv_input_is_a_bst

	namespace remove_colored_pieces_if_both_neighbors_are_the_same_color {
		bool Solution::winnerOfGame(string colors) {
			int a_count = 0;
			int b_count = 0;
			vector vec(colors.length(), true);
			vec[0]                   = false;
			vec[colors.length() - 1] = false;
			for(int i = 0; i + 1 < colors.length(); i++) {
				if(colors[i] != colors[i + 1]) {
					vec[i]     = false;
					vec[i + 1] = false;
				}
			}
			for(int i = 0; i + 1 < colors.length(); i++) {
				if(vec[i]) {
					if(colors[i] == 'A') {
						a_count++;
					} else {
						b_count++;
					}
				}
			}
			return a_count > b_count;
		}
	}// namespace remove_colored_pieces_if_both_neighbors_are_the_same_color

	namespace k_th_smallest_in_lexicographical_order {
		int Solution::findKthNumber(int n, int k) {
			int curr = 1;
			k--;
			while(k > 0) {
				const int steps = getSteps(curr, n);
				if(steps <= k) {
					k -= steps;
					curr++;
				} else {
					curr = curr * 10;
					k--;
				}
			}
			return curr;
		}

		int Solution::getSteps(int curr, long n) {
			int steps  = 0;
			long first = curr;
			long last  = curr;
			while(first <= n) {
				steps += min(last, n) - first + 1;
				first = first * 10;
				last  = last * 10 + 9;
			}
			return steps;
		}
	}// namespace k_th_smallest_in_lexicographical_order

	namespace image_smoother {
		vector<vector<int>> Solution::imageSmoother(vector<vector<int>> &img) {
			const int m = img.size();
			const int n = img[0].size();
			auto ans    = vector(m, vector<int>(n));
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					pair<int, int> cells[9] = {make_pair(i - 1, j - 1), make_pair(i - 1, j), make_pair(i - 1, j + 1),
					                           make_pair(i, j - 1), make_pair(i, j), make_pair(i, j + 1),
					                           make_pair(i + 1, j - 1), make_pair(i + 1, j), make_pair(i + 1, j + 1)};
					int sum                 = 0;
					int count               = 0;
					for(int k = 0; k < 9; k++) {
						auto [x, y] = cells[k];
						if(0 <= x && x < m && 0 <= y && y < n) {
							count++;
							sum += img[x][y];
						}
					}
					ans[i][j] = sum / count;
				}
			}
			return ans;
		}
	}// namespace image_smoother

	namespace factorial_trailing_zeroes {
		int Solution::trailingZeroes(int n) {
			unsigned int pow5   = 5;
			unsigned int pow2   = 2;
			unsigned int count5 = 0;
			unsigned int count2 = 0;
			while(n / pow5 != 0) {
				count5 += n / pow5;
				pow5 *= 5;
			}
			while(n / pow2 != 0) {
				count2 += n / pow2;
				pow2 *= 2;
			}
			return min(count2, count5);
		}
	}// namespace factorial_trailing_zeroes

	namespace baseball_game {
		int Solution::calPoints(vector<string> &ops) {
			vector<int> stk;
			for(const string &op: ops) {
				if(op == "+") {
					const int score1 = stk.back();
					const int score2 = *(stk.rbegin() + 1);
					stk.push_back(score1 + score2);
				} else if(op == "D") {
					stk.push_back(2 * stk.back());
				} else if(op == "C") {
					stk.pop_back();
				} else {
					stringstream ss;
					ss << op;
					int score;
					ss >> score;
					stk.push_back(score);
				}
			}
			int ans = 0;
			for(const auto score: stk) {
				ans += score;
			}
			return ans;
		}
	}// namespace baseball_game

	namespace minimum_deletions_to_make_array_beautiful {
		int Solution::minDeletion(vector<int> &nums) {
			vector<int> indexes;
			for(int i = 0; i + 1 < nums.size(); i++) {
				if(nums[i] == nums[i + 1]) {
					indexes.push_back(i);
				}
			}
			int ans   = 0;
			bool even = true;
			for(const auto index: indexes) {
				if(even && index % 2 == 0 || !even && index % 2 != 0) {
					ans++;
					even = !even;
				}
			}
			if((nums.size() - ans) % 2 != 0) {
				ans++;
			}
			return ans;
		}
	}// namespace minimum_deletions_to_make_array_beautiful

	namespace find_palindrome_with_fixed_length {
		unsigned long long qmi(unsigned long long m, unsigned long long k) {
			unsigned long long res = 1;
			unsigned long long t   = m;
			while(k != 0U) {
				if((k & 1) != 0U) {
					res = res * t;
				}
				t = t * t;
				k >>= 1;
			}
			return res;
		}

		vector<long long> Solution::kthPalindrome(vector<int> &queries, int intLength) {
			vector<long long> ans;
			if(intLength == 1) {
				for(auto query: queries) {
					if(query < 10) {
						ans.push_back(query);
					} else {
						ans.push_back(-1);
					}
				}
				return ans;
			}
			if(intLength == 2) {
				for(auto query: queries) {
					if(query < 10) {
						ans.push_back(query * 10 + query);
					} else {
						ans.push_back(-1);
					}
				}
				return ans;
			}
			int n = (intLength + 1) / 2;
			vector<unsigned long long> q10(n + 1);
			for(int i = 1; i <= n; i++) {
				q10[i] = qmi(10, n - i);
			}
			for(auto query: queries) {
				vector<unsigned long long> num;
				int n1 = query / q10[1] + 1;
				if(n1 == 10 && query % q10[1] == 0) {
					stringstream ss;
					for(int i = 0; i < intLength; i++) {
						ss << 9;
					}
					long long res;
					ss >> res;
					ans.push_back(res);
					continue;
				}
				if(n1 > 9) {
					ans.push_back(-1);
					continue;
				}
				if(n1 < 10 && query % q10[1] == 0) {
					n1--;
					query = (query - 1) % q10[1] + 1;
				} else {
					query %= q10[1];
				}
				num.push_back(n1);
				for(int i = 2; i <= n; i++) {
					int digit = query / q10[i];
					if(i == n) {
						digit--;
					} else if(query != q10[i] && query % q10[i] == 0) {
						digit--;
					} else if(query == q10[i]) {
						digit = 0;
					}
					query %= q10[i];
					num.push_back((digit + 10) % 10);
				}
				stringstream ss;
				for(int digit: num) {
					ss << digit;
				}
				int i = num.size() - 1;
				if(intLength % 2 != 0) {
					i--;
				}
				while(i >= 0) {
					ss << num[i];
					--i;
				}
				long long res;
				ss >> res;
				ans.push_back(res);
			}
			return ans;
		}
	}// namespace find_palindrome_with_fixed_length

	namespace find_missing_observations {
		vector<int> Solution::missingRolls(vector<int> &rolls, int mean, int n) {
			const int m = rolls.size();
			int sum     = (m + n) * mean;
			for(const auto roll: rolls) {
				sum -= roll;
			}
			if(sum < n || sum > 6 * n) {
				return {};
			}
			vector ans(n, sum / n);
			sum %= n;
			for(int i = 0; i < sum; i++) {
				ans[i]++;
			}
			return ans;
		}
	}// namespace find_missing_observations

	namespace binary_number_with_alternating_bits {
		bool Solution::hasAlternatingBits(int n) {
			stringstream ss;
			while(n != 0) {
				ss << n % 2;
				n /= 2;
			}
			string str;
			ss >> str;
			for(int i = 0; i + 1 < str.length(); i++) {
				if(str[i] == str[i + 1]) {
					return false;
				}
			}
			return true;
		}
	}// namespace binary_number_with_alternating_bits

	namespace maximize_the_confusion_of_an_exam {
		int Solution::maxConsecutiveAnswers(string answerKey, int k) {
			if(answerKey.length() == 1) {
				return 1;
			}
			vector<int> t_count(answerKey.length());
			vector<int> f_count(answerKey.length());
			int t_current = 0;
			int f_current = 0;
			for(int i = 0; i < t_count.size(); i++) {
				if(answerKey[i] == 'T') {
					t_current++;
				} else {
					f_current++;
				}
				t_count[i] = t_current;
				f_count[i] = f_current;
			}
			int l      = 1;
			int r      = answerKey.size();
			auto check = [&answerKey, &t_count, &f_count, &k](int len) -> bool {
				for(int i = 0; i + len <= answerKey.length(); i++) {
					int tc = t_count[i + len - 1] - (i - 1 >= 0 ? t_count[i - 1] : 0);
					int fc = f_count[i + len - 1] - (i - 1 >= 0 ? f_count[i - 1] : 0);
					if(min(tc, fc) <= k) {
						return true;
					}
				}
				return false;
			};
			while(l < r) {
				if(l + 1 == r) {
					if(check(r)) {
						return r;
					}
					return l;
				}
				const int mid = (l + r) / 2;
				if(check(mid)) {
					l = mid;
				} else {
					r = mid;
				}
			}
			return -1;
		}
	}// namespace maximize_the_confusion_of_an_exam

	namespace find_servers_that_handled_most_number_of_requests {
		vector<int> Solution::busiestServers(int k, vector<int> &arrival, vector<int> &load) {
			vector<int> ans;
			vector count(k, 0);
			set<int> available;
			for(int i = 0; i < k; i++) {
				available.insert(i);
			}
			priority_queue<event> events;
			for(int i = 0; i < arrival.size(); i++) {
				event e = {arrival[i], true, i};
				events.push(e);
			}
			while(!events.empty()) {
				event e = events.top();
				events.pop();
				if(e.start) {
					if(!available.empty()) {
						auto it = available.lower_bound(e.index % k);
						if(it == available.end()) {
							it = available.begin();
						}
						event next = {e.time + load[e.index], false, e.index, *it};
						events.push(next);
						available.erase(it);
					}
				} else {
					//end
					available.insert(e.server_index);
					count[e.server_index]++;
				}
			}
			const int maximum = *max_element(count.begin(), count.end());
			for(int i = 0; i < k; i++) {
				if(count[i] == maximum) {
					ans.push_back(i);
				}
			}
			return ans;
		}

		bool event::operator<(const event &e) const {
			if(this->time != e.time) {
				return this->time > e.time;
			}
			return this->start;
		}
	}// namespace find_servers_that_handled_most_number_of_requests

	namespace self_dividing_numbers {
		vector<int> Solution::selfDividingNumbers(int left, int right) {
			vector<int> ans;
			for(int i = left; i <= right; ++i) {
				stringstream ss;
				ss << i;
				char ch;
				bool flag = true;
				while(ss >> ch) {
					const int num = ch - '0';
					if(num == 0) {
						flag = false;
						break;
					}
					if(i % num != 0) {
						flag = false;
						break;
					}
				}
				if(flag) {
					ans.push_back(i);
				}
			}
			return ans;
		}
	}// namespace self_dividing_numbers

	namespace array_of_doubled_pairs {
		bool Solution::canReorderDoubled(vector<int> &arr) {
			multiset<int> positive;
			multiset<int, greater<>> negative;
			for(auto num: arr) {
				if(num >= 0) {
					positive.insert(num);
				} else {
					negative.insert(num);
				}
			}
			while(!positive.empty()) {
				const int num = *positive.begin();
				positive.erase(positive.begin());
				auto it = positive.find(num * 2);
				if(it == positive.end()) {
					return false;
				}
				positive.erase(it);
			}
			while(!negative.empty()) {
				const int num = *negative.begin();
				negative.erase(negative.begin());
				auto it = negative.find(num * 2);
				if(it == negative.end()) {
					return false;
				}
				negative.erase(it);

				negative.erase(it);
			}
			return true;
		}
	}// namespace array_of_doubled_pairs

	namespace strong_password_checker {
		int Solution::strongPasswordChecker(const string &password) {
			const int n    = password.length();
			bool has_lower = false;
			bool has_upper = false;
			bool has_digit = false;
			for(const char ch: password) {
				if(islower(ch) != 0) {
					has_lower = true;
				} else if(isupper(ch) != 0) {
					has_upper = true;
				} else if(isdigit(ch) != 0) {
					has_digit = true;
				}
			}
			const int categories = static_cast<int>(has_lower) + static_cast<int>(has_upper) + static_cast<int>(has_digit);

			if(n < 6) {
				return max(6 - n, 3 - categories);
			}
			if(n <= 20) {
				int replace  = 0;
				int count    = 0;
				char current = '#';

				for(const char ch: password) {
					if(ch == current) {
						++count;
					} else {
						replace += count / 3;
						count   = 1;
						current = ch;
					}
				}
				replace += count / 3;
				return max(replace, 3 - categories);
			}
			// 替换次数和删除次数
			int replace = 0;
			int remove  = n - 20;
			// k mod 3 = 1 的组数，即删除 2 个字符可以减少 1 次替换操作
			int rm2   = 0;
			int count = 0;
			char cur  = '#';

			for(const char ch: password) {
				if(ch == cur) {
					++count;
				} else {
					if(remove > 0 && count >= 3) {
						if(count % 3 == 0) {
							// 如果是 k % 3 = 0 的组，那么优先删除 1 个字符，减少 1 次替换操作
							--remove;
							--replace;
						} else if(count % 3 == 1) {
							// 如果是 k % 3 = 1 的组，那么存下来备用
							++rm2;
						}
						// k % 3 = 2 的组无需显式考虑
					}
					replace += count / 3;
					count = 1;
					cur   = ch;
				}
			}
			if(remove > 0 && count >= 3) {
				if(count % 3 == 0) {
					--remove;
					--replace;
				} else if(count % 3 == 1) {
					++rm2;
				}
			}
			replace += count / 3;

			// 使用 k % 3 = 1 的组的数量，由剩余的替换次数、组数和剩余的删除次数共同决定
			const int use2 = min({replace, rm2, remove / 2});
			replace -= use2;
			remove -= use2 * 2;
			// 由于每有一次替换次数就一定有 3 个连续相同的字符（k / 3 决定），因此这里可以直接计算出使用 k % 3 = 2 的组的数量
			const int use3 = min(replace, remove / 3);
			replace -= use3;
			remove -= use3 * 3;
			return n - 20 + max(replace, 3 - categories);
		}
	}// namespace strong_password_checker

	namespace number_of_ways_to_select_buildings {
		long long Solution::numberOfWays(string s) {
			const unsigned int n = s.length();
			vector<unsigned int> prev0(n, 0);
			vector<unsigned int> prev1(n, 0);
			vector<unsigned int> post0(n, 0);
			vector<unsigned int> post1(n, 0);
			unsigned current0 = 0;
			unsigned current1 = 0;
			for(int i = 0; i < n; i++) {
				prev0[i] = current0;
				prev1[i] = current1;
				if(s[i] == '0') {
					current0++;
				} else {
					current1++;
				}
			}
			current0 = 0;
			current1 = 0;
			for(int i = n - 1; i >= 0; i--) {
				post0[i] = current0;
				post1[i] = current1;
				if(s[i] == '0') {
					current0++;
				} else {
					current1++;
				}
			}
			long long ans = 0;
			for(unsigned i = 0; i < n; i++) {
				if(s[i] == '0') {
					ans += static_cast<long long>(prev1[i]) * post1[i];
				} else {
					ans += static_cast<long long>(prev0[i]) * post0[i];
				}
			}
			return ans;
		}
	}// namespace number_of_ways_to_select_buildings

	namespace sum_of_scores_of_built_strings {
		long long Solution::sumScores(string s) {
			const int n   = s.length();
			long long ans = n;
			int l         = 0;
			int r         = 0;
			vector z(n, 0);
			for(int i = 1; i < n; ++i) {
				if(i <= r && z[i - l] < r - i + 1) {
					z[i] = z[i - l];
				} else {
					z[i] = max(0, r - i + 1);
					while(i + z[i] < n && s[z[i]] == s[i + z[i]]) {
						++z[i];
					}
				}
				if(i + z[i] - 1 > r) {
					l = i;
					r = i + z[i] - 1;
				}
				ans += z[i];
			}
			return ans;
		}
	}// namespace sum_of_scores_of_built_strings

	/**
	 * \brief 6055. Minimum Number of Operations to Convert Time
	 */
	namespace minimum_number_of_operations_to_convert_time {
		int Solution::convertTime(string current, string correct) {
			const int current_h = (current[0] - '0') * 10 + (current[1] - '0');
			const int current_m = (current[3] - '0') * 10 + (current[4] - '0');
			const int correct_h = (correct[0] - '0') * 10 + (correct[1] - '0');
			const int correct_m = (correct[3] - '0') * 10 + (correct[4] - '0');
			int diff            = correct_h * 60 + correct_m - (current_h * 60 + current_m);
			if(diff < 0) {
				diff += 24 * 60;
			}
			int ans = 0;
			ans += diff / 60;
			diff %= 60;
			ans += diff / 15;
			diff %= 15;
			ans += diff / 5;
			diff %= 5;
			ans += diff;
			return ans;
		}
	}// namespace minimum_number_of_operations_to_convert_time

	/**
	 * \brief 5235. Find Players With Zero or One Losses
	 */
	namespace find_players_with_zero_or_one_losses {
		vector<vector<int>> Solution::findWinners(vector<vector<int>> &matches) {
			map<unsigned, unsigned> lose;
			for(auto match: matches) {
				lose[match[0]] += 0;
				lose[match[1]] += 1;
			}
			vector<vector<int>> ans(2);
			vector<int> ans1;
			vector<int> ans2;
			for(auto [player, count]: lose) {
				if(count == 0) {
					ans1.push_back(player);
				} else if(count == 1) {
					ans2.push_back(player);
				}
			}
			ans[0] = ans1;
			ans[1] = ans2;
			return ans;
		}
	}// namespace find_players_with_zero_or_one_losses

	/**
	 * \brief 5219. Maximum Candies Allocated to K Children
	 */
	namespace maximum_candies_allocated_to_k_children {
		int Solution::maximumCandies(vector<int> &candies, long long k) {
			sort(candies.begin(), candies.end());
			long long sum = 0;
			for(const auto candy: candies) {
				sum += candy;
			}
			int l = 1;
			int r = sum / k;
			if(sum < k) {
				return 0;
			}
			while(l < r) {
				if(l + 1 == r) {
					unsigned long long count = 0;
					for(auto it = candies.rbegin(); it != candies.rend() && *it >= r; ++it) {
						count += *it / r;
						if(count > k) {
							break;
						}
					}
					if(count > k) {
						return r;
					}
					return l;
				}
				const int m              = (l + r) / 2;
				unsigned long long count = 0;
				for(auto it = candies.rbegin(); it != candies.rend() && *it >= m; ++it) {
					count += *it / m;
					if(count > k) {
						break;
					}
				}
				if(count >= k) {
					l = m;
				} else if(count < k) {
					r = m;
				}
			}
			return (l + r) / 2;
		}
	}// namespace maximum_candies_allocated_to_k_children

	namespace encrypt_and_decrypt_strings {
		Encrypter::Encrypter(vector<char> &keys, vector<string> &values, vector<string> &dictionary) {
			for(int i = 0; i < keys.size(); ++i) {
				mp[keys[i] - 'a'] = values[i];
			}
			for(const auto &s: dictionary) {
				++count[encrypt(s)];
			}
		}

		string Encrypter::encrypt(const string &word1) const {
			string res;
			for(const char ch: word1) {
				const auto &s = mp[ch - 'a'];
				if(s.empty()) {
					return "";
				}
				res += s;
			}
			return res;
		}

		int Encrypter::decrypt(const string &word2) {
			if(count.contains(word2)) {
				count[word2] += 0;
				return count[word2];
			}
			// 防止把不在 cnt 中的字符串加进去
			return 0;
		}
	}// namespace encrypt_and_decrypt_strings

	namespace range_sum_query_mutable {
		NumArray::NumArray(vector<int> &nums)
		    : nums(nums) {
			const int n = nums.size();
			size        = sqrt(n);
			sum.resize((n + size - 1) / size);// n/size 向上取整
			for(int i = 0; i < n; i++) {
				sum[i / size] += nums[i];
			}
		}

		void NumArray::update(int index, int val) {
			sum[index / size] += val - nums[index];
			nums[index] = val;
		}

		int NumArray::sumRange(int left, int right) const {
			const int b1 = left / size;
			const int i1 = left % size;
			const int b2 = right / size;
			const int i2 = right % size;
			if(b1 == b2) {
				// 区间 [left, right] 在同一块中
				return accumulate(nums.begin() + b1 * size + i1, nums.begin() + b1 * size + i2 + 1, 0);
			}
			const int sum1 = accumulate(nums.begin() + b1 * size + i1, nums.begin() + b1 * size + size, 0);
			const int sum2 = accumulate(nums.begin() + b2 * size, nums.begin() + b2 * size + i2 + 1, 0);
			const int sum3 = accumulate(sum.begin() + b1 + 1, sum.begin() + b2, 0);
			return sum1 + sum2 + sum3;
		}
	}// namespace range_sum_query_mutable

	namespace process_restricted_friend_requests {
		vector<bool> Solution::friendRequests(int n, vector<vector<int>> &restrictions, vector<vector<int>> &requests) {
			UnionFind uf(n);
			vector<bool> ans(requests.size());
			auto check = [&uf, &restrictions](int x, int y) -> bool {
				x = uf.find(x);
				y = uf.find(y);
				if(x > y) {
					swap(x, y);
				}
				for(auto &restriction: restrictions) {
					int i = uf.find(restriction[0]);
					int j = uf.find(restriction[1]);
					if(i > j) {
						swap(i, j);
					}
					if(i == x && j == y) {
						return false;
					}
				}
				return true;
			};
			for(int i = 0; i < requests.size(); i++) {
				if(check(requests[i][0], requests[i][1])) {
					uf.unite(requests[i][0], requests[i][1]);
					ans[i] = true;
				} else {
					ans[i] = false;
				}
			}
			return ans;
		}
	}// namespace process_restricted_friend_requests

	namespace prime_number_of_set_bits_in_binary_representation {
		int Solution::countPrimeSetBits(int left, int right) {
			int ans = 0;
			const unordered_set primes{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61};
			for(unsigned i = left; i <= right; i++) {
				if(primes.contains(popcount(i))) {
					ans++;
				}
			}
			return ans;
		}
	}// namespace prime_number_of_set_bits_in_binary_representation

	namespace minimum_height_trees {
		vector<int> Solution::findMinHeightTrees(int n, vector<vector<int>> &edges) {
			if(n == 1) {
				return {0};
			}
			vector<vector<int>> adj(n);
			for(auto &edge: edges) {
				adj[edge[0]].emplace_back(edge[1]);
				adj[edge[1]].emplace_back(edge[0]);
			}

			vector parent(n, -1);
			/* 找到与节点 0 最远的节点 x */
			const int x = findLongestNode(0, parent, adj);
			/* 找到与节点 x 最远的节点 y */
			int y = findLongestNode(x, parent, adj);
			/* 求出节点 x 到节点 y 的路径 */
			vector<int> path;
			parent[x] = -1;
			while(y != -1) {
				path.emplace_back(y);
				y = parent[y];
			}
			const int m = path.size();
			if(m % 2 == 0) {
				return {path[m / 2 - 1], path[m / 2]};
			}
			return {path[m / 2]};
		}

		int Solution::findLongestNode(int u, vector<int> &parent, vector<vector<int>> &adj) {
			const int n = adj.size();
			queue<int> qu;
			vector<bool> visit(n);
			qu.emplace(u);
			visit[u] = true;
			int node = -1;

			while(!qu.empty()) {
				const int curr = qu.front();
				qu.pop();
				node = curr;
				for(auto &v: adj[curr]) {
					if(!visit[v]) {
						visit[v]  = true;
						parent[v] = curr;
						qu.emplace(v);
					}
				}
			}
			return node;
		}
	}// namespace minimum_height_trees

	namespace rotate_string {
		bool Solution::rotateString(string s, const string &goal) {
			if(s.length() != goal.length()) {
				return false;
			}
			s += s;
			return s.find(goal) != string::npos;
		}
	}// namespace rotate_string

	namespace n_ary_tree_level_order_traversal {
		vector<vector<int>> Solution::levelOrder(Node *root) {
			queue<pair<int, Node *>> q;
			vector<vector<int>> ans;
			if(root == nullptr) {
				return ans;
			}
			q.push(make_pair(0, root));
			while(!q.empty()) {
				auto [level, node] = q.front();
				if(ans.size() == level) {
					ans.emplace_back();
				}
				ans[level].push_back(node->val);
				q.pop();
				for(auto *next: node->children) {
					q.push(make_pair(level + 1, next));
				}
			}
			return ans;
		}
	}// namespace n_ary_tree_level_order_traversal

	namespace reaching_points {
		bool Solution::reachingPoints(int sx, int sy, int tx, int ty) {
			while(tx > sx && ty > sy && tx != ty) {
				if(tx > ty) {
					tx %= ty;
				} else {
					ty %= tx;
				}
			}
			if(tx == sx && ty == sy) {
				return true;
			}
			if(tx == sx) {
				return ty > sy && (ty - sy) % tx == 0;
			}
			if(ty == sy) {
				return tx > sx && (tx - sx) % ty == 0;
			}
			return false;
		}
	}// namespace reaching_points

	namespace maximum_product_after_k_increments {
		int Solution::maximumProduct(vector<int> &nums, int k) {
			priority_queue<int, vector<int>, greater<int>> pq;
			for(auto num: nums) {
				pq.push(num);
			}
			while(k-- != 0) {
				const int num = pq.top();
				pq.pop();
				pq.push(num + 1);
			}
			long long ans = 1;
			while(!pq.empty()) {
				const int num = pq.top();
				pq.pop();
				ans *= num;
				ans %= 1000000007;
			}
			return ans;
		}
	}// namespace maximum_product_after_k_increments

	namespace maximum_total_beauty_of_the_gardens {
		long long Solution::maximumBeauty(vector<int> &flowers, long long newFlowers, int target, int full, int partial) {
			const int n = flowers.size();
			sort(flowers.begin(), flowers.end());
			for(int i = 0; i < n; i++) {
				flowers[i] = min(flowers[i], target);
			}
			long long ans = 0;
			vector<long long> sum(n + 1, 0);///< 当前项之前的和
			for(int i = 0; i < n; i++) {
				sum[i + 1] = sum[i] + flowers[i];
			}
			for(int i = 0, j = 0; i <= n; i++) {
				const long long rest = newFlowers - (static_cast<long long>(target) * (n - i) - (sum[n] - sum[i]));///< 补齐后n-i项到target后剩余的
				if(rest >= 0) {
					while(j < i && rest >= static_cast<long long>(flowers[j]) * j - sum[j]) {
						//将前j项补齐到flowers[j]
						j++;
					}
					ans = max(ans, static_cast<long long>(full) * (n - i) + (j == 0 ? 0 : static_cast<long long>(partial) * min(static_cast<long long>(target - 1), (rest + sum[j]) / j)));
				}
				if(i < n && flowers[i] == target) {
					break;
				}
			}
			return ans;
		}
	}// namespace maximum_total_beauty_of_the_gardens

	namespace count_numbers_with_unique_digits {
		int Solution::countNumbersWithUniqueDigits(int n) {
			if(n == 0) {
				return 1;
			}
			vector<int> dp(n + 1);
			dp[1] = 9;
			for(int i = 2; i <= n; ++i) {
				dp[i] = dp[i - 1] * (10 - (i - 1));
			}
			int ans = 0;
			for(int i = 1; i <= n; ++i) {
				ans += dp[i];
			}
			return ans + 1;
		}
	}// namespace count_numbers_with_unique_digits

	namespace number_of_lines_to_write_string {
		vector<int> Solution::numberOfLines(vector<int> &widths, string s) {
			int lines   = 1;
			int current = 0;
			for(int i = 0; i < s.length(); i++) {
				if(current + widths[s[i] - 'a'] > 100) {
					current = 0;
					lines++;
				}
				current += widths[s[i] - 'a'];
			}
			return {lines, current};
		}
	}// namespace number_of_lines_to_write_string

	namespace permutation_in_string {
		bool Solution::checkInclusion(const string &s1, string s2) {
			if(s1.length() > s2.length()) {
				return false;
			}
			unordered_map<char, int> um1;
			unordered_map<char, int> um2;
			for(char ch: s1) {
				um1[ch]++;
			}
			for(int i = 0; i < s1.length(); i++) {
				um2[s2[i]]++;
			}
			if(um2 == um1) {
				return true;
			}
			for(int i = 0; i + s1.length() < s2.length(); i++) {
				um2[s2[i]]--;
				um2[s2[i + s1.length()]]++;
				if(um2[s2[i]] == 0) {
					um2.erase(s2[i]);
				}
				if(um2 == um1) {
					return true;
				}
			}
			return false;
		}
	}// namespace permutation_in_string

	namespace insert_delete_getrandom_o1 {
		RandomizedSet::RandomizedSet() {
			generator    = default_random_engine(time(nullptr));
			distribution = uniform_int_distribution(0, INT_MAX);
		}

		bool RandomizedSet::insert(int val) {
			if(static_cast<unsigned int>(map.contains(val)) != 0U) {
				return false;
			}
			nums.push_back(val);
			map[val] = nums.size() - 1;
			return true;
		}

		bool RandomizedSet::remove(int val) {
			if(static_cast<unsigned int>(map.contains(val)) == 0U) {
				return false;
			}
			const int index = map[val];
			const int last  = nums.back();
			nums[index]     = last;
			map[last]       = index;
			nums.pop_back();
			map.erase(val);
			return true;
		}

		int RandomizedSet::getRandom() { return nums[distribution(generator) % nums.size()]; }
	}// namespace insert_delete_getrandom_o1

	namespace projection_area_of_3d_shapes {
		int Solution::projectionArea(vector<vector<int>> &grid) {
			const int n  = grid.size();
			int xy       = 0;
			int xz       = 0;
			int yz       = 0;
			auto grid_xz = vector(51, vector(51, 0));
			auto grid_yz = vector(51, vector(51, 0));
			for(int i = 0; i < n; i++) {
				for(int j = 0; j < n; j++) {
					if(grid[i][j] != 0) {
						xy++;
					}
					for(int k = 0; k < grid[i][j]; k++) {
						grid_xz[i][k] = 1;
						grid_yz[j][k] = 1;
					}
				}
			}
			for(int i = 0; i < 51; i++) {
				for(int j = 0; j < 51; j++) {
					if(grid_xz[i][j] != 0) {
						xz++;
					}
					if(grid_yz[i][j] != 0) {
						yz++;
					}
				}
			}
			return xy + yz + xz;
		}
	}// namespace projection_area_of_3d_shapes

	namespace design_parking_system {
		ParkingSystem::ParkingSystem(int big, int medium, int small)
		    : big(big), medium(medium), small(small) {}

		bool ParkingSystem::addCar(int carType) {
			switch(carType) {
				case 1: {
					if(big > 0) {
						big--;
						return true;
					}
					return false;
				}
				case 2: {
					if(medium > 0) {
						medium--;
						return true;
					}
					return false;
				}
				case 3: {
					if(small > 0) {
						small--;
						return true;
					}
					return false;
				}
				default: return false;
			}
		}
	}// namespace design_parking_system

	namespace range_sum_query_immutable {
		NumArray::NumArray(vector<int> &nums) {
			pref_sum    = vector<int>(nums.size());
			pref_sum[0] = nums[0];
			for(int i = 1; i < nums.size(); i++) {
				pref_sum[i] = pref_sum[i - 1] + nums[i];
			}
		}

		int NumArray::sumRange(int left, int right) const { return pref_sum[right] - (left - 1 >= 0 ? pref_sum[left - 1] : 0); }
	}// namespace range_sum_query_immutable

	namespace house_robber {
		int Solution::rob(vector<int> &nums) {
			if(nums.size() == 1) {
				return nums[0];
			}
			vector<int> dp(nums.size());
			dp[0] = nums[0];
			dp[1] = max(nums[0], nums[1]);
			for(int i = 2; i < nums.size(); i++) {
				dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
			}
			return dp[nums.size() - 1];
		}
	}// namespace house_robber

	namespace triangle {
		int Solution::minimumTotal(vector<vector<int>> &triangle) {
			vector<vector<int>> dp = triangle;
			for(int i = 1; i < triangle.size(); i++) {
				for(int j = 0; j < triangle[i].size(); j++) {
					if(j == 0) {
						dp[i][j] = dp[i - 1][j] + triangle[i][j];
					} else if(j == triangle[i].size() - 1) {
						dp[i][j] = dp[i - 1][j - 1] + triangle[i][j];
					} else {
						dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - 1]) + triangle[i][j];
					}
				}
			}
			int ans = dp.back()[0];
			for(int i = 0; i < dp.back().size(); i++) {
				ans = min(ans, dp.back()[i]);
			}
			return ans;
		}
	}// namespace triangle

	namespace lowest_common_ancestor_of_a_binary_search_tree {
		TreeNode *Solution::lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q) {
			auto *const tnp = new TreeNodeP(root->val);
			TreeNodeP *pp;
			TreeNodeP *qq;
			copy(root, tnp, p->val, q->val, &pp, &qq);
			TreeNodeP *current = pp;
			while(current != nullptr) {
				current->ed = true;
				current     = current->parent;
			}
			current = qq;
			while(current != nullptr) {
				if(current->ed) {
					return current->mirror;
				}
				current = current->parent;
			}
			return root;
		}

		void Solution::copy(TreeNode *tn, TreeNodeP *tnp, int low, int high, TreeNodeP **p, TreeNodeP **q) {
			tnp->mirror = tn;
			if(tn->val == low) {
				*p = tnp;
			} else if(tn->val == high) {
				*q = tnp;
			}
			if(tn->left != nullptr) {
				tnp->left         = new TreeNodeP(tn->left->val);
				tnp->left->parent = tnp;
				copy(tn->left, tnp->left, low, high, p, q);
			}
			if(tn->right != nullptr) {
				tnp->right         = new TreeNodeP(tn->right->val);
				tnp->right->parent = tnp;
				copy(tn->right, tnp->right, low, high, p, q);
			}
		}
	}// namespace lowest_common_ancestor_of_a_binary_search_tree

	namespace shuffle_an_array {
		vector<int> Solution::reset() { return nums; }

		vector<int> Solution::shuffle() const {
			vector<int> ans;
			vector<int> cpy = nums;
			while(!cpy.empty()) {
				const int idx = rand() % cpy.size();
				ans.emplace_back(cpy[idx]);
				cpy.erase(cpy.begin() + idx);
			}
			return ans;
		}

		Solution::Solution(vector<int> &nums)
		    : nums(nums) { srand(time(nullptr)); }
	}// namespace shuffle_an_array

	namespace find_all_anagrams_in_a_string {
		vector<int> Solution::findAnagrams(string s, const string &p) {
			vector<int> ans;
			unordered_map<char, int> um_p;
			for(char ch: p) {
				um_p[ch]++;
			}
			unordered_map<char, int> um_s;
			for(int i = 0; i < p.length(); i++) {
				um_s[s[i]]++;
			}
			if(um_s == um_p) {
				ans.emplace_back(0);
			}
			for(int i = p.length(); i < s.length(); i++) {
				um_s[s[i]]++;
				um_s[s[i - p.length()]]--;
				if(um_s[s[i - p.length()]] == 0) {
					um_s.erase(s[i - p.length()]);
				}
				if(um_s == um_p) {
					ans.emplace_back(i - p.length() + 1);
				}
			}
			return ans;
		}
	}// namespace find_all_anagrams_in_a_string

	namespace subarray_product_less_than_k {
		int Solution::numSubarrayProductLessThanK(vector<int> &nums, int k) {
			int ans  = 0;
			int prod = 1;
			int i    = 0;
			for(int j = 0; j < nums.size(); j++) {
				prod *= nums[j];
				while(i <= j && prod >= k) {
					prod /= nums[i];
					i++;
				}
				ans += j - i + 1;
			}
			return ans;
		}
	}// namespace subarray_product_less_than_k

	namespace minimum_size_subarray_sum {
		int Solution::minSubArrayLen(int target, vector<int> &nums) {
			int r   = nums.size() - 1;
			int l   = r;
			int sum = nums[r];
			int ans = 0;
			while(l >= 0 && l <= r) {
				if(nums[l] >= target) {
					return 1;
				}
				while(l - 1 >= 0 && sum + nums[l - 1] < target) {
					sum += nums[--l];
				}
				if(l - 1 >= 0) {
					l--;
					sum += nums[l];
					if(ans == 0) {
						ans = r - l + 1;
					} else {
						ans = min(ans, r - l + 1);
					}
				} else {
					break;
				}
				do {
					sum -= nums[r--];
					if(sum >= target) {
						ans = min(ans, r - l + 1);
					}
				} while(sum >= target && r >= l);
			}
			return ans;
		}
	}// namespace minimum_size_subarray_sum

	namespace populating_next_right_pointers_in_each_node_ii {
		Node *Solution::connect(Node *root) {
			if(root == nullptr) {
				return nullptr;
			}
			int prev_level  = 0;
			Node *prev_node = root;
			queue<pair<int, Node *>> q;
			if(root->left != nullptr) {
				q.emplace(1, root->left);
			}
			if(root->right != nullptr) {
				q.emplace(1, root->right);
			}
			while(!q.empty()) {
				auto [level, node] = q.front();
				q.pop();
				if(level == prev_level) {
					prev_node->next = node;
				}
				prev_level = level;
				prev_node  = node;
				if(node->left != nullptr) {
					q.emplace(level + 1, node->left);
				}
				if(node->right != nullptr) {
					q.emplace(level + 1, node->right);
				}
			}
			return root;
		}
	}// namespace populating_next_right_pointers_in_each_node_ii

	namespace subtree_of_another_tree {
		bool Solution::isSubtree(TreeNode *root, TreeNode *subRoot) {
			if(root == nullptr) {
				return false;
			}
			queue<TreeNode *> q;
			q.push(root);
			while(!q.empty()) {
				auto *const node = q.front();
				q.pop();
				if(equal(node, subRoot)) {
					return true;
				}
				if(node->left != nullptr) {
					q.push(node->left);
				}
				if(node->right != nullptr) {
					q.push(node->right);
				}
			}
			return false;
		}

		bool Solution::equal(TreeNode *tn1, TreeNode *tn2) {
			if(static_cast<int>(tn1 == nullptr) + static_cast<int>(tn2 == nullptr) == 1) {
				return false;
			}
			if(tn1 == nullptr && tn2 == nullptr) {
				return true;
			}
			if(tn1->val != tn2->val) {
				return false;
			}
			if(static_cast<int>(tn1->left == nullptr) + static_cast<int>(tn2->left == nullptr) == 1) {
				return false;
			}
			if(static_cast<int>(tn1->right == nullptr) + static_cast<int>(tn2->right == nullptr) == 1) {
				return false;
			}
			return equal(tn1->left, tn2->left) && equal(tn1->right, tn2->right);
		}
	}// namespace subtree_of_another_tree

	namespace shortest_path_in_binary_matrix {
		int Solution::shortestPathBinaryMatrix(vector<vector<int>> &grid) {
			int n       = grid.size();
			auto levels = vector(n, vector(n, -1));
			auto cmp    = [&n](const tuple<int, int, int> &t1, const tuple<int, int, int> &t2) {
                const auto &[level1, x1, y1] = t1;
                const auto &[level2, x2, y2] = t2;
                const int dx1                = abs(n - 1 - x1);
                const int dy1                = abs(n - 1 - y1);
                const int dx2                = abs(n - 1 - x2);
                const int dy2                = abs(n - 1 - y2);
                return level1 + dx1 + dy1 - min(dx1, dy1) > level2 + dx2 + dy2 - min(dx2, dy2);
			};
			priority_queue<tuple<int, int, int>, vector<tuple<int, int, int>>, decltype(cmp)> pq(cmp);
			if(grid[0][0] == 0 && grid[n - 1][n - 1] == 0) {
				pq.push(make_tuple(1, 0, 0));
			} else {
				return -1;
			}
			while(!pq.empty()) {
				auto [level, x, y] = pq.top();
				if(x == n - 1 && y == n - 1) {
					return level;
				}
				pq.pop();
				if(levels[x][y] == -1 || levels[x][y] > level) {
					levels[x][y] = level;
				} else {
					continue;
				}
				pair<int, int> nexts[8] = {make_pair(x - 1, y - 1), make_pair(x - 1, y), make_pair(x - 1, y + 1),
				                           make_pair(x, y - 1), make_pair(x, y + 1),
				                           make_pair(x + 1, y - 1), make_pair(x + 1, y), make_pair(x + 1, y + 1)};
				for(auto [next_x, next_y]: nexts) {
					if(next_x >= 0 && next_x < n && next_y >= 0 && next_y < n && grid[next_x][next_y] == 0 && (levels[next_x][next_y] == -1 || levels[next_x][next_y] > level + 1)) {
						pq.push(make_tuple(level + 1, next_x, next_y));
					}
				}
			}
			return -1;
		}
	}// namespace shortest_path_in_binary_matrix

	namespace surrounded_regions {
		void Solution::solve(vector<vector<char>> &board) {
			const int m = board.size();
			const int n = board[0].size();
			for(int i = 0; i < n; i++) {
				if(board[0][i] == 'O') {
					dfs(board, 0, i);
				}
				if(board[m - 1][i] == 'O') {
					dfs(board, m - 1, i);
				}
			}
			for(int j = 0; j < m; j++) {
				if(board[j][0] == 'O') {
					dfs(board, j, 0);
				}
				if(board[j][n - 1] == 'O') {
					dfs(board, j, n - 1);
				}
			}
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					if(board[i][j] == 'O') {
						board[i][j] = 'X';
					}
					if(board[i][j] == 'D') {
						board[i][j] = 'O';
					}
				}
			}
		}

		void Solution::dfs(vector<vector<char>> &board, int x, int y) {
			board[x][y]             = 'D';
			const int m             = board.size();
			const int n             = board[0].size();
			pair<int, int> nexts[4] = {{x - 1, y}, {x + 1, y}, {x, y - 1}, {x, y + 1}};
			for(auto [next_x, next_y]: nexts) {
				if(next_x >= 0 && next_x < m && next_y >= 0 && next_y < n && board[next_x][next_y] == 'O') {
					dfs(board, next_x, next_y);
				}
			}
		}
	}// namespace surrounded_regions

	namespace all_paths_from_source_to_target {
		vector<vector<int>> Solution::allPathsSourceTarget(vector<vector<int>> &graph) {
			vector<vector<int>> ans;
			dfs(graph, ans, 0);
			for(auto &path: ans) {
				path.push_back(0);
				path = vector(path.rbegin(), path.rend());
			}
			return ans;
		}

		int Solution::dfs(vector<vector<int>> &graph, vector<vector<int>> &ans, int cur) {
			int ret = 0;
			if(cur == graph.size() - 1) {
				ans.emplace_back(vector(1, cur));
				return 1;
			}
			for(const auto next: graph[cur]) {
				const int n = dfs(graph, ans, next);
				ret += n;
				for(int i = ans.size() - 1, j = 0; j < n; i--, j++) {
					ans[i].emplace_back(cur);
				}
			}
			return ret;
		}
	}// namespace all_paths_from_source_to_target

	namespace permutations_ii {
		vector<vector<int>> Solution::permuteUnique(vector<int> &nums) {
			vector<vector<int>> ans;
			set<vector<int>> s;
			dfs(s, vector<int>(), nums);
			ans.reserve(s.size());
			for(const auto &vec: s) {
				ans.emplace_back(vec);
			}
			return ans;
		}

		void Solution::dfs(set<vector<int>> &s, const vector<int> &current, vector<int> rest) {
			if(rest.empty()) {
				s.insert(current);
				return;
			}
			for(auto it = rest.begin(); it != rest.end(); ++it) {
				vector<int> next_current = current;
				vector<int> next_rest    = rest;
				next_current.push_back(*it);
				next_rest.erase(next_rest.begin() + (it - rest.begin()));
				dfs(s, next_current, next_rest);
			}
		}
	}// namespace permutations_ii

	namespace combination_sum {
		vector<vector<int>> Solution::combinationSum(vector<int> &candidates, int target) {
			sort(candidates.begin(), candidates.end());
			return recurse(candidates, target, 0);
		}

		vector<vector<int>> Solution::recurse(vector<int> &candidates, int target, int index) {
			vector<vector<int>> ans;
			for(int i = index; i < candidates.size(); i++) {
				auto &candidate = candidates[i];
				if(candidate == target) {
					ans.emplace_back(vector(1, candidate));
				} else if(target - candidate >= 1) {
					auto res = recurse(candidates, target - candidate, i);
					for(auto &vec: res) {
						vec.push_back(candidate);
						ans.push_back(vec);
					}
				}
			}
			return ans;
		}
	}// namespace combination_sum

	namespace combination_sum_ii {
		vector<vector<int>> Solution::combinationSum2(vector<int> &candidates, int target) {
			sort(candidates.begin(), candidates.end());
			const auto ret = recurse(candidates, target, -10);
			vector<vector<int>> ans(ret.size());
			for(int i = 0; i < ret.size(); i++) {
				ans[i] = vector<int>(ret[i].size());
				for(int j = 0; j < ret[i].size(); j++) {
					ans[i][j] = candidates[ret[i][j]];
				}
			}
			return ans;
		}

		vector<vector<int>> Solution::recurse(vector<int> &candidates, int target, int index) {
			vector<vector<int>> ans;
			for(int i = max(0, index + 1); i < candidates.size(); i++) {
				if(!(i > 0 && candidates[i] == candidates[i - 1] && index != i - 1)) {
					const auto &candidate = candidates[i];
					if(candidate == target) {
						ans.emplace_back(vector(1, i));
					} else if(target - candidate >= 1) {
						auto res = recurse(candidates, target - candidate, i);
						for(auto &vec: res) {
							vec.push_back(i);
							ans.push_back(vec);
						}
					}
				}
			}
			return ans;
		}
	}// namespace combination_sum_ii

	namespace house_robber_ii {
		int Solution::rob(vector<int> &nums) {
			if(nums.size() == 1) {
				return nums[0];
			}
			auto vec1 = vector(nums.begin(), nums.end() - 1);
			auto vec2 = vector(nums.begin() + 1, nums.end());
			return max(house_robber::Solution::rob(vec1), house_robber::Solution::rob(vec2));
		}
	}// namespace house_robber_ii

	namespace jump_game {
		bool Solution::canJump(vector<int> &nums) {
			vector can(nums.size(), false);
			can[0]   = true;
			int last = 0;
			for(int i = 0; i < nums.size(); i++) {
				if(can[i] && min(i + nums[i], static_cast<int>(nums.size() - 1)) > last) {
					for(int j = last + 1; j <= i + nums[i] && j < nums.size(); j++) {
						can[j] = true;
					}
					last = min(i + nums[i], static_cast<int>(nums.size() - 1));
				}
			}
			return can.back();
		}
	}// namespace jump_game

	namespace jump_game_ii {
		int Solution::jump(vector<int> &nums) {
			const int n = nums.size();
			int ans     = 0;
			int last    = n - 1;
			while(last != 0) {
				for(int i = 0; i < n; i++) {
					if(i + nums[i] >= last) {
						last = i;
						ans++;
						break;
					}
				}
			}
			return ans;
		}
	}// namespace jump_game_ii

	namespace unique_paths {
		int Solution::uniquePaths(int m, int n) {
			vector dp(m, vector(n, 0));
			dp[m - 1][n - 1] = 1;
			for(int i = m - 1; i >= 0; i--) {
				for(int j = n - 1; j >= 0; j--) {
					if(i + 1 < m) {
						dp[i][j] += dp[i + 1][j];
					}
					if(j + 1 < n) {
						dp[i][j] += dp[i][j + 1];
					}
				}
			}
			return dp[0][0];
		}
	}// namespace unique_paths

	namespace longest_palindromic_substring {
		string Solution::longestPalindrome(string s) {
			const int n = s.size();
			if(n < 2) {
				return s;
			}

			int maxLen = 1;
			int begin  = 0;
			// dp[i][j] 表示 s[i..j] 是否是回文串
			vector dp(n, vector<int>(n));
			// 初始化：所有长度为 1 的子串都是回文串
			for(int i = 0; i < n; i++) {
				dp[i][i] = 1;
			}
			// 递推开始
			// 先枚举子串长度
			for(int L = 2; L <= n; L++) {
				// 枚举左边界，左边界的上限设置可以宽松一些
				for(int i = 0; i < n; i++) {
					// 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
					const int j = L + i - 1;
					// 如果右边界越界，就可以退出当前循环
					if(j >= n) {
						break;
					}

					if(s[i] != s[j]) {
						dp[i][j] = 0;
					} else {
						if(j - i < 3) {
							dp[i][j] = 1;
						} else {
							dp[i][j] = dp[i + 1][j - 1];
						}
					}

					// 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
					if(dp[i][j] != 0 && j - i + 1 > maxLen) {
						maxLen = j - i + 1;
						begin  = i;
					}
				}
			}
			return s.substr(begin, maxLen);
		}
	}// namespace longest_palindromic_substring

	namespace arithmetic_slices {
		int Solution::numberOfArithmeticSlices(vector<int> &nums) {
			const int n = nums.size();
			vector<int> diff(n - 1);
			for(int i = 0; i < n - 1; i++) {
				diff[i] = nums[i + 1] - nums[i];
			}
			vector<int> consecutive;
			int prev = 0;
			int cnt  = 0;
			for(int i = 0; i < n - 1; i++) {
				if(diff[i] == diff[prev]) {
					cnt++;
				} else {
					consecutive.emplace_back(cnt);
					prev = i;
					cnt  = 1;
				}
			}
			consecutive.emplace_back(cnt);
			int ans = 0;
			for(const auto num: consecutive) {
				if(num >= 2) {
					ans += (num - 1) * num / 2;
				}
			}
			return ans;
		}
	}// namespace arithmetic_slices

	namespace decode_ways {
		int Solution::numDecodings(string s) {
			vector dp(s.length(), 0);
			for(int i = 0; i < dp.size(); i++) {
				bool ok = false;
				if('1' <= s[i] && s[i] <= '9') {
					dp[i] += i - 1 >= 0 ? dp[i - 1] : 1;
					ok = true;
				}
				if(i - 1 >= 0 && (s[i - 1] == '1' && '0' <= s[i] && s[i] <= '9' || s[i - 1] == '2' && '0' <= s[i] && s[i] <= '6')) {
					dp[i] += i - 2 >= 0 ? dp[i - 2] : 1;
					ok = true;
				}
				if(!ok) {
					return 0;
				}
			}
			return dp.back();
		}
	}// namespace decode_ways

	namespace word_break {
		bool Solution::wordBreak(const string &s, vector<string> &wordDict) {
			vector end(s.length(), false);
			TrieNode tn(0);
			for(const auto &word: wordDict) {
				tn.insert(word);
			}
			search(&tn, s, 0, end);
			for(int i = 1; i < s.length(); i++) {
				if(end[i - 1]) {
					search(&tn, s, i, end);
					if(end.back()) {
						return true;
					}
				}
			}
			return end.back();
		}

		void Solution::search(const TrieNode *tn, const string &s, int i, vector<bool> &end) {
			const TrieNode *node = tn;
			for(; i < s.length(); i++) {
				node = node->nexts[s[i] - 'a'];
				if(node == nullptr) {
					return;
				}
				if(node->end_of_word) {
					end[i] = true;
				}
			}
		}
	}// namespace word_break

	namespace longest_increasing_subsequence {
		int Solution::lengthOfLIS(vector<int> &nums) {
			const int n = nums.size();
			int ans     = 1;
			vector dp(n, 1);//length of longest increasing subsequence end with i
			for(int i = 0; i < n; i++) {
				for(int j = i + 1; j < n; j++) {
					if(nums[j] > nums[i]) {
						dp[j] = max(dp[j], dp[i] + 1);
					}
				}
				ans = max(ans, dp[i]);
			}
			return ans;
		}
	}// namespace longest_increasing_subsequence

	namespace number_of_longest_increasing_subsequence {
		int Solution::findNumberOfLIS(vector<int> &nums) {
			const int n = nums.size();
			vector dp(n, map<unsigned, unsigned>());//dp[i][j] = number of increasing subsequence end with i, length is j
			for(int i = 0; i < n; i++) {
				dp[i][1] = 1;
			}
			unsigned max_len = 1;
			for(int i = 0; i < n; i++) {
				for(int j = i + 1; j < n; j++) {
					auto &[len, cnt] = *dp[i].rbegin();
					if(nums[j] > nums[i]) {
						dp[j][len + 1] += cnt;
						max_len = max(max_len, len + 1);
					}
				}
			}
			unsigned ans = 0;
			for(int i = 0; i < n; i++) {
				ans += dp[i][max_len];
			}
			return ans;
		}
	}// namespace number_of_longest_increasing_subsequence

	namespace longest_common_subsequence {
		int Solution::longestCommonSubsequence(string text1, string text2) {
			vector dp(text1.length(), vector(text2.length(), 0));///< dp[i][j] = longest common subsequence of text1 end with i and text2 end with j
			for(int i = 0; i < text1.length(); i++) {
				for(int j = 0; j < text2.length(); j++) {
					if(text1[i] == text2[j]) {
						dp[i][j] = (i - 1 < 0 || j - 1 < 0 ? 0 : dp[i - 1][j - 1]) + 1;
					} else {
						dp[i][j] = max(i - 1 >= 0 ? dp[i - 1][j] : 0, j - 1 >= 0 ? dp[i][j - 1] : 0);
					}
				}
			}
			return dp.back().back();
		}
	}// namespace longest_common_subsequence

	namespace delete_operation_for_two_strings {
		int Solution::minDistance(const string &word1, const string &word2) {
			const int lcs = longest_common_subsequence::Solution::longestCommonSubsequence(word1, word2);
			return word1.length() + word2.length() - 2 * lcs;
		}
	}// namespace delete_operation_for_two_strings

	namespace edit_distance {
		int Solution::minDistance(string word1, string word2) {
			// dp[i][j] is the minimum number of operations required to convert word1[0..i] to word2[0..j]
			vector dp(word1.length() + 1, vector<int>(word2.length() + 1));
			// if word[i] == word2[j], dp[i][j] = dp[i-1][j-1]; else dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1
			for(int j = 0; j <= word2.length(); j++) {
				dp[0][j] = j;
			}
			for(int i = 0; i <= word1.length(); i++) {
				dp[i][0] = i;
			}
			for(int i = 1; i <= word1.length(); i++) {
				for(int j = 1; j <= word2.length(); j++) {
					if(word1[i - 1] == word2[j - 1]) {
						dp[i][j] = dp[i - 1][j - 1];
					} else {
						dp[i][j] = min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
					}
				}
			}
			return dp.back().back();
		}
	}// namespace edit_distance

	namespace coin_change {
		int Solution::coinChange(vector<int> &coins, int amount) {
			vector dp(amount + 1, -1);
			dp[0] = 0;
			for(const auto &coin: coins) {
				if(coin <= amount) {
					dp[coin] = 1;
				}
			}
			for(unsigned i = 0; i <= amount; i++) {
				if(dp[i] > 0) {
					for(const auto &coin: coins) {
						if(i + coin <= static_cast<unsigned>(amount)) {
							if(dp[i + coin] == -1) {
								dp[i + coin] = dp[i] + 1;
							} else {
								dp[i + coin] = min(dp[i + coin], dp[i] + 1);
							}
						}
					}
				}
			}
			return dp[amount];
		}
	}// namespace coin_change

	namespace integer_break {
		int Solution::integerBreak(int n) {
			// dp[i] is the maximum product of i
			vector<int> dp(n + 1);
			// dp[i] = max(dp[i], dp[j] * dp[i - j])
			dp[2] = 1;
			dp[1] = 1;
			for(int i = 3; i <= n; i++) {
				for(int j = 1; j < i; j++) {
					dp[i] = max(dp[i], dp[j] * dp[i - j]);
					dp[i] = max(dp[i], j * dp[i - j]);
					dp[i] = max(dp[i], dp[j] * (i - j));
					dp[i] = max(dp[i], j * (i - j));
				}
			}
			return dp[n];
		}
	}// namespace integer_break

	namespace max_points_on_a_line {
		int Solution::maxPoints(vector<vector<int>> &points) {
			int ans = 0;
			for(auto &p1: points) {
				unordered_map<long double, int> us;
				int cnt = 0;
				for(auto &p2: points) {
					if(p2[0] != p1[0]) {
						us[static_cast<long double>(p2[1] - p1[1]) / static_cast<long double>(p2[0] - p1[0])]++;
					} else {
						cnt++;
					}
				}
				for(auto &[k, v]: us) {
					cnt = max(cnt, v + 1);
				}
				ans = max(ans, cnt);
			}
			return ans;
		}
	}// namespace max_points_on_a_line

	namespace group_anagrams {
		vector<vector<string>> Solution::groupAnagrams(vector<string> &strs) {
			vector<string> strs_sorted = strs;
			unordered_map<string, vector<string>> um;
			for(auto &str: strs_sorted) {
				sort(str.begin(), str.end());
				if(!um.contains(str)) {
					um[str] = vector<string>();
				}
			}
			for(int i = 0; i < strs.size(); i++) {
				um[strs_sorted[i]].emplace_back(strs[i]);
			}
			vector<vector<string>> ans;
			ans.reserve(um.size());
			for(auto &[k, v]: um) {
				ans.emplace_back(v);
			}
			return ans;
		}
	}// namespace group_anagrams

	namespace sort_colors {
		void Solution::sortColors(vector<int> &nums) { qsort(nums, 0, nums.size() - 1); }

		void Solution::qsort(vector<int> &nums, int l, int r) {
			if(l >= r) {
				return;
			}
			int lp          = l - 1;
			int rp          = r + 1;
			const int pivot = nums[(l + r) / 2];
			while(lp < rp) {
				while(nums[++lp] < pivot) {}
				while(nums[--rp] > pivot) {}
				if(lp < rp) {
					swap(nums[lp], nums[rp]);
				}
			}
			qsort(nums, l, rp);
			qsort(nums, rp + 1, r);
		}
	}// namespace sort_colors

	namespace top_k_frequent_elements {
		vector<int> Solution::topKFrequent(vector<int> &nums, int k) {
			unordered_map<int, int> um;
			for(auto num: nums) {
				um[num]++;
			}
			vector<int> vec(um.size());
			int i = 0;
			for(auto &[_, v]: um) {
				vec[i++] = v;
			}
			sort(vec.rbegin(), vec.rend());
			unordered_set<int> us;
			for(i = 0; i < k; i++) {
				us.insert(vec[i]);
			}
			vector<int> ans;
			for(auto [num, v]: um) {
				if(us.contains(v)) {
					ans.emplace_back(num);
				}
			}
			return ans;
		}
	}// namespace top_k_frequent_elements

	namespace kth_largest_element_in_an_array {
		int Solution::findKthLargest(vector<int> &nums, int k) {
			sort(nums.rbegin(), nums.rend());
			return nums[k - 1];
		}
	}// namespace kth_largest_element_in_an_array

	namespace merge_intervals {
		vector<vector<int>> Solution::merge(vector<vector<int>> &intervals) {
			vector<vector<int>> ans;
			auto comp = [](const vector<int> &a, const vector<int> &b) { return a[0] < b[0]; };
			sort(intervals.begin(), intervals.end(), comp);
			int start = intervals[0][0];
			int end   = intervals[0][1];
			for(int i = 1; i < intervals.size(); i++) {
				if(intervals[i][0] <= end) {
					end = max(end, intervals[i][1]);
				} else {
					ans.emplace_back(vector{start, end});
					start = intervals[i][0];
					end   = intervals[i][1];
				}
			}
			ans.emplace_back(vector{start, end});
			return ans;
		}
	}// namespace merge_intervals

	namespace search_a_2d_matrix_ii {
		bool Solution::searchMatrix(vector<vector<int>> &matrix, int target) { return search(matrix, target, 0, matrix.size() - 1, 0, matrix[0].size() - 1); }

		bool Solution::search(const vector<vector<int>> &matrix, int target, int x_start, int x_end, int y_start, int y_end) {
			const int minimum = min(x_end - x_start, y_end - y_start);
			vector<int> diag1(minimum + 1);
			for(int i = 0; i <= minimum; i++) {
				diag1[i] = matrix[x_start + i][y_start + i];
			}
			const auto it = lower_bound(diag1.begin(), diag1.end(), target);
			const int x   = x_start + it - diag1.begin();
			const int y   = y_start + it - diag1.begin();
			if(it != diag1.end()) {
				if(*it == target) {
					return true;
				}
				if(it == diag1.begin()) {
					return false;
				}
				if(search(matrix, target, x_start, x - 1, y, y_end)) {
					return true;
				}
				if(search(matrix, target, x, x_end, y_start, y - 1)) {
					return true;
				}
				if(search(matrix, target, x, x_end, y, y_end)) {
					return true;
				}
			} else {
				if(x > x_end && y > y_end) {
					return false;
				}
				if(x > x_end && search(matrix, target, x_start, x_end, y, y_end)) {
					return true;
				}
				if(y > y_end && search(matrix, target, x, x_end, y_start, y_end)) {
					return true;
				}
			}
			return false;
		}
	}// namespace search_a_2d_matrix_ii

	namespace serialize_and_deserialize_binary_tree {
		string Codec::serialize(TreeNode *root) {
			if(root == nullptr) {
				return "[]";
			}
			vector<string> vec;
			ostringstream oss;
			oss << '[';
			queue<TreeNode *> q;
			q.push(root);
			while(!q.empty()) {
				const TreeNode *node = q.front();
				q.pop();
				if(node == nullptr) {
					vec.emplace_back("null");
					continue;
				}
				vec.emplace_back(to_string(node->val));
				q.push(node->left);
				q.push(node->right);
			}
			int end = vec.size() - 1;
			while(vec[end] == "null" && end > 0) {
				end--;
			}
			oss << vec[0];
			for(int i = 1; i <= end; i++) {
				oss << ',' << vec[i];
			}
			oss << ']';
			return oss.str();
		}

		TreeNode *Codec::deserialize(string data) {
			if(data == "[]") {
				return nullptr;
			}
			vector<string> vec;
			data            = data.substr(1, data.size() - 2);
			auto *const str = static_cast<char *>(malloc((data.length() + 1) * sizeof(char)));
			memcpy(str, data.c_str(), (data.length() + 1) * sizeof(char));
			for(const char *item = strtok(str, ","); item != nullptr; item = strtok(nullptr, ",")) {
				vec.emplace_back(string(item));
			}
			queue<TreeNode **> q;
			auto *root = new TreeNode(stoi(vec[0]));
			q.push(&root);
			for(const auto &str: vec) {
				auto *const node = q.front();
				q.pop();
				if(str == "null") {
					*node = nullptr;
				} else {
					*node = new TreeNode(stoi(str));
					q.push(&(*node)->left);
					q.push(&(*node)->right);
				}
			}
			return root;
		}
	}// namespace serialize_and_deserialize_binary_tree

	namespace task_scheduler {
		int Solution::leastInterval(vector<char> &tasks, int n) {
			if(n == 0) {
				return tasks.size();
			}
			int maximum = 0;
			int cycle   = 0;
			unordered_map<char, int> task_cnt;
			unordered_map<char, int> processing;
			for(char task: tasks) {
				task_cnt[task]++;
			}
			while(true) {
				bool finished = true;
				maximum       = 0;
				for(const auto &[task, cnt]: task_cnt) {
					if(cnt > 0) {
						finished = false;
					}
					if(processing[task] <= 0) {
						maximum = max(maximum, cnt);
					}
				}
				if(finished) {
					return cycle;
				}
				for(auto &[task, rest]: processing) {
					rest--;
				}
				for(auto &[task, cnt]: task_cnt) {
					if(maximum == cnt && processing[task] <= 0) {
						cnt--;
						processing[task] = n;
						break;
					}
				}
				cycle++;
			}
		}
	}// namespace task_scheduler

	namespace design_hashmap {
		MyHashMap::MyHashMap() {
			arr = array<list<pair<int, int>>, SZ>();
			for(unsigned i = 0; i < SZ; i++) {
				arr[i] = list<pair<int, int>>();
			}
		}

		void MyHashMap::put(int key, int value) {
			const unsigned slot = static_cast<unsigned>(key) % SZ;
			for(auto &[k, v]: arr[slot]) {
				if(k == key) {
					v = value;
					return;
				}
			}
			arr[slot].emplace_back(key, value);
		}

		int MyHashMap::get(int key) {
			const unsigned slot = static_cast<unsigned>(key) % SZ;
			for(auto &[k, v]: arr[slot]) {
				if(k == key) {
					return v;
				}
			}
			return -1;
		}

		void MyHashMap::remove(int key) {
			const unsigned slot = static_cast<unsigned>(key) % SZ;
			for(auto it = arr[slot].begin(); it != arr[slot].end(); ++it) {
				if(it->first == key) {
					arr[slot].erase(it);
					return;
				}
			}
		}
	}// namespace design_hashmap

	namespace spiral_matrix_ii {
		vector<vector<int>> Solution::generateMatrix(int n) {
			vector ans(n, vector(n, 0));
			int dir = 0;// 0-right 1-down 2-left 3->up
			int c   = 1;
			int x   = 0;
			int y   = 0;
			for(int i = 0; i < n * n; i++) {
				ans[x][y] = c++;
				bool flag = true;
			SLCT:
				int nx = x;
				int ny = y;
				switch(dir) {
					case 0:
						ny++;
						break;
					case 1:
						nx++;
						break;
					case 2:
						ny--;
						break;
					case 3:
						nx--;
						break;
				}
				if(flag && (nx < 0 || nx >= n || ny < 0 || ny >= n || ans[nx][ny] != 0)) {
					dir++;
					dir %= 4;
					flag = false;
					goto SLCT;
				}
				x = nx;
				y = ny;
			}
			return ans;
		}
	}// namespace spiral_matrix_ii

	namespace non_overlapping_intervals {
		int Solution::eraseOverlapIntervals(vector<vector<int>> &intervals) {
			if(intervals.empty()) {
				return 0;
			}

			sort(intervals.begin(), intervals.end(), [](const auto &u, const auto &v) { return u[1] < v[1]; });

			const int n = intervals.size();
			int right   = intervals[0][1];
			int ans     = 1;
			for(int i = 1; i < n; ++i) {
				if(intervals[i][0] >= right) {
					++ans;
					right = intervals[i][1];
				}
			}
			return n - ans;
		}
	}// namespace non_overlapping_intervals

	namespace product_of_array_except_self {
		vector<int> Solution::productExceptSelf(vector<int> &nums) {
			vector<int> left(nums.size());
			vector<int> right(nums.size());
			int c = 1;
			for(int i = 0; i < left.size(); i++) {
				left[i] = c;
				c *= nums[i];
			}
			c = 1;
			for(int i = left.size() - 1; i >= 0; i--) {
				right[i] = c;
				c *= nums[i];
			}
			vector<int> ans(nums.size());
			for(int i = 0; i < nums.size(); i++) {
				ans[i] = left[i] * right[i];
			}
			return ans;
		}
	}// namespace product_of_array_except_self

	namespace subarray_sum_equals_k {
		int Solution::subarraySum(vector<int> &nums, int k) {
			unordered_map<int, int> um;
			um[0]     = 1;
			int count = 0;
			int ps    = 0;
			for(const auto &num: nums) {
				ps += num;
				count += um[ps - k];
				um[ps]++;
			}
			return count;
		}
	}// namespace subarray_sum_equals_k

	namespace partition_labels {
		vector<int> Solution::partitionLabels(string s) {
			unordered_map<char, unsigned> last;
			vector<int> ans;
			for(int i = 0; i < s.length(); i++) {
				last[s[i]] = i;
			}
			for(int i = 0; i < s.length();) {
				unsigned last_pos = i;
				char ch           = s[i];
				for(int j = i; j <= last_pos; j++) {
					last_pos = max(last_pos, last[s[j]]);
				}
				ans.emplace_back(last_pos - i + 1);
				i = last_pos + 1;
			}
			return ans;
		}
	}// namespace partition_labels

	namespace repeated_dna_sequences {
		vector<string> Solution::findRepeatedDnaSequences(string s) {
			vector<unsigned short> vec(s.length());
			for(int i = 0; i < s.length(); i++) {
				switch(s[i]) {
					case 'A':
						vec[i] = 0;
						break;
					case 'C':
						vec[i] = 1;
						break;
					case 'G':
						vec[i] = 2;
						break;
					case 'T':
						vec[i] = 3;
						break;
				}
			}
			unsigned hsv = 0;
			if(s.length() < 10) {
				return {};
			}
			unordered_map<unsigned, string> um;
			unordered_map<unsigned, unsigned> cnt;
			for(int i = 0; i < 10; i++) {
				hsv *= 4;
				hsv += vec[i];
			}
			um[hsv]          = s.substr(0, 10);
			cnt[hsv]         = 1;
			const unsigned f = 262144;
			for(int i = 10; i < s.length(); i++) {
				hsv -= vec[i - 10] * f;
				hsv *= 4;
				hsv += vec[i];
				um[hsv] = s.substr(i - 9, 10);
				cnt[hsv]++;
			}
			vector<string> ans;
			for(auto &[k, v]: um) {
				if(cnt[k] > 1) {
					ans.emplace_back(v);
				}
			}
			return ans;
		}
	}// namespace repeated_dna_sequences

	namespace design_linked_list {
		MyLinkedList::MyLinkedList() {
			head = new ListNode();
			tail = head;
		}

		int MyLinkedList::get(int index) const {
			index += 1;
			if(index < 1) {
				return -1;
			}
			const ListNode *current = head;
			for(int i = 0; i < index && current != nullptr; i++) {
				current = current->next;
			}
			return current == nullptr ? -1 : current->val;
		}

		void MyLinkedList::addAtHead(int val) {
			auto *const node = new ListNode(val);
			node->next       = head->next;
			head->next       = node;
			if(tail == head) {
				tail = node;
			}
		}

		void MyLinkedList::addAtTail(int val) {
			auto *const node = new ListNode(val);
			tail->next       = node;
			tail             = node;
		}

		void MyLinkedList::addAtIndex(int index, int val) {
			index += 1;
			if(index < 1) {
				return;
			}
			auto *const node  = new ListNode(val);
			ListNode *current = head;
			for(int i = 0; i < index - 1 && current != nullptr; i++) {
				current = current->next;
			}
			if(current == nullptr) {
				delete node;
				return;
			}
			node->next    = current->next;
			current->next = node;
			if(current == tail) {
				tail = node;
			}
		}

		void MyLinkedList::deleteAtIndex(int index) {
			index += 1;
			if(index < 1) {
				return;
			}
			ListNode *current = head;
			for(int i = 0; i < index - 1 && current != nullptr; i++) {
				current = current->next;
			}
			if(current == nullptr) {
				return;
			}
			const auto *const p = current->next;
			if(p == tail) {
				tail = current;
			}
			if(p != nullptr) {
				current->next = current->next->next;
				delete p;
			}
		}
	}// namespace design_linked_list

	namespace delete_node_in_a_bst {
		TreeNode *Solution::findMaximum(TreeNode *node) {
			TreeNode *current = node;
			while(current->right != nullptr) {
				prev    = current;
				current = current->right;
			}
			return current;
		}

		TreeNode *Solution::findMinimum(TreeNode *node) {
			TreeNode *current = node;
			while(current->left != nullptr) {
				prev    = current;
				current = current->left;
			}
			return current;
		}

		void Solution::remove(TreeNode *node) {
			if(node->right != nullptr) {
				prev             = node;
				auto *const rmin = findMinimum(node->right);
				node->val        = rmin->val;
				remove(rmin);
				return;
			}
			if(node->left != nullptr) {
				prev             = node;
				auto *const lmax = findMaximum(node->left);
				node->val        = lmax->val;
				remove(lmax);
				return;
			}
			if(prev != nullptr) {
				if(prev->left != nullptr && prev->left->val == node->val) {
					prev->left = nullptr;
				} else if(prev->right != nullptr && prev->right->val == node->val) {
					prev->right = nullptr;
				}
			} else {
				exit(-1);
			}
			//delete node;
		}

		TreeNode *Solution::deleteNode(TreeNode *root, int key) {
			if(root == nullptr) {
				return root;
			}
			TreeNode *current = root;
			while(current != nullptr && current->val != key) {
				if(current->val == key) {
					break;
				}
				prev = current;
				if(current->val < key) {
					current = current->right;
				} else {
					current = current->left;
				}
			}
			if(current == nullptr) {
				return root;
			}
			if(root->left == nullptr && root->right == nullptr) {
				return nullptr;
			}
			remove(current);
			return root;
		}
	}// namespace delete_node_in_a_bst

	namespace missing_element_in_sorted_array {
		int Solution::missingElement(vector<int> &nums, int k) {
			unordered_set<int> us;
			for(auto num: nums) {
				us.insert(num);
			}
			if(missing(nums, nums.size() - 1) < k) {
				return nums[0] + k + nums.size() - 1;
			}
			int l = 0;
			int r = nums.size() - 1;
			while(l < r) {
				if(r == l + 1) {
					return nums[l] + k - missing(nums, l);
				}
				const int m = (l + r) / 2;
				if(missing(nums, m) < k) {
					l = m;
				} else if(missing(nums, m) >= k) {
					r = m;
				}
			}
			return 0;
		}

		unsigned Solution::missing(vector<int> &nums, int i) { return nums[i] - nums[0] - i; }
	}// namespace missing_element_in_sorted_array

	namespace find_a_peak_element_ii {
		vector<int> Solution::findPeakGridLR(vector<vector<int>> &mat, int l, int r) {
			const int mid = (l + r) / 2;
			int max_col   = mid;
			int max_row   = 0;
			int maximum   = -1;
			for(int i = 0; i < mat.size(); i++) {
				for(int j = mid - 1; j <= mid + 1; j++) {
					if(maximum < get(mat, i, j)) {
						maximum = get(mat, i, j);
						max_col = j;
						max_row = i;
					}
				}
			}
			if(max_col == mid || l + 1 == r) {
				return {max_row, max_col};
			}
			if(max_col == mid + 1) {
				return findPeakGridLR(mat, mid, r);
			}
			return findPeakGridLR(mat, l, mid);
		}

		vector<int> Solution::findPeakGrid(vector<vector<int>> &mat) { return findPeakGridLR(mat, 0, mat[0].size() - 1); }

		int Solution::get(vector<vector<int>> &mat, int i, int j) {
			if(i >= 0 && i < mat.size() && j >= 0 && j < mat[0].size()) {
				return mat[i][j];
			}
			return -1;
		}
	}// namespace find_a_peak_element_ii

	namespace divide_chocolate {
		int Solution::maximizeSweetness(vector<int> &sweetness, int k) {
			int l = sweetness[0];
			int r = 0;
			for(auto s: sweetness) {
				l = min(l, s);
				r += s;
			}
			while(l < r) {
				if(l + 1 == r) {
					return count(sweetness, r) == k + 1 ? r : l;
				}
				const int m = (l + r) / 2;
				const int c = count(sweetness, m);
				if(c < k + 1) {
					r = m - 1;
				} else {
					l = m;
				}
			}
			return l;
		}

		int Solution::count(vector<int> &sweetness, int x) {
			int ans     = 0;
			int current = 0;
			for(const auto s: sweetness) {
				current += s;
				if(current >= x) {
					current = 0;
					ans++;
				}
			}
			return ans;
		}
	}// namespace divide_chocolate

	namespace shortest_distance_to_target_color {
		vector<int> Solution::shortestDistanceColor(vector<int> &colors, vector<vector<int>> &queries) {
			vector<int> ans;
			unordered_map<int, vector<int>> um;
			for(int i = 0; i < colors.size(); i++) {
				um[colors[i]].emplace_back(i);
			}
			for(auto &[k, vec]: um) {
				sort(vec.begin(), vec.end());
			}
			for(auto &query: queries) {
				int &i           = query[0];
				int &c           = query[1];
				vector<int> &vec = um[c];
				auto g           = lower_bound(vec.begin(), vec.end(), i, less());
				auto l           = lower_bound(vec.rbegin(), vec.rend(), i, greater());
				if(g == vec.end() && l == vec.rend()) {
					ans.emplace_back(-1);
				} else if(g == vec.end()) {
					ans.emplace_back(abs(*l - i));
				} else if(l == vec.rend()) {
					ans.emplace_back(abs(*g - i));
				} else {
					ans.emplace_back(min(abs(*l - i), abs(*g - i)));
				}
			}
			return ans;
		}
	}// namespace shortest_distance_to_target_color

	namespace meeting_scheduler {
		vector<int> Solution::minAvailableDuration(vector<vector<int>> &slots1, vector<vector<int>> &slots2, int duration) {
			vector<int> ans(2);
			auto cmp = [](const vector<int> &vec1, const vector<int> &vec2) -> bool {
				if(vec1[1] != vec2[1]) {
					return vec1[1] < vec2[1];
				}
				return vec1[0] < vec2[0];
			};
			sort(slots1.begin(), slots1.end(), cmp);
			sort(slots2.begin(), slots2.end(), cmp);
			for(auto it1 = slots1.begin(), it2 = slots2.begin(); it1 != slots1.end() && it2 != slots2.end();) {
				pair<int, int> p = merge(*it1, *it2);
				if(p.second - p.first >= duration) {
					return {p.first, p.first + duration};
				}
				if(cmp(*it1, *it2)) {
					++it1;
				} else {
					++it2;
				}
			}
			return {};
		}

		pair<int, int> Solution::merge(const vector<int> &vec1, const vector<int> &vec2) { return {max(vec1[0], vec2[0]), min(vec1[1], vec2[1])}; }
	}// namespace meeting_scheduler

	namespace find_the_duplicate_number {
		int Solution::findDuplicate(vector<int> &nums) {
			int maximum = nums[0];
			int minimum = nums[0];
			for(const auto &num: nums) {
				maximum = max(maximum, num);
				minimum = min(minimum, num);
			}
			int l = minimum;
			int r = maximum;
			while(l < r) {
				const int m = (l + r) / 2;
				const int c = countInRange(nums, l, m);
				if(c == m - l + 1) {
					l = m + 1;
				} else if(c > m - l + 1) {
					r = m;
				} else {
					l++;
				}
			}
			return l;
		}

		int Solution::countInRange(vector<int> &nums, int l, int r) {
			int ans = 0;
			for(const auto &num: nums) {
				if(l <= num && num <= r) {
					ans++;
				}
			}
			return ans;
		}
	}// namespace find_the_duplicate_number

	namespace trapping_rain_water {
		int Solution::trap(vector<int> &height) {
			vector lmax(height.size(), 0);
			vector rmax(height.size(), 0);
			int maximum = height[0];
			for(int i = 0; i < height.size(); i++) {
				maximum = max(maximum, height[i]);
				lmax[i] = maximum;
			}
			maximum = height.back();
			for(int i = height.size() - 1; i >= 0; i--) {
				maximum = max(maximum, height[i]);
				rmax[i] = maximum;
			}
			int ans = 0;
			for(int i = 0; i < height.size(); i++) {
				ans += min(lmax[i], rmax[i]) - height[i];
			}
			return ans;
		}
	}// namespace trapping_rain_water

	namespace product_of_two_run_length_encoded_arrays {
		vector<vector<int>> Solution::findRLEArray(vector<vector<int>> &encoded1, vector<vector<int>> &encoded2) {
			vector<vector<int>> ans;
			int p1 = 0;
			int p2 = 0;
			for(int i1 = 0, i2 = 0; i1 < encoded1.size() && i2 < encoded2.size();) {
				const int len = min(encoded1[i1][1] - p1, encoded2[i2][1] - p2);
				const int v   = encoded1[i1][0] * encoded2[i2][0];
				if(!ans.empty() && ans.back()[0] == v) {
					ans.back()[1] += len;
				} else {
					vector vec = {v, len};
					ans.emplace_back(vec);
				}
				p1 += len;
				p2 += len;
				if(p1 >= encoded1[i1][1]) {
					i1++;
					p1 = 0;
				}
				if(p2 >= encoded2[i2][1]) {
					i2++;
					p2 = 0;
				}
			}
			return ans;
		}
	}// namespace product_of_two_run_length_encoded_arrays

	namespace longest_substring_with_at_most_two_distinct_characters {
		int Solution::getMinUniqueCharCnt(const string &s, int len) {
			unordered_map<char, int> um;
			for(int i = 0; i < len; i++) {
				um[s[i]]++;
			}
			size_t ans = um.size();
			for(int i = 0, j = len; j < s.length(); i++, j++) {
				um[s[i]]--;
				um[s[j]]++;
				if(um[s[i]] == 0) {
					um.erase(s[i]);
				}
				ans = min(ans, um.size());
			}
			return ans;
		}

		int Solution::lengthOfLongestSubstringTwoDistinct(const string &s) {
			int l = 1;
			int r = s.length();
			while(l < r) {
				const int mid = (l + r) / 2 + 1;
				const int res = getMinUniqueCharCnt(s, mid);
				if(res > 2) {
					r = mid - 1;
				} else {
					l = mid;
				}
			}
			return l;
		}
	}// namespace longest_substring_with_at_most_two_distinct_characters

	namespace longest_substring_with_at_most_k_distinct_characters {
		int Solution::lengthOfLongestSubstringKDistinct(const string &s, int k) {
			if(k == 0) {
				return 0;
			}
			int l = 1;
			int r = s.length();
			while(l < r) {
				const int mid = (l + r) / 2 + 1;
				const int res = longest_substring_with_at_most_two_distinct_characters::Solution::getMinUniqueCharCnt(s, mid);
				if(res > k) {
					r = mid - 1;
				} else {
					l = mid;
				}
			}
			return l;
		}
	}// namespace longest_substring_with_at_most_k_distinct_characters

	namespace max_consecutive_ones_iii {
		int Solution::longestOnes(vector<int> &nums, int k) {
			int l = 0;
			int r = nums.size();
			while(l < r) {
				const int mid = (l + r) / 2 + 1;
				const int res = cntMinFlip(nums, mid);
				if(res > k) {
					r = mid - 1;
				} else {
					l = mid;
				}
			}
			return l;
		}

		int Solution::cntMinFlip(vector<int> &nums, int len) {
			if(len == 0) {
				return 0;
			}
			int current = 0;
			for(int i = 0; i < len; i++) {
				if(nums[i] == 0) {
					current++;
				}
			}
			int ans = current;
			for(int i = 0, j = len; j < nums.size(); i++, j++) {
				if(nums[i] == 0) {
					current--;
				}
				if(nums[j] == 0) {
					current++;
				}
				ans = min(ans, current);
			}
			return ans;
		}
	}// namespace max_consecutive_ones_iii

	namespace sliding_window_maximum {
		vector<int> Solution::maxSlidingWindow(vector<int> &nums, int k) {
			multiset<int> ms;
			for(int i = 0; i < k; i++) {
				ms.insert(nums[i]);
			}
			vector<int> ans;
			for(int i = 0, j = k; j < nums.size(); i++, j++) {
				ans.emplace_back(*ms.rbegin());
				ms.erase(ms.lower_bound(nums[i]));
				ms.insert(nums[j]);
			}
			ans.emplace_back(*ms.rbegin());
			return ans;
		}
	}// namespace sliding_window_maximum

	namespace minimum_window_substring {
		string Solution::minWindow(string s, const string &t) {
			string ans = s;
			int l      = 0;
			int r      = 0;
			unordered_map<char, int> umt;
			unordered_map<char, int> ums;
			ums[s[0]]++;
			for(char ch: t) {
				umt[ch]++;
			}
			bool flag = true;
			while(l <= r && r < s.length() && l < s.length()) {
				while(!valid(ums, umt) && r + 1 < s.length()) {
					ums[s[++r]]++;
				}
				while(valid(ums, umt) && l < s.length()) {
					flag = false;
					if(r - l + 1 < ans.length()) {
						ans = s.substr(l, r - l + 1);
					}
					ums[s[l++]]--;
				}
				if(flag) {
					return "";
				}
				if(r == s.length() - 1) {
					break;
				}
			}
			return ans;
		}

		bool Solution::valid(unordered_map<char, int> &ums, const unordered_map<char, int> &umt) {
			for(const auto &[k, v]: umt) {
				if(!ums.contains(k) || ums[k] < v) {
					return false;
				}
			}
			return true;
		}
	}// namespace minimum_window_substring

	namespace walls_and_gates {
		void Solution::wallsAndGates(vector<vector<int>> &rooms) {
			const int m = rooms.size();
			const int n = rooms[0].size();
			queue<tuple<int, int, int>> q;
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					if(rooms[i][j] == 0) {
						q.push({0, i, j});
					}
				}
			}
			while(!q.empty()) {
				auto [d, x, y] = q.front();
				q.pop();
				pair<int, int> nexts[4] = {{x + 1, y}, {x - 1, y}, {x, y + 1}, {x, y - 1}};
				for(auto &[next_x, next_y]: nexts) {
					if(next_x >= 0 && next_y >= 0 && next_x < m && next_y < n && rooms[next_x][next_y] != -1 && rooms[next_x][next_y] != 0 && (rooms[next_x][next_y] == INT_MAX || rooms[next_x][next_y] > d + 1)) {
						rooms[next_x][next_y] = d + 1;
						q.push({d + 1, next_x, next_y});
					}
				}
			}
		}
	}// namespace walls_and_gates

	namespace pacific_atlantic_waterflow {
		vector<vector<int>> Solution::pacificAtlantic(vector<vector<int>> &heights) {
			const int m = heights.size();
			const int n = heights[0].size();
			unordered_set<pair<int, int>, myhash, myeq> pacific;
			unordered_set<pair<int, int>, myhash, myeq> atlantic;
			queue<pair<int, int>> q;
			vector<vector<int>> ans;

			for(int i = 0; i < m; i++) {
				q.push({i, 0});
				pacific.insert({i, 0});
			}
			for(int i = 1; i < n; i++) {
				q.push({0, i});
				pacific.insert({0, i});
			}
			while(!q.empty()) {
				auto [x, y] = q.front();
				q.pop();
				pair<int, int> nexts[4] = {{x + 1, y}, {x - 1, y}, {x, y + 1}, {x, y - 1}};
				for(auto &[next_x, next_y]: nexts) {
					if(next_x >= 0 && next_y >= 0 && next_x < m && next_y < n && heights[next_x][next_y] >= heights[x][y] && !pacific.contains({next_x, next_y})) {
						pacific.insert({next_x, next_y});
						q.push({next_x, next_y});
					}
				}
			}

			for(int i = 0; i < m; i++) {
				q.push({i, n - 1});
				atlantic.insert({i, n - 1});
			}
			for(int i = 0; i < n - 1; i++) {
				q.push({m - 1, i});
				atlantic.insert({m - 1, i});
			}
			while(!q.empty()) {
				auto [x, y] = q.front();
				q.pop();
				pair<int, int> nexts[4] = {{x + 1, y}, {x - 1, y}, {x, y + 1}, {x, y - 1}};
				for(auto &[next_x, next_y]: nexts) {
					if(next_x >= 0 && next_y >= 0 && next_x < m && next_y < n && heights[next_x][next_y] >= heights[x][y] && !atlantic.contains({next_x, next_y})) {
						atlantic.insert({next_x, next_y});
						q.push({next_x, next_y});
					}
				}
			}

			for(const auto &p: atlantic) {
				if(pacific.contains(p)) {
					vector vec = {p.first, p.second};
					ans.emplace_back(vec);
				}
			}
			sort(ans.begin(), ans.end());
			return ans;
		}

		bool myeq::operator()(const pair<int, int> &p1, const pair<int, int> &p2) const { return p1 == p2; }

		size_t myhash::operator()(const pair<int, int> &p) const { return p.first * 200 + p.second; }
	}// namespace pacific_atlantic_waterflow

	namespace find_all_the_lonely_nodes {
		vector<int> Solution::getLonelyNodes(TreeNode *root) {
			vector<int> ans;
			queue<TreeNode *> q;
			q.push(root);
			while(!q.empty()) {
				const TreeNode *node = q.front();
				q.pop();
				if(node->left == nullptr && node->right != nullptr) {
					ans.emplace_back(node->right->val);
				} else if(node->right == nullptr && node->left != nullptr) {
					ans.emplace_back(node->left->val);
				}
				if(node->left != nullptr) {
					q.push(node->left);
				}
				if(node->right != nullptr) {
					q.push(node->right);
				}
			}
			return ans;
		}
	}// namespace find_all_the_lonely_nodes

	namespace kill_process {
		vector<int> Solution::killProcess(vector<int> &pid, vector<int> &ppid, int kill) {
			unordered_map<int, Node *> um;
			for(const auto &v: pid) {
				um[v] = new Node(v);
			}
			for(int i = 0; i < pid.size(); i++) {
				if(ppid[i] != 0) {
					um[ppid[i]]->children.insert(um[pid[i]]);
				}
			}
			vector<int> ans;
			queue<Node *> q;
			q.push(um[kill]);
			while(!q.empty()) {
				Node *node = q.front();
				q.pop();
				ans.emplace_back(node->val);
				for(auto *next: node->children) {
					q.push(next);
				}
			}
			return ans;
		}
	}// namespace kill_process

	namespace all_nodes_distance_k_in_binary_tree {
		vector<int> Solution::distanceK(TreeNode *root, TreeNode *target, int k) {
			if(k == 0) {
				return {target->val};
			}
			unordered_map<TreeNode *, Node *> um;
			vector<int> ans;
			queue<TreeNode *> q1;
			q1.push(root);
			um[root] = new Node(root->val);
			while(!q1.empty()) {
				TreeNode *tn = q1.front();
				q1.pop();
				if(tn->left != nullptr) {
					q1.push(tn->left);
					um[tn->left] = new Node(tn->left->val);
					um[tn->left]->siblings.insert(um[tn]);
					um[tn]->siblings.insert(um[tn->left]);
				}
				if(tn->right != nullptr) {
					q1.push(tn->right);
					um[tn->right] = new Node(tn->right->val);
					um[tn->right]->siblings.insert(um[tn]);
					um[tn]->siblings.insert(um[tn->right]);
				}
			}
			Node *node = um[target];
			unordered_set<Node *> vis;
			queue<pair<int, Node *>> q2;
			q2.push({0, node});
			while(!q2.empty()) {
				auto [d, nd] = q2.front();
				q2.pop();
				vis.insert(nd);
				for(auto *sibling: nd->siblings) {
					if(!vis.contains(sibling)) {
						vis.insert(sibling);
						if(d + 1 == k) {
							ans.emplace_back(sibling->val);
						} else {
							q2.push({d + 1, sibling});
						}
					}
				}
			}
			return ans;
		}
	}// namespace all_nodes_distance_k_in_binary_tree

	namespace open_the_lock {
		int Solution::openLock(vector<string> &deadends, const string &target) {
			unordered_set<string> deads;
			unordered_set<string> vis;
			for(auto &deadend: deadends) {
				deads.insert(deadend);
			}
			auto get_nexts = [](const string &code) {
				vector ans(8, code);
				ans[0][0] = (ans[0][0] - '0' + 10 + 1) % 10 + '0';
				ans[1][0] = (ans[1][0] - '0' + 10 - 1) % 10 + '0';
				ans[2][1] = (ans[2][1] - '0' + 10 + 1) % 10 + '0';
				ans[3][1] = (ans[3][1] - '0' + 10 - 1) % 10 + '0';
				ans[4][2] = (ans[4][2] - '0' + 10 + 1) % 10 + '0';
				ans[5][2] = (ans[5][2] - '0' + 10 - 1) % 10 + '0';
				ans[6][3] = (ans[6][3] - '0' + 10 + 1) % 10 + '0';
				ans[7][3] = (ans[7][3] - '0' + 10 - 1) % 10 + '0';
				return ans;
			};
			queue<pair<int, string>> q;
			q.push({0, "0000"});
			while(!q.empty()) {
				auto [step, code] = q.front();
				if(code == target) {
					return step;
				}
				vis.insert(code);
				q.pop();
				if(deads.contains(code)) {
					continue;
				}
				auto nexts = get_nexts(code);
				for(auto &next: nexts) {
					if(!vis.contains(next)) {
						vis.insert(next);
						if(next == target) {
							return step + 1;
						}
						q.push({step + 1, next});
					}
				}
			}
			return -1;
		}
	}// namespace open_the_lock

	namespace number_of_operations_to_make_network_connected {
		int Solution::makeConnected(int n, vector<vector<int>> &connections) {
			vector<unordered_set<int>> g(n);
			for(auto &connection: connections) {
				g[connection[0]].insert(connection[1]);
				g[connection[1]].insert(connection[0]);
			}
			int group_cnt      = 0;
			int free_edges_cnt = 0;
			unordered_set<int> vis;
			for(int i = 0; i < n; i++) {
				if(!vis.contains(i)) {
					int edge_cnt = 0;
					int node_cnt = 0;
					dfs(edge_cnt, node_cnt, vis, i, g);
					group_cnt++;
					free_edges_cnt += edge_cnt / 2 - node_cnt + 1;
				}
			}
			if(free_edges_cnt < group_cnt - 1) {
				return -1;
			}
			return group_cnt - 1;
		}

		void Solution::dfs(int &edge_cnt, int &node_cnt, unordered_set<int> &vis, int node, vector<unordered_set<int>> &g) {
			node_cnt++;
			edge_cnt += g[node].size();
			vis.insert(node);
			for(auto next: g[node]) {
				if(!vis.contains(next)) {
					dfs(edge_cnt, node_cnt, vis, next, g);
				}
			}
		}
	}// namespace number_of_operations_to_make_network_connected

	namespace minimum_cost_to_make_at_least_one_valid_path_in_a_grid {
		int Solution::minCost(vector<vector<int>> &grid) {
			const int m = grid.size();
			const int n = grid[0].size();
			vector g(m, vector<Node *>(n, nullptr));
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					g[i][j] = new Node(i, j);
				}
			}
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					pair<int, int> nexts[4] = {{i + 1, j}, {i - 1, j}, {i, j + 1}, {i, j - 1}};
					for(auto [x, y]: nexts) {
						if(x >= 0 && x < m && y >= 0 && y < n) {
							g[i][j]->siblings.insert(make_pair(g[x][y], 1));
						}
					}
					int x = i;
					int y = j;
					switch(grid[i][j]) {
						case 1:
							y++;
							break;
						case 2:
							y--;
							break;
						case 3:
							x++;
							break;
						case 4:
							x--;
							break;
					}
					if(x >= 0 && x < m && y >= 0 && y < n) {
						g[i][j]->siblings[g[x][y]] = 0;
					}
				}
			}
			priority_queue<pair<int, Node *>, vector<pair<int, Node *>>, mycmp> pq;
			unordered_set<Node *> vis;
			pq.push({0, g[0][0]});
			while(!pq.empty()) {
				auto [cost, node] = pq.top();
				pq.pop();
				if(vis.contains(node)) {
					continue;
				}
				vis.insert(node);
				if(node->x == m - 1 && node->y == n - 1) {
					return cost;
				}
				for(auto [sibling, c]: node->siblings) {
					if(!vis.contains(sibling)) {
						pq.push({cost + c, sibling});
					}
				}
			}
			return 0;
		}

		bool mycmp::operator()(const pair<int, Node *> &p1, const pair<int, Node *> &p2) const {
			if(p1.first != p2.first) {
				return p1.first > p2.first;
			}
			return p1.second->x + p1.second->y < p2.second->x + p2.second->y;
		}
	}// namespace minimum_cost_to_make_at_least_one_valid_path_in_a_grid

	namespace critical_connections_in_a_network {
		vector<vector<int>> Solution::criticalConnections(int n, vector<vector<int>> &connections) {
			vector<unordered_set<int>> g(n);
			for(auto &conn: connections) {
				g[conn[0]].insert(conn[1]);
				g[conn[1]].insert(conn[0]);
			}
			vector<vector<int>> ans;
			vector dfn(n, -1);
			vector low(n, -1);
			unordered_set<int> vis;
			int step = 0;
			for(int i = 0; i < n; i++) {
				if(dfn[i] == -1) {
					step = 0;
					tarjan(-1, step, dfn, i, g, low, ans);
				}
			}
			return ans;
		}

		void Solution::tarjan(int prev, int &step, vector<int> &dfn, int node, vector<unordered_set<int>> &g, vector<int> &low, vector<vector<int>> &ans) {
			dfn[node] = step;
			low[node] = step;
			for(const auto &next: g[node]) {
				if(dfn[next] == -1) {
					tarjan(node, ++step, dfn, next, g, low, ans);
				}
				if(next != prev) {
					low[node] = min(low[node], low[next]);
				}
				if(dfn[node] < low[next]) {
					ans.push_back({node, next});
				}
			}
		}
	}// namespace critical_connections_in_a_network

	namespace factor_combinations {
		vector<vector<int>> Solution::getFactorsWithMin(int n, int minimum) {
			vector<vector<int>> ans;
			for(int i = minimum; i <= sqrt(n); i++) {
				if(n % i == 0) {
					ans.push_back({i, n / i});
					auto res = getFactorsWithMin(n / i, i);
					for(auto &vec: res) {
						ans.push_back({i});
						ans.back().insert(ans.back().end(), vec.begin(), vec.end());
					}
				}
			}
			return ans;
		}

		vector<vector<int>> Solution::getFactors(int n) { return getFactorsWithMin(n, 2); }
	}// namespace factor_combinations

	namespace decode_string {
		string Solution::decodeString(string s) {
			int i = 0;
			vector<int> cnt;
			vector<string> strs;
			while(i < s.length()) {
				if(isalpha(s[i]) != 0) {
					cnt.emplace_back(1);
					strs.emplace_back(string(1, s[i]));
					i++;
				} else if(isdigit(s[i]) != 0) {
					int j = i + 1;
					while(j < s.length() && isdigit(s[j]) != 0) {
						j++;
					}
					cnt.emplace_back(stoi(s.substr(i, j - i)));
					i         = j;
					int level = 1;
					while(level > 0) {
						j++;
						if(s[j] == '[') {
							level++;
						} else if(s[j] == ']') {
							level--;
						}
					}
					strs.emplace_back(decodeString(s.substr(i + 1, j - i - 1)));
					i = j + 1;
				}
			}
			ostringstream oss;
			for(i = 0; i < cnt.size(); i++) {
				for(int j = 0; j < cnt[i]; j++) {
					oss << strs[i];
				}
			}
			return oss.str();
		}
	}// namespace decode_string

	namespace n_queens {
		vector<vector<string>> Solution::solveNQueens(int n) {
			vector<vector<string>> ans;
			const vector board(n, vector(n, false));
			dfs(board, 0, n, ans);
			return ans;
		}

		void Solution::dfs(const vector<vector<bool>> &board, int line, int n, vector<vector<string>> &ans) {
			if(line == n) {
				ans.emplace_back(toStringVec(board));
				return;
			}
			for(int i = 0; i < n; i++) {
				if(valid(board, n, line, i)) {
					vector<vector<bool>> next = board;
					next[line][i]             = true;
					dfs(next, line + 1, n, ans);
				}
			}
		}

		bool Solution::valid(const vector<vector<bool>> &board, int n, int x, int y) {
			for(int i = 0; i < x; i++) {
				if(board[i][y]) {
					return false;
				}
			}
			for(int i = x, j = y; i >= 0 && i < n && j >= 0 && j < n; i--, j--) {
				if(board[i][j]) {
					return false;
				}
			}
			for(int i = x, j = y; i >= 0 && i < n && j >= 0 && j < n; i--, j++) {
				if(board[i][j]) {
					return false;
				}
			}
			return true;
		}

		vector<string> Solution::toStringVec(const vector<vector<bool>> &board) {
			vector<string> ans(board.size());
			for(int i = 0; i < board.size(); i++) {
				ostringstream oss;
				for(int j = 0; j < board[i].size(); j++) {
					oss << (board[i][j] ? 'Q' : '.');
				}
				ans[i] = oss.str();
			}
			return ans;
		}
	}// namespace n_queens

	namespace sudoku_solver {
		void Solution::solveSudoku(vector<vector<char>> &board) { dfs(board, board); }

		bool Solution::dfs(const vector<vector<char>> &board, vector<vector<char>> &ans) {
			for(int i = 0; i < 9; i++) {
				for(int j = 0; j < 9; j++) {
					if(board[i][j] == '.') {
						for(char c = '1'; c <= '9'; c++) {
							if(valid(board, i, j, c)) {
								bool haveValid            = true;
								vector<vector<char>> next = board;
								next[i][j]                = c;
								if(dfs(next, ans)) {
									return true;
								}
							}
						}
						return false;
					}
				}
			}
			ans = board;
			return true;
		}

		bool Solution::valid(const vector<vector<char>> &board, int x, int y, char num) {
			for(int i = 0; i < 9; i++) {
				if(board[i][y] == num) {
					return false;
				}
			}
			for(int j = 0; j < 9; j++) {
				if(board[x][j] == num) {
					return false;
				}
			}
			for(int i = 0; i < 3; i++) {
				for(int j = 0; j < 3; j++) {
					if(board[x / 3 * 3 + i][y / 3 * 3 + j] == num) {
						return false;
					}
				}
			}
			return true;
		}
	}// namespace sudoku_solver

	namespace regular_expression_matching {
		bool Solution::isMatch(const string &s, const string &p) { return dfs(s, p, 0, 0); }

		bool Solution::dfs(const string &s, const string &p, int si, int pi) {
			if(pi == p.length() && si == s.length()) {
				return true;
			}
			if(pi == p.length()) {
				return false;
			}
			const char c  = p[pi++];
			bool multiple = false;
			if(pi < p.length() && p[pi] == '*') {
				multiple = true;
				pi++;
			}
			if(!multiple) {
				if(si == s.length()) {
					return false;
				}
				if(c == '.' || s[si] == c) {
					return dfs(s, p, si + 1, pi);
				}
				return false;
			}
			if(c == '.') {
				for(int i = si; i <= s.length(); i++) {
					if(dfs(s, p, i, pi)) {
						return true;
					}
				}
				return false;
			}
			int i = si;
			while(s[i] == c) {
				if(dfs(s, p, ++i, pi)) {
					return true;
				}
			}
			return dfs(s, p, si, pi);
		}
	}// namespace regular_expression_matching

	namespace different_ways_to_add_parentheses {
		vector<int> Solution::eval(const string &expr, int start, int end) {
			vector<int> ans;
			bool allDigit = true;
			for(int i = start; i <= end; i++) {
				if(!isdigit(expr[i])) {
					allDigit     = false;
					vector left  = eval(expr, start, i - 1);
					vector right = eval(expr, i + 1, end);
					for(const auto &l: left) {
						for(const auto &r: right) {
							switch(expr[i]) {
								case '+':
									ans.emplace_back(l + r);
									break;
								case '-':
									ans.emplace_back(l - r);
									break;
								case '*':
									ans.emplace_back(l * r);
									break;
							}
						}
					}
				}
			}
			if(allDigit) {
				int val = 0;
				for(int i = start; i <= end; i++) {
					val *= 10;
					val += expr[i] - '0';
				}
				ans.emplace_back(val);
			}
			return ans;
		}

		vector<int> Solution::diffWaysToCompute(const string &expression) {
			vector ans = eval(expression, 0, expression.length() - 1);
			sort(ans.begin(), ans.end());
			return ans;
		}
	}// namespace different_ways_to_add_parentheses

	namespace remove_invalid_parentheses {
		vector<string> Solution::removeInvalidParentheses(const string &s) {
			vector<string> ans;
			unordered_set<string> currSet;

			currSet.insert(s);
			while(true) {
				for(auto &str: currSet) {
					if(isValid(str))
						ans.emplace_back(str);
				}
				if(!ans.empty()) {
					sort(ans.begin(), ans.end());
					return ans;
				}
				unordered_set<string> nextSet;
				for(auto &str: currSet) {
					for(int i = 0; i < str.size(); i++) {
						if(i > 0 && str[i] == str[i - 1]) {
							continue;
						}
						if(str[i] == '(' || str[i] == ')') {
							nextSet.insert(str.substr(0, i) + str.substr(i + 1, str.size()));
						}
					}
				}
				currSet = nextSet;
			}
		}

		bool Solution::isValid(const string &str) {
			int count = 0;

			for(const char c: str) {
				if(c == '(') {
					count++;
				} else if(c == ')') {
					count--;
					if(count < 0) {
						return false;
					}
				}
			}

			return count == 0;
		}
	}// namespace remove_invalid_parentheses

	namespace median_of_two_sorted_arrays {
		double Solution::findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2) {
			if(nums1.size() > nums2.size()) {
				return findMedianSortedArrays(nums2, nums1);
			}

			const int m = nums1.size();
			const int n = nums2.size();
			int left = 0, right = m;
			// median1：前一部分的最大值
			// median2：后一部分的最小值
			int median1 = 0, median2 = 0;

			while(left <= right) {
				// 前一部分包含 nums1[0 .. i-1] 和 nums2[0 .. j-1]
				// 后一部分包含 nums1[i .. m-1] 和 nums2[j .. n-1]
				const int i = (left + right) / 2;
				const int j = (m + n + 1) / 2 - i;

				// nums_im1, nums_i, nums_jm1, nums_j 分别表示 nums1[i-1], nums1[i], nums2[j-1], nums2[j]
				int nums_im1 = i == 0 ? INT_MIN : nums1[i - 1];
				int nums_i   = i == m ? INT_MAX : nums1[i];
				int nums_jm1 = j == 0 ? INT_MIN : nums2[j - 1];
				int nums_j   = j == n ? INT_MAX : nums2[j];

				if(nums_im1 <= nums_j) {
					median1 = max(nums_im1, nums_jm1);
					median2 = min(nums_i, nums_j);
					left    = i + 1;
				} else {
					right = i - 1;
				}
			}

			return (m + n) % 2 == 0 ? (median1 + median2) / 2.0 : median1;
		}
	}// namespace median_of_two_sorted_arrays

	namespace count_of_smaller_numbers_after_self {
		vector<int> Solution::countSmaller(vector<int> &nums) {
			vector<int> resultList;

			Discretization(nums);

			Init(nums.size() + 5);

			for(int i = static_cast<int>(nums.size()) - 1; i >= 0; --i) {
				const int id = getId(nums[i]);
				resultList.push_back(Query(id - 1));
				Update(id);
			}

			reverse(resultList.begin(), resultList.end());

			return resultList;
		}

		void Solution::Init(int length) { c.resize(length, 0); }

		int Solution::LowBit(int x) { return x & -x; }

		void Solution::Update(int pos) {
			while(pos < c.size()) {
				c[pos] += 1;
				pos += LowBit(pos);
			}
		}

		int Solution::Query(int pos) const {
			int ret = 0;

			while(pos > 0) {
				ret += c[pos];
				pos -= LowBit(pos);
			}

			return ret;
		}

		void Solution::Discretization(vector<int> &nums) {
			a.assign(nums.begin(), nums.end());
			sort(a.begin(), a.end());
			a.erase(unique(a.begin(), a.end()), a.end());
		}

		int Solution::getId(int x) { return lower_bound(a.begin(), a.end(), x) - a.begin() + 1; }
	}// namespace count_of_smaller_numbers_after_self

	namespace best_time_to_buy_and_sell_stock_with_cooldown {
		int Solution::maxProfit(vector<int> &prices) {
			if(prices.empty()) {
				return 0;
			}

			const int n = prices.size();
			int f0      = -prices[0];
			int f1      = 0;
			int f2      = 0;
			for(int i = 1; i < n; ++i) {
				tie(f0, f1, f2) = make_tuple(max(f0, f2 - prices[i]), f0 + prices[i], max(f1, f2));
			}

			return max(f1, f2);
		}
	}// namespace best_time_to_buy_and_sell_stock_with_cooldown

	namespace best_time_to_buy_and_sell_stock_with_transaction_fee {
		int Solution::maxProfit(vector<int> &prices, int fee) {
			const int n = prices.size();
			vector<int> holding(n);
			vector<int> not_holding(n);
			not_holding[0] = 0;
			holding[0]     = -prices[0];
			for(int i = 1; i < n; i++) {
				not_holding[i] = max(not_holding[i - 1], holding[i - 1] + prices[i] - fee);
				holding[i]     = max(holding[i - 1], not_holding[i - 1] - prices[i]);
			}
			return max(not_holding.back(), holding.back());
		}
	}// namespace best_time_to_buy_and_sell_stock_with_transaction_fee

	namespace split_array_largest_sum {
		int Solution::splitArray(vector<int> &nums, int m) {
			int l = 0;
			int r = 0;
			for(auto num: nums) {
				r += num;
				l = max(l, num);
			}
			while(l < r) {
				const int mid = (l + r) / 2;
				const int cnt = get_m(nums, mid);
				if(cnt == m) {
					r = mid;
				} else if(cnt > m) {
					l = mid + 1;
				} else if(cnt < m) {
					r = mid - 1;
				}
			}
			return l;
		}

		int Solution::get_m(const vector<int> &nums, int msum) {
			int ans = 0;
			int c   = 0;
			for(const auto num: nums) {
				if(c + num > msum) {
					ans++;
					c = 0;
				}
				c += num;
			}
			if(c > 0) {
				ans++;
			}
			return ans;
		}
	}// namespace split_array_largest_sum

	namespace house_robber_iii {
		int Solution::rob(TreeNode *root) {
			int ans = 0;
			return max(dfs(true, root), dfs(false, root));
		}

		int Solution::dfs(bool steal, TreeNode *node) {
			if(um.contains({node, steal})) {
				return um[{node, steal}];
			}
			int ans = steal ? node->val : 0;
			if(node->left != nullptr) {
				const int ns = dfs(!steal, node->left);
				const int s  = !steal ? dfs(steal, node->left) : 0;
				ans += max(s, ns);
			}
			if(node->right != nullptr) {
				const int ns = dfs(!steal, node->right);
				const int s  = !steal ? dfs(steal, node->right) : 0;
				ans += max(s, ns);
			}
			um[{node, steal}] = ans;
			return ans;
		}

		size_t myhash::operator()(const pair<TreeNode *, bool> &p) const { return (uint64_t) p.first * 2 + (p.second ? 1 : 0); }

		bool myeq::operator()(const pair<TreeNode *, bool> &p1, const pair<TreeNode *, bool> &p2) const { return p1.first == p2.first && p1.second == p2.second; }
	}// namespace house_robber_iii

	namespace maximal_square {
		int Solution::maximalSquare(vector<vector<char>> &matrix) {
			const int m = matrix.size();
			const int n = matrix[0].size();
			vector horizontal_next_1s(m, vector(n, 0));
			vector vertical_next_1s(m, vector(n, 0));
			vector dp(m + 1, vector(n + 1, 0));
			for(int i = 0; i < m; i++) {
				int cnt = 0;
				for(int j = n - 1; j >= 0; j--) {
					if(matrix[i][j] == '1') {
						cnt++;
					} else {
						cnt = 0;
					}
					horizontal_next_1s[i][j] = cnt;
				}
			}
			for(int j = 0; j < n; j++) {
				int cnt = 0;
				for(int i = m - 1; i >= 0; i--) {
					if(matrix[i][j] == '1') {
						cnt++;
					} else {
						cnt = 0;
					}
					vertical_next_1s[i][j] = cnt;
				}
			}
			int ans = 0;
			for(int i = m - 1; i >= 0; i--) {
				for(int j = n - 1; j >= 0; j--) {
					if(matrix[i][j] == '1') {
						dp[i][j] = min(min(vertical_next_1s[i][j], horizontal_next_1s[i][j]), 1 + dp[i + 1][j + 1]);
						ans      = max(ans, dp[i][j]);
					}
				}
			}
			return ans * ans;
		}
	}// namespace maximal_square

	namespace maximal_rectangle {
		int Solution::maximalRectangle(vector<vector<char>> &matrix) {
			const int m = matrix.size();
			if(m == 0) {
				return 0;
			}
			const int n = matrix[0].size();
			vector left(m, vector(n, 0));

			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					if(matrix[i][j] == '1') {
						left[i][j] = (j == 0 ? 0 : left[i][j - 1]) + 1;
					}
				}
			}

			int ret = 0;
			for(int j = 0; j < n; j++) {
				// 对于每一列，使用基于柱状图的方法
				vector<int> up(m, 0), down(m, 0);

				stack<int> stk;
				for(int i = 0; i < m; i++) {
					while(!stk.empty() && left[stk.top()][j] >= left[i][j]) {
						stk.pop();
					}
					up[i] = stk.empty() ? -1 : stk.top();
					stk.push(i);
				}
				stk = stack<int>();
				for(int i = m - 1; i >= 0; i--) {
					while(!stk.empty() && left[stk.top()][j] >= left[i][j]) {
						stk.pop();
					}
					down[i] = stk.empty() ? m : stk.top();
					stk.push(i);
				}

				for(int i = 0; i < m; i++) {
					const int height = down[i] - up[i] - 1;
					int area         = height * left[i][j];
					ret              = max(ret, area);
				}
			}
			return ret;
		}
	}// namespace maximal_rectangle

	namespace predict_the_winner {
		bool Solution::PredictTheWinner(vector<int> &nums) {
			const int length = nums.size();
			auto dp          = vector<int>(length);
			for(int i = 0; i < length; i++) {
				dp[i] = nums[i];
			}
			for(int i = length - 2; i >= 0; i--) {
				for(int j = i + 1; j < length; j++) {
					dp[j] = max(nums[i] - dp[j], nums[j] - dp[j - 1]);
				}
			}
			return dp[length - 1] >= 0;
		}
	}// namespace predict_the_winner

	namespace palindrome_partitioning {

		vector<vector<string>> Solution::partition(const string &s) {
			const vector<string> vec;
			vector<vector<string>> ans;
			dfs(vec, s, ans, 0, 0);
			return ans;
		}

		bool Solution::is_palindromic(const string &s, int start, int end) {
			for(int i = start, j = end; i < j; i++, j--) {
				if(s[i] != s[j]) {
					return false;
				}
			}
			return true;
		}

		void Solution::dfs(const vector<string> &current, const string &s, vector<vector<string>> &ans, int start, int cursor) {
			if(cursor == s.length() - 1 && is_palindromic(s, start, cursor)) {
				ans.emplace_back(current);
				ans.back().emplace_back(s.substr(start, cursor - start + 1));
				return;
			}
			if(cursor >= s.length() - 1 || start >= s.length()) {
				return;
			}
			if(is_palindromic(s, start, cursor)) {
				vector next = current;
				next.emplace_back(s.substr(start, cursor - start + 1));
				dfs(next, s, ans, cursor + 1, cursor + 1);
			}
			dfs(current, s, ans, start, cursor + 1);
		}
	}// namespace palindrome_partitioning

	namespace palindrome_partitioning_ii {
		int Solution::minCut(string s) {
			vector is_palindromic(s.length(), vector(s.length(), false));
			for(int i = 0; i < s.length(); i++) {
				for(int j = 0; i - j >= 0 && i + j < s.length() && s[i - j] == s[i + j]; j++) {
					is_palindromic[i - j][i + j] = true;
				}
			}
			for(int i = 0; i < s.length() - 1; i++) {
				if(s[i] == s[i + 1]) {
					for(int j = 0; i - j >= 0 && i + 1 + j < s.length() && s[i - j] == s[i + 1 + j]; j++) {
						is_palindromic[i - j][i + 1 + j] = true;
					}
				}
			}
			vector dp(s.length(), 2000);
			dp[0] = 0;
			for(int j = 1; j < dp.size(); j++) {
				if(is_palindromic[0][j]) {
					dp[j] = 0;
					continue;
				}
				for(int i = j; i >= 0; i--) {
					if(is_palindromic[i][j]) {
						dp[j] = min(dp[j], dp[i - 1] + 1);
					}
				}
			}
			return dp.back();
		}
	}// namespace palindrome_partitioning_ii

	namespace partition_equal_subset_sum {
		bool Solution::canPartition(vector<int> &nums) {
			const int n = nums.size();
			if(n < 2) {
				return false;
			}
			const int sum    = accumulate(nums.begin(), nums.end(), 0);
			const int maxNum = *max_element(nums.begin(), nums.end());
			if(sum & 1) {
				return false;
			}
			const int target = sum / 2;
			if(maxNum > target) {
				return false;
			}
			vector dp(n, vector(target + 1, 0));
			for(int i = 0; i < n; i++) {
				dp[i][0] = true;
			}
			dp[0][nums[0]] = true;
			for(int i = 1; i < n; i++) {
				const int num = nums[i];
				for(int j = 1; j <= target; j++) {
					if(j >= num) {
						dp[i][j] = dp[i - 1][j] | dp[i - 1][j - num];
					} else {
						dp[i][j] = dp[i - 1][j];
					}
				}
			}
			return dp[n - 1][target];
		}
	}// namespace partition_equal_subset_sum

	namespace minimum_cost_for_tickets {
		int Solution::mincostTickets(vector<int> &days, vector<int> &costs) {
			unordered_set<int> us;
			int end = 0;
			for(const auto &day: days) {
				us.insert(day);
				end = max(end, day);
			}
			vector dp(end + 1, 0);
			for(int i = 1; i <= end; i++) {
				dp[i] = i - 1 >= 0 ? dp[i - 1] : 0;
				if(us.contains(i)) {
					dp[i] += costs[0];
					dp[i] = min(dp[i], (i - 7 >= 0 ? dp[i - 7] : 0) + costs[1]);
					dp[i] = min(dp[i], (i - 30 >= 0 ? dp[i - 30] : 0) + costs[2]);
				}
			}
			return dp.back();
		}
	}// namespace minimum_cost_for_tickets

	namespace best_time_to_buy_and_sell_stock_iii {
		int Solution::maxProfit(vector<int> &prices) {
			vector dp(5, vector<long>(prices.size(), -10000000000));
			// 0 - 不持有
			// 1 - 第一次持有
			// 2 - 第一次卖出
			// 3 - 第二次持有
			// 4 - 第二次卖出
			dp[0][0] = 0;
			dp[1][0] = -prices[0];
			for(int i = 1; i < prices.size(); i++) {
				dp[0][i] = dp[0][i - 1];
				dp[1][i] = max(dp[1][i - 1], dp[0][i - 1] - prices[i]);
				dp[2][i] = max(dp[2][i - 1], dp[1][i - 1] + prices[i]);
				dp[3][i] = max(dp[3][i - 1], dp[2][i - 1] - prices[i]);
				dp[4][i] = max(dp[4][i - 1], dp[3][i - 1] + prices[i]);
			}
			long ans = dp[0].back();
			for(int i = 1; i <= 4; i++) {
				ans = max(ans, dp[i].back());
			}
			return ans;
		}
	}// namespace best_time_to_buy_and_sell_stock_iii

	namespace dungeon_game {
		int Solution::calculateMinimumHP(vector<vector<int>> &dungeon) {
			const int n = dungeon.size(), m = dungeon[0].size();
			vector dp(n + 1, vector(m + 1, INT_MAX));
			dp[n][m - 1] = dp[n - 1][m] = 1;
			for(int i = n - 1; i >= 0; --i) {
				for(int j = m - 1; j >= 0; --j) {
					const int minn = min(dp[i + 1][j], dp[i][j + 1]);
					dp[i][j]       = max(minn - dungeon[i][j], 1);
				}
			}
			return dp[0][0];
		}
	}// namespace dungeon_game

	namespace course_schedule {
		bool Solution::canFinish(int numCourses, vector<vector<int>> &prerequisites) {
			vector<int> in(numCourses);
			vector<unordered_set<int>> out(numCourses);
			unordered_set<int> learned;
			for(auto &prerequisite: prerequisites) {
				in[prerequisite[1]]++;
				out[prerequisite[0]].insert(prerequisite[1]);
			}
			bool hasChange = true;
			while(hasChange) {
				hasChange = false;
				for(int i = 0; i < numCourses; i++) {
					if(in[i] == 0 && !learned.contains(i)) {
						hasChange = true;
						learned.insert(i);
						for(auto &next: out[i]) {
							in[next]--;
						}
					}
				}
			}
			for(int i = 0; i < numCourses; i++) {
				if(in[i] != 0) {
					return false;
				}
			}
			return true;
		}
	}// namespace course_schedule

	namespace course_schedule_ii {
		vector<int> Solution::findOrder(int numCourses, vector<vector<int>> &prerequisites) {
			vector<int> ans;
			vector<int> in(numCourses);
			vector<unordered_set<int>> out(numCourses);
			unordered_set<int> learned;
			for(auto &prerequisite: prerequisites) {
				in[prerequisite[0]]++;
				out[prerequisite[1]].insert(prerequisite[0]);
			}
			bool hasChange = true;
			while(hasChange) {
				hasChange = false;
				for(int i = 0; i < numCourses; i++) {
					if(in[i] == 0 && !learned.contains(i)) {
						hasChange = true;
						learned.insert(i);
						ans.emplace_back(i);
						for(auto &next: out[i]) {
							in[next]--;
						}
					}
				}
			}
			if(ans.size() == numCourses) {
				return ans;
			}
			return {};
		}
	}// namespace course_schedule_ii

	namespace longest_increasing_path_in_a_matrix {
		int Solution::longestIncreasingPath(vector<vector<int>> &matrix) {
			if(matrix.empty() || matrix[0].empty()) {
				return 0;
			}
			rows            = matrix.size();
			columns         = matrix[0].size();
			auto outdegrees = vector(rows, vector<int>(columns));
			for(int i = 0; i < rows; ++i) {
				for(int j = 0; j < columns; ++j) {
					for(int k = 0; k < 4; ++k) {
						const int newRow = i + dirs[k][0], newColumn = j + dirs[k][1];
						if(newRow >= 0 && newRow < rows && newColumn >= 0 && newColumn < columns && matrix[newRow][newColumn] > matrix[i][j]) {
							++outdegrees[i][j];
						}
					}
				}
			}
			queue<pair<int, int>> q;
			for(int i = 0; i < rows; ++i) {
				for(int j = 0; j < columns; ++j) {
					if(outdegrees[i][j] == 0) {
						q.push({i, j});
					}
				}
			}
			int ans = 0;
			while(!q.empty()) {
				++ans;
				const int size = q.size();
				for(int i = 0; i < size; ++i) {
					const auto cell = q.front();
					q.pop();
					const int row = cell.first, column = cell.second;
					for(int k = 0; k < 4; ++k) {
						int newRow = row + dirs[k][0], newColumn = column + dirs[k][1];
						if(newRow >= 0 && newRow < rows && newColumn >= 0 && newColumn < columns && matrix[newRow][newColumn] < matrix[row][column]) {
							--outdegrees[newRow][newColumn];
							if(outdegrees[newRow][newColumn] == 0) {
								q.push({newRow, newColumn});
							}
						}
					}
				}
			}
			return ans;
		}
	}// namespace longest_increasing_path_in_a_matrix

	namespace parallel_courses {
		int Solution::minimumSemesters(int n, vector<vector<int>> &relations) {
			vector<node *> nodes(n);
			for(int i = 1; i <= n; i++) {
				nodes[i - 1] = new node(i, 0);
			}
			for(const auto &relation: relations) {
				nodes[relation[1] - 1]->pred.insert(nodes[relation[0] - 1]);
				nodes[relation[0] - 1]->out++;
			}
			bool flag = true;
			unordered_set<int> vis;
			while(flag) {
				flag = false;
				for(int i = 0; i < n; i++) {
					if(nodes[i]->out == 0) {
						if(vis.contains(i)) {
							continue;
						}
						vis.insert(i);
						flag = true;
						for(node *next: nodes[i]->pred) {
							next->out--;
							next->len = max(next->len, nodes[i]->len + 1);
						}
					}
				}
			}
			int ans = 0;
			for(int i = 0; i < n; i++) {
				if(nodes[i]->out != 0) {
					return -1;
				}
				ans = max(ans, nodes[i]->len);
			}
			return ans;
		}
	}// namespace parallel_courses

	namespace alien_dictionary {
		string Solution::alienOrder(vector<string> &words) {
			unordered_map<char, unordered_set<char>> g;
			unordered_map<char, int> in;
			ostringstream oss;
			unordered_set<char> charset;
			for(const auto &word: words) {
				for(const auto &ch: word) {
					charset.insert(ch);
				}
			}
			for(const auto &ch: charset) {
				g[ch]  = unordered_set<char>();
				in[ch] = 0;
			}
			int max_len = 0;
			for(const auto &word: words) {
				max_len = max(max_len, static_cast<int>(word.length()));
			}
			for(int i = 0; i < max_len; i++) {
				unordered_map<string, vector<string>> um;
				for(const auto &word: words) {
					if(word.length() >= i) {
						um[i > 0 ? word.substr(0, i) : ""].emplace_back(word);
					}
				}
				for(const auto &[pred, section]: um) {
					for(int j = 0, k = 1; k < section.size(); j++, k++) {
						if(i < section[j].length() && i < section[k].length()) {
							if(section[j][i] != section[k][i]) {
								g[section[j][i]].insert(section[k][i]);
							}
						} else if(i < section[j].length()) {
							return "";
						}
					}
				}
			}
			for(const auto &[k, section]: g) {
				for(const auto &n: section) {
					in[n]++;
				}
			}
			bool flag = true;
			unordered_set<char> vis;
			while(flag) {
				flag = false;
				for(const auto &[ch, n]: in) {
					if(n == 0 && !vis.contains(ch)) {
						flag = true;
						vis.insert(ch);
						oss << ch;
						for(const auto &nc: g[ch]) {
							in[nc]--;
						}
					}
				}
			}
			for(const auto &[ch, n]: in) {
				if(n != 0) {
					return "";
				}
			}
			return oss.str();
		}
	}// namespace alien_dictionary

	namespace single_number_iii {
		vector<int> Solution::singleNumber(vector<int> &nums) {
			int xorsum = 0;
			for(const int num: nums) {
				xorsum ^= num;
			}
			// 防止溢出
			const int lsb = xorsum == INT_MIN ? xorsum : xorsum & -xorsum;
			int type1 = 0, type2 = 0;
			for(const int num: nums) {
				if(num & lsb) {
					type1 ^= num;
				} else {
					type2 ^= num;
				}
			}
			return {type1, type2};
		}
	}// namespace single_number_iii

	namespace shortest_path_to_get_all_keys {
		int Solution::shortestPathAllKeys(vector<string> &grid) {
			priority_queue<frame> pq;
			int m        = grid.size();
			int n        = grid[0].size();
			int start_x  = 0;
			int start_y  = 0;
			int lock_cnt = 0;
			unordered_map<unsigned, vector<vector<int>>> min_step;
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < n; j++) {
					if(grid[i][j] == START) {
						start_x = i;
						start_y = j;
					} else if(isupper(grid[i][j])) {
						lock_cnt++;
					}
				}
			}
			frame start(start_x, start_y, lock_cnt);
			pq.push(start);
			while(!pq.empty()) {
				frame f = pq.top();
				pq.pop();
				if(f.keys.size() == lock_cnt) {
					return f.step;
				}
				if(!min_step.contains(f.get_mask())) {
					min_step[f.get_mask()] = vector(m, vector(n, INT_MAX));
				}
				if(min_step[f.get_mask()][f.x][f.y] <= f.step) {
					continue;
				}
				min_step[f.get_mask()][f.x][f.y] = f.step;
				const pair<int, int> nexts[4]    = {{f.x + 1, f.y}, {f.x - 1, f.y}, {f.x, f.y + 1}, {f.x, f.y - 1}};
				for(const auto &[n_x, n_y]: nexts) {
					if(n_x >= 0 && n_x < m && n_y >= 0 && n_y < n && grid[n_x][n_y] != WALL) {
						if(islower(grid[n_x][n_y])) {
							frame next = f;
							next.x     = n_x;
							next.y     = n_y;
							next.step++;
							next.keys.insert(grid[n_x][n_y]);
							if(!min_step.contains(next.get_mask())) {
								min_step[next.get_mask()] = vector(m, vector(n, INT_MAX));
							}
							if(min_step[next.get_mask()][n_x][n_y] > next.step) {
								pq.push(next);
							}
						} else if(isupper(grid[n_x][n_y])) {
							if(f.keys.contains(static_cast<char>(tolower(grid[n_x][n_y])))) {
								frame next = f;
								next.x     = n_x;
								next.y     = n_y;
								next.step++;
								if(!min_step.contains(next.get_mask())) {
									min_step[next.get_mask()] = vector(m, vector(n, INT_MAX));
								}
								if(min_step[next.get_mask()][n_x][n_y] > next.step) {
									pq.push(next);
								}
							}
						} else {
							frame next = f;
							next.x     = n_x;
							next.y     = n_y;
							next.step++;
							if(!min_step.contains(next.get_mask())) {
								min_step[next.get_mask()] = vector(m, vector(n, INT_MAX));
							}
							if(min_step[next.get_mask()][n_x][n_y] > next.step) {
								pq.push(next);
							}
						}
					}
				}
			}
			return -1;
		}

		bool frame::operator<(const frame &f) const {
			if(step != f.step) {
				return step > f.step;
			}
			return keys.size() < f.keys.size();
		}

		unsigned frame::get_mask() const {
			unsigned mask = 0;
			for(const auto &key: keys) {
				mask |= 1 << key - 'a';
			}
			return mask;
		}
	}// namespace shortest_path_to_get_all_keys

	namespace minimum_number_of_k_consecutive_bit_flips {
		int Solution::minKBitFlips(vector<int> &nums, int k) {
			const int n = nums.size();
			int ans = 0, revCnt = 0;
			for(int i = 0; i < n; ++i) {
				if(i >= k && nums[i - k] > 1) {
					revCnt ^= 1;
					nums[i - k] -= 2;// 复原数组元素，若允许修改数组 nums，则可以省略
				}
				if(nums[i] == revCnt) {
					if(i + k > n) {
						return -1;
					}
					++ans;
					revCnt ^= 1;
					nums[i] += 2;
				}
			}
			return ans;
		}
	}// namespace minimum_number_of_k_consecutive_bit_flips

	namespace design_underground_system {
		void UndergroundSystem::checkIn(int id, const string &stationName, int t) { records[id] = {stationName, t}; }
		void UndergroundSystem::checkOut(int id, const string &stationName, int t) { um[records[id].first][stationName].emplace_back(t - records[id].second); }

		double UndergroundSystem::getAverageTime(const string &startStation, const string &endStation) {
			int total = 0;
			for(const auto t: um[startStation][endStation]) {
				total += t;
			}
			return static_cast<double>(total) / um[startStation][endStation].size();
		}
	}// namespace design_underground_system

	namespace lru_cache {
		LRUCache::LRUCache(int capacity)
		    : capacity(capacity) {}

		int LRUCache::get(int key) {
			if(um.contains(key)) {
				if(key != keys.back()) {
					keys.erase(find(keys.begin(), keys.end(), key));
					keys.emplace_back(key);
				}
				return um[key];
			}
			return -1;
		}

		void LRUCache::put(int key, int value) {
			if(um.size() == capacity) {
				if(um.contains(key)) {
					//满 含
					if(key != keys.back()) {
						keys.erase(find(keys.begin(), keys.end(), key));
						keys.emplace_back(key);
					}
				} else {
					//满 不含
					um.erase(*keys.begin());
					keys.erase(keys.begin());
					keys.emplace_back(key);
				}
			} else {
				if(um.contains(key)) {
					//未满 含
					if(key != keys.back()) {
						keys.erase(find(keys.begin(), keys.end(), key));
						keys.emplace_back(key);
					}
				} else {
					//未满 不含
					keys.emplace_back(key);
				}
			}
			um[key] = value;
		}
	}// namespace lru_cache

	namespace time_based_key_value_store {
		void TimeMap::set(const string &key, string value, int timestamp) { um[key][timestamp] = std::move(value); }

		string TimeMap::get(const string &key, int timestamp) {
			const auto it = um[key].lower_bound(timestamp);
			return it == um[key].end() ? "" : it->second;
		}
	}// namespace time_based_key_value_store

	namespace range_module {
		void RangeModule::addRange(int left, int right) { tree.assign(left, right - 1, true); }

		bool RangeModule::queryRange(int left, int right) { return tree.check(left, right - 1); }

		void RangeModule::removeRange(int left, int right) { tree.assign(left, right - 1); }
	}// namespace range_module

	namespace lfu_cache {
		int LFUCache::get(int key) {
			if(capacity == 0) {
				return -1;
			}
			int ans = -1;
			if(um.contains(key)) {
				// 如果存在
				ans = um[key];
				cnt[key]++;                                                                   //增加计数
				const auto it = find(tnc[cnt[key] - 1].begin(), tnc[cnt[key] - 1].end(), key);//
				if(it != tnc[cnt[key] - 1].end()) {
					tnc[cnt[key] - 1].erase(it);
					if(tnc[cnt[key] - 1].empty()) {
						tnc.erase(cnt[key] - 1);
					}
				}
				tnc[cnt[key]].emplace_back(key);
			}
			return ans;
		}

		void LFUCache::put(int key, int value) {
			if(capacity == 0) {
				return;
			}
			cnt[key]++;
			if(um.size() == capacity) {
				//满
				if(um.contains(key)) {
					//已存在
					tnc[cnt[key] - 1].erase(find(tnc[cnt[key] - 1].begin(), tnc[cnt[key] - 1].end(), key));
					if(tnc[cnt[key] - 1].empty()) {
						tnc.erase(cnt[key] - 1);
					}
				} else {
					//不存在
					while(tnc.begin()->second.empty()) {
						tnc.erase(tnc.begin());
					}
					const auto evicted = tnc.begin()->second.begin();
					const int val      = *evicted;
					tnc.begin()->second.erase(evicted);
					cnt.erase(val);
					um.erase(val);
				}
			} else {
				//未满
				if(um.contains(key)) {
					//已存在
					tnc[cnt[key] - 1].erase(find(tnc[cnt[key] - 1].begin(), tnc[cnt[key] - 1].end(), key));
					if(tnc[cnt[key] - 1].empty()) {
						tnc.erase(cnt[key] - 1);
					}
				} else {
					//不存在
				}
			}
			tnc[cnt[key]].emplace_back(key);
			um[key] = value;
		}
	}// namespace lfu_cache

	namespace leetcode454_4sum_ii {
		int Solution::sumCount(int sum, int i) {
			if(mem[i].contains(sum)) {
				return mem[i][sum];
			}
			if(i == vec.size() - 1) {
				return vec[i][sum];
			}
			int ans = 0;
			for(const auto &[k, v]: vec[i]) {
				ans += v * sumCount(sum - k, i + 1);
			}
			mem[i][sum] = ans;
			return ans;
		}

		int Solution::fourSumCount(vector<int> &nums1, vector<int> &nums2, vector<int> &nums3, vector<int> &nums4) {
			mem = vector<unordered_map<int, int>>(4);
			vec = vector<unordered_map<int, int>>(4);
			for(const auto &num: nums1) {
				vec[0][num]++;
			}
			for(const auto &num: nums2) {
				vec[1][num]++;
			}
			for(const auto &num: nums3) {
				vec[2][num]++;
			}
			for(const auto &num: nums4) {
				vec[3][num]++;
			}
			return sumCount(0, 0);
		}
	}// namespace leetcode454_4sum_ii

	namespace maximum_size_subarray_sum_equals_k {
		int Solution::maxSubArrayLen(vector<int> &nums, int k) {
			auto pref_sum = vector(nums.size(), 0);
			pref_sum[0]   = nums[0];
			unordered_map<int, set<int>> um;
			um[0].insert(-1);
			um[nums[0]].insert(0);
			for(int i = 1; i < nums.size(); i++) {
				pref_sum[i] += nums[i] + pref_sum[i - 1];
				um[pref_sum[i]].insert(i);
			}
			int ans = 0;
			for(int i = nums.size() - 1; i >= 0; i--) {
				const int r = pref_sum[i];
				int l       = r - k;
				if(!um[l].empty()) {
					ans = max(ans, i - *um[l].begin());
				}
			}
			return ans;
		}
	}// namespace maximum_size_subarray_sum_equals_k

	namespace minimum_operations_to_transform_array {
		long long Solution::minOperations(vector<int> &nums1, vector<int> &nums2) {
			int extra          = nums2.back();
			long long step_cnt = 0;
			int nearest        = 0;
			int nearest_d      = INT_MAX;
			bool flag          = false;
			int status         = 1;
			for(int i = 0; i < nums1.size(); i++) {
				if(abs(nums1[i] - extra) < nearest_d) {
					nearest   = i;
					status    = 1;
					nearest_d = abs(nums1[i] - extra);
				}
				if(abs(nums2[i] - extra) < nearest_d) {
					nearest   = i;
					status    = 2;
					nearest_d = abs(nums2[i] - extra);
				}
				if((nums1[i] <= extra && extra <= nums2[i]) || (nums2[i] <= extra && extra <= nums1[i])) {
					flag = true;
				}
				step_cnt += abs(nums1[i] - nums2[i]);
			}
			if(flag) {
				return step_cnt + 1;
			} else if(status == 1) {
				return step_cnt + 1 + abs(nums1[nearest] - extra);
			} else
				return step_cnt + 1 + abs(nums2[nearest] - extra);
		}
	}// namespace minimum_operations_to_transform_array

	namespace maximize_sum_of_squares_of_digits {
		string Solution::maxSumOfSquares(int num, int sum) {
			ostringstream oss = {};
			if(9 * num < sum) {
				return "";
			}
			int cnt = 0;
			while(sum > 9) {
				oss << 9;
				cnt++;
				sum -= 9;
			}
			oss << sum;
			cnt++;
			while(num - cnt > 0) {
				cnt++;
				oss << 0;
			}

			return oss.str();
		}
	}// namespace maximize_sum_of_squares_of_digits

	namespace beast_reachable_tower {
		vector<int> Solution::bestTower(vector<vector<int>> &towers, vector<int> &center, int radius) {
			vector<tower> vec = vector<tower>();
			for(const auto t: towers) {
				tower nt = tower{t[0], t[1], t[2], abs(t[0] - center[0]) + abs(t[1] - center[1])};
				if(nt.d <= radius) {
					vec.push_back(nt);
				}
			}
			ranges::sort(vec, [](const tower &a, const tower &b) {
				if(a.f != b.f) {
					return a.f > b.f;
				}
				if(a.x != b.x) {
					return a.x < b.x;
				}
				return a.y < b.y;
			});
			if(vec.empty()) {
				return {-1, -1};
			} else {
				return {vec[0].x, vec[0].y};
			}
		}
	}// namespace beast_reachable_tower

	namespace minimum_operations_to_reach_target_array {
		int Solution::minOperations(vector<int> &nums, vector<int> &target) {
			unordered_set<int> s = {};
			for(int i = 0; i < nums.size(); i++) {
				if(nums[i] != target[i]) {
					s.insert(nums[i]);
				}
			}
			return s.size();
		}
	}// namespace minimum_operations_to_reach_target_array

	namespace minimum_cost_path_with_edge_reversals {
		bool status::operator<(const status &rhs) const {
			return this->weight > rhs.weight;
		}
		int Solution::minCost(int n, vector<vector<int>> &edges) {
			vector<node *> nodes(n);
			for(int i = 0; i < n; i++) {
				nodes[i] = new node(i);
			}
			for(const auto &edge: edges) {
				int u                    = edge[0];
				int v                    = edge[1];
				int w                    = edge[2];
				nodes[u]->to[nodes[v]]   = w;
				nodes[v]->from[nodes[u]] = w;
			}
			priority_queue<status> pq = {};
			unordered_set<int> vis    = {};
			pq.push(status{nodes[0], 0, false});
			while(!pq.empty()) {
				auto current = pq.top();
				pq.pop();
				if(vis.contains(current.nd->id)) {
					continue;
				} else {
					vis.insert(current.nd->id);
				}
				if(current.nd->id == n - 1) {
					return current.weight;
				}
				for(const auto &[k, v]: current.nd->to) {
					if(!vis.contains(k->id)) {
						pq.push(status{k, current.weight + v, current.used});
					}
				}
				//if(!current.used) {
				for(const auto &[k, v]: current.nd->from) {
					if(!vis.contains(k->id)) {
						pq.push(status{k, current.weight + 2 * v, true});
					}
				}
				//}
			}
			return -1;
		}
	}// namespace minimum_cost_path_with_edge_reversals

	namespace reverse_bits {
		int Solution::reverseBits(int n) {
			int res = 0;
			for(int i = 0; i < 32; i++) {
				int target = 31 - i;
				int diff   = target - i;
				int mask   = (n & (1u << target));
				if(diff > 0) {
					mask >>= diff;
				} else {
					mask <<= -diff;
				}
				res |= mask;
			}
			return res;
		}
	}// namespace reverse_bits

	namespace check_if_a_string_contains_all_binary_codes_of_size_k {
		bool Solution::hasAllCodes(string s, int k) {
			if(k > s.length()) {
				return false;
			}
			bitset<2 << 20> exist = {};
			unsigned int v        = 0;
			unsigned int mask     = 0;
			for(int i = 0; i < k; i++) {
				v <<= 1;
				v |= s[i] == '1' ? 1u : 0u;
				mask |= 1 << i;
			}
			exist.set(v);
			for(int i = k; i < s.length(); i++) {
				v <<= 1;
				v |= s[i] == '1' ? 1u : 0u;
				v &= mask;
				exist.set(v);
			}
			for(unsigned int i = 0; i < 1 << k; i++) {
				if(!exist.test(i)) {
					return false;
				}
			}
			return true;
		}
	}// namespace check_if_a_string_contains_all_binary_codes_of_size_k
}// namespace leetcode