├── .gitignore
├── README.md
└── src
    ├── 1068.cpp
    ├── 1069.cpp
    ├── 1070.cpp
    ├── 1071.cpp
    ├── 1072.cpp
    ├── 1073.cpp
    ├── 1074.cpp
    ├── 1076.cpp
    ├── 1077.cpp
    ├── 1079.cpp
    ├── 1081.cpp
    ├── 1082.cpp
    ├── 1083.cpp
    ├── 1084.cpp
    ├── 1085.cpp
    ├── 1090.cpp
    ├── 1091.cpp
    ├── 1092.cpp
    ├── 1093.cpp
    ├── 1094.cpp
    ├── 1095.cpp
    ├── 1096.cpp
    ├── 1097.cpp
    ├── 1098.cpp
    ├── 1099.cpp
    ├── 1110.cpp
    ├── 1111.cpp
    ├── 1112.cpp
    ├── 1130.cpp
    ├── 1131.cpp
    ├── 1132.cpp
    ├── 1133.cpp
    ├── 1135.cpp
    ├── 1136.cpp
    ├── 1137.cpp
    ├── 1138.cpp
    ├── 1139.cpp
    ├── 1140.cpp
    ├── 1141.cpp
    ├── 1143.cpp
    ├── 1144.cpp
    ├── 1145.cpp
    ├── 1158.cpp
    ├── 1160.cpp
    ├── 1163.cpp
    ├── 1164.cpp
    ├── 1190.cpp
    ├── 1192.cpp
    ├── 1193.cpp
    ├── 1194.cpp
    ├── 1195.cpp
    ├── 1196.cpp
    ├── 1197.cpp
    ├── 1202.cpp
    ├── 1617.cpp
    ├── 1618.cpp
    ├── 1619.cpp
    ├── 1620.cpp
    ├── 1621.cpp
    ├── 1622.cpp
    ├── 1623.cpp
    ├── 1624.cpp
    ├── 1625.cpp
    ├── 1628.cpp
    ├── 1629.cpp
    ├── 1630.cpp
    ├── 1631.cpp
    ├── 1632.cpp
    ├── 1633.cpp
    ├── 1634.cpp
    ├── 1635.cpp
    ├── 1636.cpp
    ├── 1637.cpp
    ├── 1638.cpp
    ├── 1639.cpp
    ├── 1640.cpp
    ├── 1641.cpp
    ├── 1642.cpp
    ├── 1643.cpp
    ├── 1644.cpp
    ├── 1645.cpp
    ├── 1646.cpp
    ├── 1647.cpp
    ├── 1648.cpp
    ├── 1649.cpp
    ├── 1650.cpp
    ├── 1651.cpp
    ├── 1652.cpp
    ├── 1653.cpp
    ├── 1660.cpp
    ├── 1661.cpp
    ├── 1662.cpp
    ├── 1666.cpp
    ├── 1667.cpp
    ├── 1668.cpp
    ├── 1669.cpp
    ├── 1671.cpp
    ├── 1672.cpp
    ├── 1673.cpp
    ├── 1674.cpp
    ├── 1675.cpp
    ├── 1676.cpp
    ├── 1678.cpp
    ├── 1679.cpp
    ├── 1680.cpp
    ├── 1681.cpp
    ├── 1682.cpp
    ├── 1683.cpp
    ├── 1684.cpp
    ├── 1686.cpp
    ├── 1687.cpp
    ├── 1688.cpp
    ├── 1689.cpp
    ├── 1690.cpp
    ├── 1691.cpp
    ├── 1692.cpp
    ├── 1693.cpp
    ├── 1694.cpp
    ├── 1695.cpp
    ├── 1696.cpp
    ├── 1711.cpp
    ├── 1712.cpp
    ├── 1713.cpp
    ├── 1715.cpp
    ├── 1716.cpp
    ├── 1717.cpp
    ├── 1722.cpp
    ├── 1723.cpp
    ├── 1724.cpp
    ├── 1725.cpp
    ├── 1726.cpp
    ├── 1727.cpp
    ├── 1728.cpp
    ├── 1729.cpp
    ├── 1730.cpp
    ├── 1731.cpp
    ├── 1732.cpp
    ├── 1733.cpp
    ├── 1734.cpp
    ├── 1735.cpp
    ├── 1736.cpp
    ├── 1737.cpp
    ├── 1739.cpp
    ├── 1744.cpp
    ├── 1745.cpp
    ├── 1746.cpp
    ├── 1749.cpp
    ├── 1750.cpp
    ├── 1751.cpp
    ├── 1753.cpp
    ├── 1754.cpp
    ├── 1755.cpp
    ├── 2064.cpp
    ├── 2072.cpp
    ├── 2073.cpp
    ├── 2074.cpp
    ├── 2076.cpp
    ├── 2077.cpp
    ├── 2078.cpp
    ├── 2079.cpp
    ├── 2080.cpp
    ├── 2081.cpp
    ├── 2084.cpp
    ├── 2085.cpp
    ├── 2086.cpp
    ├── 2087.cpp
    ├── 2088.cpp
    ├── 2101.cpp
    ├── 2102.cpp
    ├── 2103.cpp
    ├── 2104.cpp
    ├── 2105.cpp
    ├── 2106.cpp
    ├── 2107.cpp
    ├── 2108.cpp
    ├── 2109.cpp
    ├── 2110.cpp
    ├── 2111.cpp
    ├── 2112.cpp
    ├── 2113.cpp
    ├── 2121.cpp
    ├── 2129.cpp
    ├── 2130.cpp
    ├── 2133.cpp
    ├── 2134.cpp
    ├── 2136.cpp
    ├── 2137.cpp
    ├── 2138.cpp
    ├── 2143.cpp
    ├── 2162.cpp
    ├── 2163.cpp
    ├── 2164.cpp
    ├── 2165.cpp
    ├── 2166.cpp
    ├── 2168.cpp
    ├── 2169.cpp
    ├── 2181.cpp
    ├── 2182.cpp
    ├── 2183.cpp
    ├── 2185.cpp
    ├── 2187.cpp
    ├── 2189.cpp
    ├── 2190.cpp
    ├── 2191.cpp
    ├── 2192.cpp
    ├── 2193.cpp
    ├── 2194.cpp
    ├── 2195.cpp
    ├── 2205.cpp
    ├── 2206.cpp
    ├── 2207.cpp
    ├── 2208.cpp
    ├── 2209.cpp
    ├── 2210.cpp
    ├── 2216.cpp
    ├── 2217.cpp
    ├── 2220.cpp
    ├── 2413.cpp
    ├── 2416.cpp
    ├── 2417.cpp
    ├── 2420.cpp
    ├── 2428.cpp
    └── 2431.cpp


/.gitignore:
--------------------------------------------------------------------------------
1 | .vscode
2 | .gitignore
3 | util.py


--------------------------------------------------------------------------------
/src/1068.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // just simulate
32 | 
33 | void solve(int tc = 0) {
34 |     ll n; cin >> n;
35 |     while (n != 1) {
36 |         cout << n << " ";
37 |         n = (n % 2) ? 3 * n + 1 : n / 2;
38 |     }
39 |     cout << 1 << "\n";
40 | }
41 | 
42 | signed main() {
43 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
44 |     int tc = 1;
45 |     // cin >> tc;
46 |     for (int t = 1; t <= tc; t++) {
47 |         // cout << "Case #" << t << ": ";
48 |         solve(t);
49 |     }
50 | }


--------------------------------------------------------------------------------
/src/1069.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // two pointers
32 | 
33 | void solve(int tc = 0) {
34 |     string s; cin >> s;
35 |     int n = sz(s);
36 |     int ans = 0;
37 |     for (int i = 0; i < n;) {
38 |         int j = i;
39 |         while (j < n && s[j] == s[i]) j++;
40 |         ans = max(ans, j - i);
41 |         i = j;
42 |     }
43 |     cout << ans << "\n";
44 | }
45 | 
46 | signed main() {
47 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
48 |     int tc = 1;
49 |     // cin >> tc;
50 |     for (int t = 1; t <= tc; t++) {
51 |         // cout << "Case #" << t << ": ";
52 |         solve(t);
53 |     }
54 | }


--------------------------------------------------------------------------------
/src/1070.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // 2 4 6 8 10 ... 1 3 5 7 9 ...
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     if (n == 2 || n == 3) {
36 |         cout << "NO SOLUTION\n";
37 |         return;
38 |     }
39 |     for (int i = 2; i <= n; i += 2) cout << i << " ";
40 |     for (int i = 1; i <= n; i += 2) cout << i << " ";
41 |     cout << "\n";
42 | }
43 | 
44 | signed main() {
45 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
46 |     int tc = 1;
47 |     // cin >> tc;
48 |     for (int t = 1; t <= tc; t++) {
49 |         // cout << "Case #" << t << ": ";
50 |         solve(t);
51 |     }
52 | }


--------------------------------------------------------------------------------
/src/1071.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // observe patterns
32 | 
33 | void solve(int tc = 0) {
34 |     ll r, c; cin >> r >> c;
35 |     if (r > c) {
36 |         if (r % 2) {
37 |             cout << (r - 1) * (r - 1) + c << "\n";
38 |         } else {
39 |             cout << r * r - c + 1 << "\n";
40 |         }
41 |     } else {
42 |         if (c % 2) {
43 |             cout << c * c - r + 1 << "\n";
44 |         } else {
45 |             cout << (c - 1) * (c - 1) + r << "\n";
46 |         }
47 |     }
48 | }
49 | 
50 | signed main() {
51 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
52 |     int tc = 1;
53 |     cin >> tc;
54 |     for (int t = 1; t <= tc; t++) {
55 |         // cout << "Case #" << t << ": ";
56 |         solve(t);
57 |     }
58 | }


--------------------------------------------------------------------------------
/src/1072.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // take complement: no.of ways to place 2 knights - no.of ways so that they attack each other
32 | 
33 | void solve(int tc = 0) {
34 |     cout << (ll) (tc * tc) * (tc * tc - 1) / 2 - (ll) (tc - 1) * (tc - 2) * 4 << "\n";
35 | }
36 | 
37 | signed main() {
38 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
39 |     int tc = 1;
40 |     cin >> tc;
41 |     for (int t = 1; t <= tc; t++) {
42 |         // cout << "Case #" << t << ": ";
43 |         solve(t);
44 |     }
45 | }


--------------------------------------------------------------------------------
/src/1073.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // greedy
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     multiset<int> st;
36 |     while (n--) {
37 |         int x; cin >> x;
38 |         auto it = st.upper_bound(x);
39 |         if (it != st.end()) st.erase(it);
40 |         st.insert(x);
41 |     }
42 |     cout << sz(st) << "\n";
43 | }
44 | 
45 | signed main() {
46 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
47 |     int tc = 1;
48 |     // cin >> tc;
49 |     for (int t = 1; t <= tc; t++) {
50 |         // cout << "Case #" << t << ": ";
51 |         solve(t);
52 |     }
53 | }


--------------------------------------------------------------------------------
/src/1074.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // median
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     sort(all(a));
38 |     int med = a[n / 2];
39 |     ll ans = 0;
40 |     for (int x : a) ans += abs(x - med);
41 |     cout << ans << "\n";
42 | }
43 | 
44 | signed main() {
45 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
46 |     int tc = 1;
47 |     // cin >> tc;
48 |     for (int t = 1; t <= tc; t++) {
49 |         // cout << "Case #" << t << ": ";
50 |         solve(t);
51 |     }
52 | }


--------------------------------------------------------------------------------
/src/1076.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // sliding window
32 | 
33 | #include <ext/pb_ds/assoc_container.hpp>
34 | #include <ext/pb_ds/tree_policy.hpp>
35 | using namespace __gnu_pbds;
36 | template <class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
37 |  
38 | void solve(int tc = 0) {
39 |     int n, m; cin >> n >> m;
40 |     vector<int> a(n);
41 |     for (int &x : a) cin >> x;
42 |     ordered_set<ar<int,2>> os;
43 |     for (int i = 0; i < m; i++) os.insert({a[i], i});
44 |     int med = (*os.find_by_order((m - 1) / 2))[0];    
45 |     cout << med << " ";
46 |     for (int l = 0, r = m; r < n; l++, r++) {
47 |         os.insert({a[r], r});
48 |         os.erase({a[l], l});
49 |         med = (*os.find_by_order((m - 1) / 2))[0];
50 |         cout << med << " ";
51 |     }
52 |     cout << "\n";
53 | }
54 | 
55 | signed main() {
56 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
57 |     int tc = 1;
58 |     // cin >> tc;
59 |     for (int t = 1; t <= tc; t++) {
60 |         // cout << "Case #" << t << ": ";
61 |         solve(t);
62 |     }
63 | }


--------------------------------------------------------------------------------
/src/1081.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e6 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> cnt(MAX_N);
36 |     while (n--) {
37 |         int x; cin >> x;
38 |         cnt[x]++;
39 |     }
40 |     for (int i = MAX_N - 1; i > 0; i--) {
41 |         int cur = 0;
42 |         for (int j = i; j < MAX_N; j += i) {
43 |             cur += cnt[j];
44 |         }
45 |         if (cur >= 2) {
46 |             cout << i << "\n";
47 |             return;
48 |         }
49 |     }
50 | }
51 | 
52 | signed main() {
53 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
54 |     int tc = 1;
55 |     // cin >> tc;
56 |     for (int t = 1; t <= tc; t++) {
57 |         // cout << "Case #" << t << ": ";
58 |         solve(t);
59 |     }
60 | }


--------------------------------------------------------------------------------
/src/1082.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | ll qexp(ll a, ll b, ll m) {
32 |     ll res = 1;
33 |     while (b > 0) {
34 |         if (b & 1) res = res * a % m;
35 |         a = a * a % m;
36 |         b >>= 1;
37 |     }
38 |     return res;
39 | }
40 | 
41 | int ap(ll l, ll r) {
42 |     l %= MOD; 
43 |     r %= MOD;
44 |     ll res = (l + r) * (r - l + 1) % MOD * qexp(2, MOD - 2, MOD) % MOD;
45 |     if (res < 0) res += MOD;
46 |     return res; 
47 | }
48 |  
49 | void solve(int tc = 0) {
50 |     ll n; cin >> n;
51 |     ll ans = 0;
52 |     for (ll l = 1; l <= n;) {
53 |         ll r = n / (n / l);
54 |         dbg(l, r, ap(l, r), n / l);
55 |         ans = (ans + ap(l, r) * (n / l) % MOD) % MOD;
56 |         l = r + 1;
57 |     }
58 |     cout << ans << "\n";
59 | }
60 | 
61 | signed main() {
62 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
63 |     int tc = 1;
64 |     // cin >> tc;
65 |     for (int t = 1; t <= tc; t++) {
66 |         // cout << "Case #" << t << ": ";
67 |         solve(t);
68 |     }
69 | }


--------------------------------------------------------------------------------
/src/1083.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // missing number = (1 + 2 + ... + n) - total sum
32 | 
33 | void solve(int tc = 0) {
34 |     ll n; cin >> n;
35 |     ll sum = n * (n + 1) / 2;
36 |     ll tot = 0;
37 |     for (int i = 0; i < n - 1; i++) {
38 |         int x; cin >> x;
39 |         tot += x;
40 |     }
41 |     cout << sum - tot << "\n";
42 | }
43 | 
44 | signed main() {
45 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
46 |     int tc = 1;
47 |     // cin >> tc;
48 |     for (int t = 1; t <= tc; t++) {
49 |         // cout << "Case #" << t << ": ";
50 |         solve(t);
51 |     }
52 | }


--------------------------------------------------------------------------------
/src/1084.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // two pointers
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m, k; cin >> n >> m >> k;
35 |     vector<int> a(n), b(m);
36 |     for (int &x : a) cin >> x;
37 |     for (int &x : b) cin >> x;
38 |     sort(all(a));
39 |     sort(all(b));
40 |     int ans = 0;
41 |     for (int i = 0, j = 0; i < n && j < m;) {
42 |         if (b[j] < a[i] - k) {
43 |             j++;
44 |         } else if (b[j] > a[i] + k) {
45 |             i++;
46 |         } else {
47 |             ans++;
48 |             i++;
49 |             j++;
50 |         }
51 |     }
52 |     cout << ans << "\n";
53 | }
54 | 
55 | signed main() {
56 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
57 |     int tc = 1;
58 |     // cin >> tc;
59 |     for (int t = 1; t <= tc; t++) {
60 |         // cout << "Case #" << t << ": ";
61 |         solve(t);
62 |     }
63 | }


--------------------------------------------------------------------------------
/src/1085.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // binary search the answer
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 | 
38 |     auto ok = [&](ll mid) -> bool {
39 |         int cnt = 0; ll cur = 0;
40 |         for (int x : a) {
41 |             if (x > mid) {
42 |                 return false;
43 |             } else if (cur + x > mid) {
44 |                 cur = x;
45 |                 cnt++;
46 |             } else {
47 |                 cur += x;
48 |             }
49 |         }
50 |         if (cur > 0) cnt++;
51 |         return cnt <= m;
52 |     };
53 | 
54 |     ll lo = 0, hi = 1e15;
55 |     while (lo + 1 < hi) {
56 |         ll mid = (lo + hi) / 2;
57 |         if (ok(mid)) hi = mid;
58 |         else lo = mid;
59 |     }
60 |     cout << hi << "\n";
61 | }
62 | 
63 | signed main() {
64 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
65 |     int tc = 1;
66 |     // cin >> tc;
67 |     for (int t = 1; t <= tc; t++) {
68 |         // cout << "Case #" << t << ": ";
69 |         solve(t);
70 |     }
71 | }


--------------------------------------------------------------------------------
/src/1090.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // two pointers
32 | 
33 | void solve(int tc = 0) {
34 |     int n, k; cin >> n >> k;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     int ans = 0;
38 |     sort(all(a));
39 |     for (int i = 0, j = n - 1; i <= j;) {
40 |         dbg(a[i], a[j], i, j, ans);
41 |         if (i == j) {
42 |             ans++;
43 |             break;
44 |         } else if (a[i] + a[j] <= k) {
45 |             i++; j--; ans++;
46 |         } else {
47 |             j--; ans++;
48 |         }
49 |     }
50 |     cout << ans << "\n";
51 | }
52 | 
53 | signed main() {
54 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
55 |     int tc = 1;
56 |     // cin >> tc;
57 |     for (int t = 1; t <= tc; t++) {
58 |         // cout << "Case #" << t << ": ";
59 |         solve(t);
60 |     }
61 | }


--------------------------------------------------------------------------------
/src/1091.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // simulate using a multiset
32 | 
33 | void solve(int tc = 0) {
34 |     int n, q; cin >> n >> q;
35 |     multiset<int> ms;
36 |     while (n--) {
37 |         int x; cin >> x;
38 |         ms.insert(x);
39 |     }
40 |     while (q--) {
41 |         int x; cin >> x;
42 |         auto it = ms.upper_bound(x);
43 |         if (it == ms.begin()) {
44 |             cout << -1 << "\n";
45 |         } else {
46 |             it = prev(it);
47 |             cout << (*it) << "\n";
48 |             ms.erase(it);
49 |         }
50 |     }
51 | }
52 | 
53 | signed main() {
54 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
55 |     int tc = 1;
56 |     // cin >> tc;
57 |     for (int t = 1; t <= tc; t++) {
58 |         // cout << "Case #" << t << ": ";
59 |         solve(t);
60 |     }
61 | }


--------------------------------------------------------------------------------
/src/1092.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // greedy
32 | 
33 | void solve(int tc = 0) {
34 |     ll n; cin >> n;
35 |     ll sum = n * (n + 1) / 2;
36 |     if (sum % 2) {
37 |         cout << "NO\n";
38 |         return;
39 |     }
40 |     cout << "YES\n";
41 |     sum /= 2;
42 |     vector<int> s1, s2;
43 |     for (int i = n; i > 0; i--) {
44 |         if (sum >= i) {
45 |             sum -= i;
46 |             s1.push_back(i);
47 |         } else {
48 |             s2.push_back(i);
49 |         }
50 |     }
51 |     cout << sz(s1) << "\n";
52 |     for (int x : s1) cout << x << " ";
53 |     cout << "\n";
54 |     cout << sz(s2) << "\n";
55 |     for (int x : s2) cout << x << " ";
56 |     cout << "\n";
57 | }
58 | 
59 | signed main() {
60 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
61 |     int tc = 1;
62 |     // cin >> tc;
63 |     for (int t = 1; t <= tc; t++) {
64 |         // cout << "Case #" << t << ": ";
65 |         solve(t);
66 |     }
67 | }


--------------------------------------------------------------------------------
/src/1093.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // similar to the minimise coin problem, the target sum is half of the total sum
32 | // to avoid overcounting, either divide the final answer by 2 or just exclude the max element from the dp transition
33 | 
34 | void solve(int tc = 0) {
35 |     int n; cin >> n;
36 |     int m = n * (n + 1) / 2;
37 |     if (m % 2) {
38 |         cout << 0 << "\n";
39 |         return;
40 |     }
41 |     m /= 2;
42 |     vector<int> dp(m + 1);
43 |     dp[0] = 1;
44 |     for (int i = 1; i < n; i++) {
45 |         for (int j = m; j >= i; j--) {
46 |             dp[j] += dp[j - i];
47 |             if (dp[j] >= MOD) dp[j] -= MOD;
48 |         }
49 |     }
50 |     cout << dp[m] << "\n";
51 | }
52 | 
53 | signed main() {
54 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
55 |     int tc = 1;
56 |     // cin >> tc;
57 |     for (int t = 1; t <= tc; t++) {
58 |         // cout << "Case #" << t << ": ";
59 |         solve(t);
60 |     }
61 | }


--------------------------------------------------------------------------------
/src/1094.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // greedy
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     ll ans = 0;
38 |     for (int i = 1; i < n; i++) {
39 |         if (a[i] < a[i - 1]) {
40 |             ans += (a[i - 1] - a[i]);
41 |             a[i] = a[i - 1];
42 |         }
43 |     }
44 |     cout << ans << "\n";
45 | }
46 | 
47 | signed main() {
48 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
49 |     int tc = 1;
50 |     // cin >> tc;
51 |     for (int t = 1; t <= tc; t++) {
52 |         // cout << "Case #" << t << ": ";
53 |         solve(t);
54 |     }
55 | }


--------------------------------------------------------------------------------
/src/1095.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | ll qexp(ll a, ll b, ll m) {
32 |     ll res = 1;
33 |     while (b > 0) {
34 |         if (b & 1) res = res * a % m;
35 |         a = a * a % m;
36 |         b >>= 1;
37 |     }
38 |     return res;
39 | }
40 | 
41 | void solve(int tc = 0) {
42 |     int a, b; cin >> a >> b;
43 |     cout << qexp(a, b, MOD) << "\n";
44 | }
45 | 
46 | signed main() {
47 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
48 |     int tc = 1;
49 |     cin >> tc;
50 |     for (int t = 1; t <= tc; t++) {
51 |         // cout << "Case #" << t << ": ";
52 |         solve(t);
53 |     }
54 | }


--------------------------------------------------------------------------------
/src/1097.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp[i][j] = max difference between the scores of the players if playing with only a[i]...a[j]
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     vector<vector<ll>> dp(n, vector<ll>(n));
38 |     for (int i = n - 1; i >= 0; i--) {
39 |         for (int j = i; j < n; j++) {
40 |             if (i == j) {
41 |                 dp[i][j] = a[i];
42 |             } else {
43 |                 dp[i][j] = max(a[i] - dp[i + 1][j], a[j] - dp[i][j - 1]);
44 |             }
45 |         }
46 |     }
47 |     ll sum = accumulate(all(a), 0ll);
48 |     cout << (sum + dp[0][n - 1]) / 2 << "\n";
49 | }
50 | 
51 | signed main() {
52 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
53 |     int tc = 1;
54 |     // cin >> tc;
55 |     for (int t = 1; t <= tc; t++) {
56 |         // cout << "Case #" << t << ": ";
57 |         solve(t);
58 |     }
59 | }


--------------------------------------------------------------------------------
/src/1098.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // Nim Game
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     int sum = 0;
36 |     while (n--) {
37 |         int x; cin >> x; x %= 4;
38 |         sum ^= x;
39 |     }
40 |     cout << (sum ? "first" : "second") << "\n";
41 | }
42 | 
43 | signed main() {
44 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
45 |     int tc = 1;
46 |     cin >> tc;
47 |     for (int t = 1; t <= tc; t++) {
48 |         // cout << "Case #" << t << ": ";
49 |         solve(t);
50 |     }
51 | }


--------------------------------------------------------------------------------
/src/1099.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     int sum = 0;
36 |     for (int i = 0; i < n; i++) {
37 |         int x; cin >> x;
38 |         if (i % 2) sum ^= x;
39 |     }
40 |     cout << (sum ? "first" : "second") << "\n";
41 | }
42 | 
43 | signed main() {
44 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
45 |     int tc = 1;
46 |     cin >> tc;
47 |     for (int t = 1; t <= tc; t++) {
48 |         // cout << "Case #" << t << ": ";
49 |         solve(t);
50 |     }
51 | }


--------------------------------------------------------------------------------
/src/1130.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<vector<int>> adj(n);
36 |     for (int i = 0; i < n - 1; i++) {
37 |         int u, v; cin >> u >> v; u--; v--;
38 |         adj[u].push_back(v);
39 |         adj[v].push_back(u);
40 |     }
41 | 
42 |     vector<bool> used(n);
43 |     int ans = 0;
44 |     function<void(int, int)> dfs = [&](int u, int p) {
45 |         for (int v : adj[u]) {
46 |             if (v == p) continue;
47 |             dfs(v, u);
48 |         }
49 |         if (p != -1 && !used[p] && !used[u]) {
50 |             used[u] = used[p] = true;
51 |             ans++;
52 |         }
53 |     };
54 |     dfs(0, -1);
55 |     
56 |     cout << ans << "\n";
57 | }
58 | 
59 | signed main() {
60 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
61 |     int tc = 1;
62 |     // cin >> tc;
63 |     for (int t = 1; t <= tc; t++) {
64 |         // cout << "Case #" << t << ": ";
65 |         solve(t);
66 |     }
67 | }


--------------------------------------------------------------------------------
/src/1131.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<vector<int>> adj(n);
36 |     for (int i = 0; i < n - 1; i++) {
37 |         int u, v; cin >> u >> v; u--; v--;
38 |         adj[u].push_back(v);
39 |         adj[v].push_back(u);
40 |     }
41 | 
42 |     vector<int> dep(n);
43 |     int mx = 0;
44 |     function<void(int, int)> dfs = [&](int u, int p) {
45 |         for (int v : adj[u]) {
46 |             if (v == p) continue;
47 |             dep[v] = dep[u] + 1;
48 |             if (dep[v] > dep[mx]) mx = v;
49 |             dfs(v, u);
50 |         }
51 |     };
52 |     
53 |     dfs(0, -1);
54 |     fill(all(dep), 0);
55 |     dfs(mx, -1);
56 |     cout << dep[mx] << "\n";
57 | }
58 | 
59 | signed main() {
60 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
61 |     int tc = 1;
62 |     // cin >> tc;
63 |     for (int t = 1; t <= tc; t++) {
64 |         // cout << "Case #" << t << ": ";
65 |         solve(t);
66 |     }
67 | }


--------------------------------------------------------------------------------
/src/1139.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 2e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | int n, ans[MAX_N], col[MAX_N];
32 | vector<int> adj[MAX_N];
33 | set<int> st[MAX_N];
34 |  
35 | void dfs(int u, int p = 0) {
36 |     st[u].insert(col[u]);
37 |     for (int v : adj[u]) {
38 |         if (v == p) continue;
39 |         dfs(v, u);
40 |         if (sz(st[u]) < sz(st[v])) swap(st[u], st[v]);
41 |         for (int x : st[v]) st[u].insert(x);
42 |     }
43 |     ans[u] = sz(st[u]);
44 | }
45 |  
46 | void solve(int tc = 0) {
47 |     cin >> n;
48 |     for (int i = 1; i <= n; i++) cin >> col[i];
49 |     for (int i = 0; i < n - 1; i++) {
50 |         int u, v; cin >> u >> v;
51 |         adj[u].push_back(v);
52 |         adj[v].push_back(u);
53 |     }
54 |     dfs(1);
55 |     for (int i = 1; i <= n; i++) cout << ans[i] << " ";
56 | }
57 | 
58 | signed main() {
59 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
60 |     int tc = 1;
61 |     // cin >> tc;
62 |     for (int t = 1; t <= tc; t++) {
63 |         // cout << "Case #" << t << ": ";
64 |         solve(t);
65 |     }
66 | }


--------------------------------------------------------------------------------
/src/1140.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // similar to the LIS problem
32 | // dp[i] = {the minimum ending time, max momeny earned from the first i projects}
33 | 
34 | void solve(int tc = 0) {
35 |     int n; cin >> n;
36 |     vector<ar<int,3>> a(n);
37 |     for (auto &[r, l, v] : a) cin >> l >> r >> v;
38 |     sort(all(a));
39 |     vector<ar<ll,2>> dp;
40 |     for (int i = 0; i < n; i++) {
41 |         ar<ll,2> res = {a[i][0], a[i][2]}; 
42 |         auto it = upper_bound(all(dp), ar<ll,2>{a[i][1], 0});
43 |         if (it != dp.begin()) {
44 |             it = prev(it);
45 |             res[1] += (*it)[1];
46 |         }
47 |         if (i > 0 && dp.back()[1] > res[1]) res = dp.back();
48 |         dp.push_back(res);
49 |     }
50 |     cout << dp[n - 1][1] << "\n";
51 | }
52 | 
53 | signed main() {
54 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
55 |     int tc = 1;
56 |     // cin >> tc;
57 |     for (int t = 1; t <= tc; t++) {
58 |         // cout << "Case #" << t << ": ";
59 |         solve(t);
60 |     }
61 | }


--------------------------------------------------------------------------------
/src/1141.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // two pointers
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     int ans = 0;
38 |     multiset<int> ms;
39 |     for (int l = 0, r = 0; r < n; r++) {
40 |         while (ms.count(a[r])) {
41 |             ms.erase(ms.find(a[l++]));
42 |         }
43 |         ans = max(ans, r - l + 1);
44 |         ms.insert(a[r]);
45 |     }
46 |     cout << ans << "\n";
47 | }
48 | 
49 | signed main() {
50 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
51 |     int tc = 1;
52 |     // cin >> tc;
53 |     for (int t = 1; t <= tc; t++) {
54 |         // cout << "Case #" << t << ": ";
55 |         solve(t);
56 |     }
57 | }


--------------------------------------------------------------------------------
/src/1145.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // classic LIS problem
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     vector<int> dp;
38 |     for (int x : a) {
39 |         auto it = lower_bound(all(dp), x);
40 |         if (it == dp.end()) {
41 |             dp.push_back(x);
42 |         } else {
43 |             *it = x;
44 |         }
45 |     }
46 |     cout << sz(dp) << "\n";
47 | }
48 | 
49 | signed main() {
50 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
51 |     int tc = 1;
52 |     // cin >> tc;
53 |     for (int t = 1; t <= tc; t++) {
54 |         // cout << "Case #" << t << ": ";
55 |         solve(t);
56 |     }
57 | }


--------------------------------------------------------------------------------
/src/1158.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // classic knapsack dp
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     vector<int> v(n), w(n);
36 |     for (int &x : w) cin >> x;
37 |     for (int &x : v) cin >> x;
38 |     vector<int> dp(m + 1);
39 |     for (int i = 0; i < n; i++) {
40 |         for (int j = m; j >= w[i]; j--) {
41 |             dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
42 |         }
43 |     }
44 |     cout << dp[m] << "\n";
45 | }
46 | 
47 | signed main() {
48 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
49 |     int tc = 1;
50 |     // cin >> tc;
51 |     for (int t = 1; t <= tc; t++) {
52 |         // cout << "Case #" << t << ": ";
53 |         solve(t);
54 |     }
55 | }


--------------------------------------------------------------------------------
/src/1163.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // simulate and maitain the answer using a set and a multiset
32 | 
33 | void solve(int tc = 0) {
34 |     int n, q; cin >> n >> q;
35 |     set<int> st{0, n};
36 |     multiset<int> ms{n};
37 |     while (q--) {
38 |         int x; cin >> x;
39 |         auto r = st.upper_bound(x);
40 |         auto l = prev(r);
41 |         ms.erase(ms.find((*r) - (*l)));
42 |         ms.insert((*r) - x);
43 |         ms.insert(x - (*l));
44 |         st.insert(x);
45 |         cout << *ms.rbegin() << " ";
46 |     }
47 |     cout << "\n";
48 | }
49 | 
50 | signed main() {
51 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
52 |     int tc = 1;
53 |     // cin >> tc;
54 |     for (int t = 1; t <= tc; t++) {
55 |         // cout << "Case #" << t << ": ";
56 |         solve(t);
57 |     }
58 | }


--------------------------------------------------------------------------------
/src/1164.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // simulate using a priority_queue
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<ar<int,3>> a(n);
36 |     for (int i = 0; i < n; i++) {
37 |         int l, r; cin >> l >> r;
38 |         a[i] = {l, r, i};
39 |     }
40 |     sort(all(a));
41 |     priority_queue<ar<int,2>,vector<ar<int,2>>,greater<ar<int,2>>> pq;
42 |     vector<int> ans(n);
43 |     for (auto [l, r, i] : a) {
44 |         if (pq.empty() || pq.top()[0] >= l) {
45 |             ans[i] = sz(pq) + 1;
46 |         } else {
47 |             ans[i] = pq.top()[1];
48 |             pq.pop();
49 |         }
50 |         pq.push({r, ans[i]});
51 |     }
52 |     cout << sz(pq) << "\n";
53 |     for (int x : ans) cout << x << " ";
54 |     cout << "\n";
55 | }
56 | 
57 | signed main() {
58 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
59 |     int tc = 1;
60 |     // cin >> tc;
61 |     for (int t = 1; t <= tc; t++) {
62 |         // cout << "Case #" << t << ": ";
63 |         solve(t);
64 |     }
65 | }


--------------------------------------------------------------------------------
/src/1617.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // each bit has 2 options, so answer = 2^n
32 | 
33 | int power(long long a, int b) {
34 |     int ret = 1;
35 |     while (b > 0) {
36 |         if (b & 1)
37 |             ret = (ret * a) % MOD;
38 |         a = (a * a) % MOD;
39 |         b >>= 1;
40 |     }
41 |     return ret;
42 | }
43 | 
44 | void solve(int tc = 0) {
45 |     int n; cin >> n;
46 |     cout << power(2, n) << "\n";
47 | }
48 | 
49 | signed main() {
50 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
51 |     int tc = 1;
52 |     // cin >> tc;
53 |     for (int t = 1; t <= tc; t++) {
54 |         // cout << "Case #" << t << ": ";
55 |         solve(t);
56 |     }
57 | }


--------------------------------------------------------------------------------
/src/1618.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // number of trailling zero = power of 5 in the prime fractorisation of the number
32 | // no. of multiples of k in range [1...n] = floor(n / k)
33 | 
34 | void solve(int tc = 0) {
35 |     int n; cin >> n;
36 |     ll ans = 0;
37 |     for (ll i = 5; i <= n; i *= 5) {
38 |         ans += n / i;
39 |     }
40 |     cout << ans << "\n";
41 | }
42 | 
43 | signed main() {
44 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
45 |     int tc = 1;
46 |     // cin >> tc;
47 |     for (int t = 1; t <= tc; t++) {
48 |         // cout << "Case #" << t << ": ";
49 |         solve(t);
50 |     }
51 | }


--------------------------------------------------------------------------------
/src/1619.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // sweepline, then prefix sum
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<ar<int,2>> events;
36 |     for (int i = 0; i < n; i++) {
37 |         int l, r; cin >> l >> r;
38 |         events.push_back({l, 1});
39 |         events.push_back({r, -1});
40 |     }
41 |     sort(all(events));
42 |     int ans = 0, cur = 0;
43 |     for (auto [i, x] : events) {
44 |         cur += x;
45 |         ans = max(ans, cur);
46 |     }
47 |     cout << ans << "\n";
48 | }
49 | 
50 | signed main() {
51 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
52 |     int tc = 1;
53 |     // cin >> tc;
54 |     for (int t = 1; t <= tc; t++) {
55 |         // cout << "Case #" << t << ": ";
56 |         solve(t);
57 |     }
58 | }


--------------------------------------------------------------------------------
/src/1620.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // binary search the answer
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 | 
38 |     auto ok = [&](ll mid) -> bool {
39 |         ll sum = 0;
40 |         for (int x : a) {
41 |             sum += mid / x;
42 |             if (sum >= m) return true;
43 |         }
44 |         return false;
45 |     };    
46 | 
47 |     ll lo = 0, hi = 1e18;
48 |     while (lo + 1 < hi) {
49 |         ll mid = (lo + hi) / 2;
50 |         if (ok(mid)) hi = mid;
51 |         else lo = mid;
52 |     }
53 |     cout << hi << "\n";
54 | }
55 | 
56 | signed main() {
57 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
58 |     int tc = 1;
59 |     // cin >> tc;
60 |     for (int t = 1; t <= tc; t++) {
61 |         // cout << "Case #" << t << ": ";
62 |         solve(t);
63 |     }
64 | }


--------------------------------------------------------------------------------
/src/1621.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // use a set
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     set<int> st;
36 |     while (n--) {
37 |         int x; cin >> x;
38 |         st.insert(x);
39 |     }
40 |     cout << sz(st) << "\n";
41 | }
42 | 
43 | signed main() {
44 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
45 |     int tc = 1;
46 |     // cin >> tc;
47 |     for (int t = 1; t <= tc; t++) {
48 |         // cout << "Case #" << t << ": ";
49 |         solve(t);
50 |     }
51 | }


--------------------------------------------------------------------------------
/src/1622.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 |  
 3 | using namespace std;
 4 |  
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 |  
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 |  
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 |  
31 | // generate all permutations using next_permutation function 
32 |  
33 | void solve(int tc = 0) {
34 |     string s; cin >> s;
35 |     sort(all(s));
36 |     vector<string> ans;
37 |     do {
38 |         ans.push_back(s);
39 |     } while (next_permutation(all(s)));
40 |     cout << sz(ans) << "\n";
41 |     for (string x : ans) cout << x << "\n";
42 | }
43 |  
44 | signed main() {
45 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
46 |     int tc = 1;
47 |     // cin >> tc;
48 |     for (int t = 1; t <= tc; t++) {
49 |         // cout << "Case #" << t << ": ";
50 |         solve(t);
51 |     }
52 | }


--------------------------------------------------------------------------------
/src/1623.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 |  
 3 | using namespace std;
 4 |  
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 |  
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 |  
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 |  
31 | // generate all subsets using bitmask
32 |  
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     ll ans = LLONG_MAX;
38 |     for (int mask = 0; mask < (1 << n); mask++) {
39 |         ll s1 = 0, s2 = 0;
40 |         for (int i = 0; i < n; i++) {
41 |             if (mask & (1 << i)) {
42 |                 s1 += a[i];
43 |             } else {
44 |                 s2 += a[i];
45 |             }
46 |         }
47 |         ans = min(ans, abs(s1 - s2));
48 |     }
49 |     cout << ans << "\n";
50 | }
51 |  
52 | signed main() {
53 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
54 |     int tc = 1;
55 |     // cin >> tc;
56 |     for (int t = 1; t <= tc; t++) {
57 |         // cout << "Case #" << t << ": ";
58 |         solve(t);
59 |     }
60 | }


--------------------------------------------------------------------------------
/src/1629.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // sort by ending time, then greedy
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<ar<int,2>> a(n);
36 |     for (auto &[r, l] : a) cin >> l >> r;
37 |     sort(all(a));
38 |     int ans = 0, pre = -1;
39 |     for (auto [r, l] : a) {
40 |         if (l >= pre) {
41 |             pre = r;
42 |             ans++;
43 |         }
44 |     }
45 |     cout << ans << "\n";
46 | }
47 | 
48 | signed main() {
49 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
50 |     int tc = 1;
51 |     // cin >> tc;
52 |     for (int t = 1; t <= tc; t++) {
53 |         // cout << "Case #" << t << ": ";
54 |         solve(t);
55 |     }
56 | }


--------------------------------------------------------------------------------
/src/1630.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // greedy, always try to finish the short tasks first
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<ar<int,2>> a(n);
36 |     for (auto &[d, t] : a) cin >> d >> t;
37 |     sort(all(a));
38 |     ll ans = 0, pre = 0;
39 |     for (auto [d, t] : a) {
40 |         pre += d;
41 |         ans += t - pre;
42 |     }
43 |     cout << ans << "\n"; 
44 | }
45 | 
46 | signed main() {
47 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
48 |     int tc = 1;
49 |     // cin >> tc;
50 |     for (int t = 1; t <= tc; t++) {
51 |         // cout << "Case #" << t << ": ";
52 |         solve(t);
53 |     }
54 | }


--------------------------------------------------------------------------------
/src/1631.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // the bottle neck is the longest book
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<ll> a(n);
36 |     ll sum = 0, mx = 0;
37 |     for (ll &x : a) {
38 |         cin >> x;
39 |         sum += x;
40 |         mx = max(mx, x);
41 |     }
42 |     cout << (mx > sum - mx ? 2 * mx : sum) << "\n";
43 | }
44 | 
45 | signed main() {
46 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
47 |     int tc = 1;
48 |     // cin >> tc;
49 |     for (int t = 1; t <= tc; t++) {
50 |         // cout << "Case #" << t << ": ";
51 |         solve(t);
52 |     }
53 | }


--------------------------------------------------------------------------------
/src/1632.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // simulate
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     vector<ar<int,2>> a(n);
36 |     for (auto &[r, l] : a) cin >> l >> r;
37 |     sort(all(a));
38 |     int ans = 0;
39 |     multiset<int> ms;
40 |     for (int i = 0; i < m; i++) ms.insert(0);
41 |     for (auto [r, l] : a) {
42 |         auto it = ms.upper_bound(l);
43 |         if (it != ms.begin()) {
44 |             ans++;
45 |             ms.erase(prev(it));
46 |             ms.insert(r);
47 |         }
48 |     }
49 |     cout << ans << "\n";
50 | }
51 | 
52 | signed main() {
53 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
54 |     int tc = 1;
55 |     // cin >> tc;
56 |     for (int t = 1; t <= tc; t++) {
57 |         // cout << "Case #" << t << ": ";
58 |         solve(t);
59 |     }
60 | }


--------------------------------------------------------------------------------
/src/1633.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp[i] = sum of { dp[j] }, where max(i - 6, 0) <= j <= i - 1
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> dp(n + 1);
36 |     dp[0] = 1;
37 |     for (int i = 1; i <= n; i++) {
38 |         for (int j = max(i - 6, 0); j <= i - 1; j++) {
39 |             dp[i] = (dp[i] + dp[j]) % MOD;
40 |         }
41 |     }
42 |     cout << dp[n] << "\n";
43 | }
44 | 
45 | signed main() {
46 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
47 |     int tc = 1;
48 |     // cin >> tc;
49 |     for (int t = 1; t <= tc; t++) {
50 |         // cout << "Case #" << t << ": ";
51 |         solve(t);
52 |     }
53 | }


--------------------------------------------------------------------------------
/src/1634.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp[i] = min of { dp[i - x] }, where i >= x
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     vector<int> dp(m + 1, INF);
38 |     dp[0] = 0;
39 |     for (int i = 1; i <= m; i++) {
40 |         for (int x : a) {
41 |             if (i >= x) {
42 |                 dp[i] = min(dp[i], dp[i - x] + 1);
43 |             }
44 |         }
45 |     }
46 |     cout << (dp[m] < INF ? dp[m] : -1) << "\n";
47 | }
48 | 
49 | signed main() {
50 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
51 |     int tc = 1;
52 |     // cin >> tc;
53 |     for (int t = 1; t <= tc; t++) {
54 |         // cout << "Case #" << t << ": ";
55 |         solve(t);
56 |     }
57 | }


--------------------------------------------------------------------------------
/src/1635.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp[i] = sum of { dp[i - x] }, where i >= x
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     vector<int> dp(m + 1);
38 |     dp[0] = 1;
39 |     for (int i = 1; i <= m; i++) {
40 |         for (int x : a) {
41 |             if (i >= x) {
42 |                 dp[i] = (dp[i] + dp[i - x]) % MOD;
43 |             }
44 |         }
45 |     }
46 |     cout << dp[m] << "\n";
47 | }
48 | 
49 | signed main() {
50 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
51 |     int tc = 1;
52 |     // cin >> tc;
53 |     for (int t = 1; t <= tc; t++) {
54 |         // cout << "Case #" << t << ": ";
55 |         solve(t);
56 |     }
57 | }


--------------------------------------------------------------------------------
/src/1636.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp[i] = sum of { dp[i - x] }, where i >= x
32 | // however, now each coin can only be used once, so need to change the order of the loop
33 | 
34 | void solve(int tc = 0) {
35 |     int n, m; cin >> n >> m;
36 |     vector<int> a(n);
37 |     for (int &x : a) cin >> x;
38 |     vector<int> dp(m + 1);
39 |     dp[0] = 1;
40 |     for (int x : a) {
41 |         for (int i = x; i <= m; i++) {
42 |             dp[i] = (dp[i] + dp[i - x]) % MOD;
43 |         }
44 |     }
45 |     cout << dp[m] << "\n";
46 | }
47 | 
48 | signed main() {
49 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
50 |     int tc = 1;
51 |     // cin >> tc;
52 |     for (int t = 1; t <= tc; t++) {
53 |         // cout << "Case #" << t << ": ";
54 |         solve(t);
55 |     }
56 | }


--------------------------------------------------------------------------------
/src/1637.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp[i] = min of { dp[i - d] }, where d is a digit of i
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> dp(n + 1, INF);
36 |     dp[n] = 0;
37 |     for (int i = n; i > 0; i--) {
38 |         int x = i;
39 |         while (x > 0) {
40 |             int d = x % 10;
41 |             dp[i - d] = min(dp[i - d], dp[i] + 1);
42 |             x /= 10;
43 |         }
44 |     }
45 |     cout << dp[0] << "\n";
46 | }
47 | 
48 | signed main() {
49 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
50 |     int tc = 1;
51 |     // cin >> tc;
52 |     for (int t = 1; t <= tc; t++) {
53 |         // cout << "Case #" << t << ": ";
54 |         solve(t);
55 |     }
56 | }


--------------------------------------------------------------------------------
/src/1638.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<vector<int>> dp(n + 1, vector<int>(n + 1));
36 |     for (int i = 1; i <= n; i++) {
37 |         for (int j = 1; j <= n; j++) {
38 |             char c; cin >> c;
39 |             if (c == '.') {
40 |                 if (i == 1 && j == 1) {
41 |                     dp[i][j] = 1;
42 |                 } else {
43 |                     dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % MOD;
44 |                 }
45 |             }
46 |         }
47 |     }
48 |     cout << dp[n][n] << "\n";
49 | }
50 | 
51 | signed main() {
52 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
53 |     int tc = 1;
54 |     // cin >> tc;
55 |     for (int t = 1; t <= tc; t++) {
56 |         // cout << "Case #" << t << ": ";
57 |         solve(t);
58 |     }
59 | }


--------------------------------------------------------------------------------
/src/1639.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // classic string edit distance
32 | 
33 | void solve(int tc = 0) {
34 |     string s, t; cin >> s >> t;
35 |     int n = sz(s), m = sz(t);
36 |     vector<vector<int>> dp(n + 1, vector<int>(m + 1, INF));
37 |     for (int i = 0; i <= n; i++) dp[i][0] = i;
38 |     for (int i = 0; i <= m; i++) dp[0][i] = i;
39 |     for (int i = 1; i <= n; i++) {
40 |         for (int j = 1; j <= m; j++) {
41 |             if (s[i - 1] == t[j - 1]) {
42 |                 dp[i][j] = dp[i - 1][j - 1];
43 |             } else {
44 |                 dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
45 |             }
46 |         }
47 |     }
48 |     cout << dp[n][m] << "\n";
49 | }
50 | 
51 | signed main() {
52 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
53 |     int tc = 1;
54 |     // cin >> tc;
55 |     for (int t = 1; t <= tc; t++) {
56 |         // cout << "Case #" << t << ": ";
57 |         solve(t);
58 |     }
59 | }


--------------------------------------------------------------------------------
/src/1640.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // two pointers
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     vector<ar<int,2>> a(n);
36 |     for (int i = 0; i < n; i++) {
37 |         int x; cin >> x;
38 |         a[i] = {x, i + 1};
39 |     }
40 |     sort(all(a));
41 |     for (int i = 0, j = n - 1; i < j;) {
42 |         if (a[i][0] + a[j][0] == m) {
43 |             cout << a[i][1] << " " << a[j][1] << "\n";
44 |             return;
45 |         } else if (a[i][0] + a[j][0] > m) {
46 |             j--;
47 |         } else {
48 |             i++;
49 |         }
50 |     }
51 |     cout << "IMPOSSIBLE\n";
52 | }
53 | 
54 | signed main() {
55 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
56 |     int tc = 1;
57 |     // cin >> tc;
58 |     for (int t = 1; t <= tc; t++) {
59 |         // cout << "Case #" << t << ": ";
60 |         solve(t);
61 |     }
62 | }


--------------------------------------------------------------------------------
/src/1641.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // two pointers
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     vector<ar<int,2>> a(n);
36 |     for (int i = 0; i < n; i++) {
37 |         int x; cin >> x;
38 |         a[i] = {x, i + 1};
39 |     }
40 |     sort(all(a));
41 |     for (int i = 0; i < n; i++) {
42 |         int sum = m - a[i][0];
43 |         for (int l = i + 1, r = n - 1; l < r;) {
44 |             if (a[l][0] + a[r][0] == sum) {
45 |                 cout << a[i][1] << " " << a[l][1] << " " << a[r][1] << "\n";
46 |                 return;
47 |             } else if (a[l][0] + a[r][0] < sum) {
48 |                 l++;
49 |             } else {
50 |                 r--;
51 |             }
52 |         }
53 |     }
54 |     cout << "IMPOSSIBLE\n";
55 | }
56 | 
57 | signed main() {
58 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
59 |     int tc = 1;
60 |     // cin >> tc;
61 |     for (int t = 1; t <= tc; t++) {
62 |         // cout << "Case #" << t << ": ";
63 |         solve(t);
64 |     }
65 | }


--------------------------------------------------------------------------------
/src/1643.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // kadane's algorithm
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     ll ans = -INF, cur = -INF;
36 |     while (n--) {
37 |         ll x; cin >> x;
38 |         cur = max(cur + x, x);
39 |         ans = max(ans, cur);
40 |     }
41 |     cout << ans << "\n";
42 | }
43 | 
44 | signed main() {
45 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
46 |     int tc = 1;
47 |     // cin >> tc;
48 |     for (int t = 1; t <= tc; t++) {
49 |         // cout << "Case #" << t << ": ";
50 |         solve(t);
51 |     }
52 | }


--------------------------------------------------------------------------------
/src/1644.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // maintain all the previous sums while moving the indexes
32 | 
33 | void solve(int tc = 0) {
34 |     int n, l, r; cin >> n >> l >> r;
35 |     vector<ll> ps{0};
36 |     for (int i = 0; i < n; i++) {
37 |         int x; cin >> x;
38 |         ps.push_back(ps.back() + x);
39 |     }
40 |     ll ans = LLONG_MIN;
41 |     multiset<ll> ms;
42 |     for (int i = 1; i <= n; i++) {
43 |         if (i >= l) ms.insert(ps[i - l]);
44 |         if (i > r) ms.erase(ms.find(ps[i - r - 1]));
45 |         if (i >= l) ans = max(ans, ps[i] - (*ms.begin()));
46 |     }
47 |     cout << ans << "\n";
48 | }
49 | 
50 | signed main() {
51 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
52 |     int tc = 1;
53 |     // cin >> tc;
54 |     for (int t = 1; t <= tc; t++) {
55 |         // cout << "Case #" << t << ": ";
56 |         solve(t);
57 |     }
58 | }


--------------------------------------------------------------------------------
/src/1645.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // monotonic stack
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     stack<int> stk;
38 |     for (int i = 0; i < n; i++) {
39 |         while (!stk.empty() && a[i] <= a[stk.top()]) stk.pop();
40 |         cout << (stk.empty() ? 0 : stk.top() + 1) << " ";
41 |         stk.push(i);
42 |     }
43 |     cout << "\n";
44 | }
45 | 
46 | signed main() {
47 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
48 |     int tc = 1;
49 |     // cin >> tc;
50 |     for (int t = 1; t <= tc; t++) {
51 |         // cout << "Case #" << t << ": ";
52 |         solve(t);
53 |     }
54 | }


--------------------------------------------------------------------------------
/src/1646.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n, q; cin >> n >> q;
35 |     vector<ll> ps{0};
36 |     for (ll sum = 0, i = 0; i < n; i++) {
37 |         int x; cin >> x;
38 |         sum += x;
39 |         ps.push_back(sum);
40 |     }
41 |     while (q--) {
42 |         int l, r; cin >> l >> r;
43 |         cout << ps[r] - ps[l - 1] << "\n";
44 |     }
45 | }
46 | 
47 | signed main() {
48 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
49 |     int tc = 1;
50 |     // cin >> tc;
51 |     for (int t = 1; t <= tc; t++) {
52 |         // cout << "Case #" << t << ": ";
53 |         solve(t);
54 |     }
55 | }


--------------------------------------------------------------------------------
/src/1649.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n, q; cin >> n >> q;
35 |     vector<int> st(2 * n);
36 |     for (int i = 0; i < n; i++) cin >> st[i + n];
37 |     for (int i = n - 1; i > 0; i--) st[i] = min(st[i << 1], st[i << 1 | 1]);
38 |     while (q--) {
39 |         int t; cin >> t;
40 |         if (t == 1) {
41 |             int i, x; cin >> i >> x; i--;
42 |             for (st[i += n] = x; i > 1; i >>= 1) st[i >> 1] = min(st[i], st[i ^ 1]);
43 |         } else {
44 |             int l, r; cin >> l >> r; l--;
45 |             int res = INT_MAX;
46 |             for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
47 |                 if (l & 1) res = min(res, st[l++]);
48 |                 if (r & 1) res = min(res, st[--r]);
49 |             }
50 |             cout << res << "\n";
51 |         }
52 |     }
53 | }
54 | 
55 | signed main() {
56 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
57 |     int tc = 1;
58 |     // cin >> tc;
59 |     for (int t = 1; t <= tc; t++) {
60 |         // cout << "Case #" << t << ": ";
61 |         solve(t);
62 |     }
63 | }


--------------------------------------------------------------------------------
/src/1650.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n, q; cin >> n >> q;
35 |     vector<int> ps{0};
36 |     for (int sum = 0, i = 0; i < n; i++) {
37 |         int x; cin >> x;
38 |         sum ^= x;
39 |         ps.push_back(sum);
40 |     }
41 |     while (q--) {
42 |         int l, r; cin >> l >> r;
43 |         cout << (ps[r] ^ ps[l - 1]) << "\n";
44 |     }
45 | }
46 | 
47 | signed main() {
48 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
49 |     int tc = 1;
50 |     // cin >> tc;
51 |     for (int t = 1; t <= tc; t++) {
52 |         // cout << "Case #" << t << ": ";
53 |         solve(t);
54 |     }
55 | }


--------------------------------------------------------------------------------
/src/1652.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n, q; cin >> n >> q;
35 |     vector<vector<int>> ps(n + 1, vector<int>(n + 1));
36 |     for (int i = 1; i <= n; i++) {
37 |         for (int j = 1; j <= n; j++) {
38 |             char c; cin >> c;
39 |             ps[i][j] = ps[i - 1][j] + ps[i][j - 1] - ps[i - 1][j - 1] + (c == '*');
40 |         }
41 |     }
42 |     auto query = [&](int r1, int c1, int r2, int c2) -> int {
43 |         return ps[r2][c2] + ps[r1 - 1][c1 - 1] - ps[r1 - 1][c2] - ps[r2][c1 - 1];
44 |     };
45 |     while (q--) {
46 |         int r1, c1, r2, c2; cin >> r1 >> c1 >> r2 >> c2;
47 |         cout << query(r1, c1, r2, c2) << "\n";
48 |     }
49 | }
50 | 
51 | signed main() {
52 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
53 |     int tc = 1;
54 |     // cin >> tc;
55 |     for (int t = 1; t <= tc; t++) {
56 |         // cout << "Case #" << t << ": ";
57 |         solve(t);
58 |     }
59 | }


--------------------------------------------------------------------------------
/src/1660.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     map<ll,int> mp;
36 |     mp[0]++;
37 |     ll ans = 0, cur = 0;
38 |     while (n--) {
39 |         int x; cin >> x;
40 |         cur += x;
41 |         ans += mp[cur - m];
42 |         mp[cur]++;
43 |     }
44 |     cout << ans << "\n";
45 | }
46 | 
47 | signed main() {
48 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
49 |     int tc = 1;
50 |     // cin >> tc;
51 |     for (int t = 1; t <= tc; t++) {
52 |         // cout << "Case #" << t << ": ";
53 |         solve(t);
54 |     }
55 | }


--------------------------------------------------------------------------------
/src/1661.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     map<ll,int> mp;
36 |     mp[0]++;
37 |     ll ans = 0, cur = 0;
38 |     while (n--) {
39 |         int x; cin >> x;
40 |         cur += x;
41 |         ans += mp[cur - m];
42 |         mp[cur]++;
43 |     }
44 |     cout << ans << "\n";
45 | }
46 | 
47 | signed main() {
48 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
49 |     int tc = 1;
50 |     // cin >> tc;
51 |     for (int t = 1; t <= tc; t++) {
52 |         // cout << "Case #" << t << ": ";
53 |         solve(t);
54 |     }
55 | }


--------------------------------------------------------------------------------
/src/1662.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     map<int,int> mp;
36 |     mp[0]++;
37 |     ll ans = 0, cur = 0;
38 |     for (int i = 0; i < n; i++) {
39 |         int x; cin >> x;
40 |         cur = (cur + x) % n;
41 |         if (cur < 0) cur += n;
42 |         ans += mp[cur];
43 |         mp[cur]++;
44 |     }
45 |     cout << ans << "\n";
46 | }
47 | 
48 | signed main() {
49 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
50 |     int tc = 1;
51 |     // cin >> tc;
52 |     for (int t = 1; t <= tc; t++) {
53 |         // cout << "Case #" << t << ": ";
54 |         solve(t);
55 |     }
56 | }


--------------------------------------------------------------------------------
/src/1672.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 5e2 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e12;
29 | const ld EPS = 1e-9;
30 | 
31 | int n, m, q;
32 | ll dist[MAX_N][MAX_N];
33 |  
34 | void floydWarshall() {
35 |     for (int k = 0; k < n; k++)
36 |         for (int i = 0; i < n; i++)
37 |             for (int j = 0; j < n; j++)
38 |                 dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
39 | }
40 |  
41 | void solve(int tc = 0) {
42 |     cin >> n >> m >> q;
43 |     for (int i = 0; i < n; i++) 
44 |         for (int j = 0; j < n; j++)
45 |             dist[i][j] = (i == j ? 0 : INF);
46 |     for (int i = 0; i < m; i++) {
47 |         int u, v, w; cin >> u >> v >> w; u--; v--;
48 |         dist[u][v] = dist[v][u] = min(dist[u][v], (ll) w);
49 |     }
50 |     floydWarshall();
51 |     while (q--) {
52 |         int u, v; cin >> u >> v; u--; v--;
53 |         cout << (dist[u][v] == INF ? -1 : dist[u][v]) << "\n";
54 |     }
55 | }
56 | 
57 | signed main() {
58 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
59 |     int tc = 1;
60 |     // cin >> tc;
61 |     for (int t = 1; t <= tc; t++) {
62 |         // cout << "Case #" << t << ": ";
63 |         solve(t);
64 |     }
65 | }


--------------------------------------------------------------------------------
/src/1674.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<vector<int>> adj(n);
36 |     vector<int> sza(n);
37 |     for (int v = 1; v < n; v++) {
38 |         int u; cin >> u; u--;
39 |         adj[u].push_back(v);
40 |     }
41 | 
42 |     function<void(int)> dfs = [&](int u) {
43 |         for (int v : adj[u]) {
44 |             dfs(v);
45 |             sza[u] += sza[v] + 1;
46 |         }
47 |     };
48 |     dfs(0);
49 |     
50 |     for (int i = 0; i < n; i++) cout << sza[i] << " ";
51 |     cout << "\n";
52 | }
53 | 
54 | signed main() {
55 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
56 |     int tc = 1;
57 |     // cin >> tc;
58 |     for (int t = 1; t <= tc; t++) {
59 |         // cout << "Case #" << t << ": ";
60 |         solve(t);
61 |     }
62 | }


--------------------------------------------------------------------------------
/src/1681.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> n >> m;
35 |     vector<vector<int>> adj(n);
36 |     for (int i = 0; i < m; i++) {
37 |         int u, v; cin >> u >> v; u--; v--;
38 |         adj[u].push_back(v);
39 |     }
40 | 
41 |     vector<int> dp(n);
42 |     vector<bool> vis(n);
43 |     function<void(int)> dfs = [&](int u) {
44 |         dp[u] = (u == n - 1) ? 1 : 0;
45 |         vis[u] = true;
46 |         for (int v : adj[u]) {
47 |             if (!vis[v]) dfs(v);
48 |             dp[u] += dp[v];
49 |             if (dp[u] >= MOD) dp[u] -= MOD;
50 |         }
51 |     };
52 |     dfs(0);
53 |     
54 |     cout << dp[0] << "\n";
55 | }
56 | 
57 | signed main() {
58 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
59 |     int tc = 1;
60 |     // cin >> tc;
61 |     for (int t = 1; t <= tc; t++) {
62 |         // cout << "Case #" << t << ": ";
63 |         solve(t);
64 |     }
65 | }


--------------------------------------------------------------------------------
/src/1692.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1 << 16;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | int n, m, vis[MAX_N];
32 | vector<ar<int,2>> adj[MAX_N];
33 | vector<int> ans;
34 |  
35 | void dfs(int u) {
36 |     while (adj[u].size()) {
37 |         auto [v, i] = adj[u].back(); adj[u].pop_back();
38 |         if (vis[i]) continue;
39 |         vis[i] = 1;
40 |         dfs(v);
41 |         ans.push_back(i);
42 |     }
43 | }
44 |  
45 | void solve(int tc = 0) {
46 |     cin >> n;
47 |     for (int i = 0; i < (1 << n); i++) {
48 |         int u = i >> 1, v = i & ((1 << (n - 1)) - 1);
49 |         adj[u].push_back({v, i});
50 |     }
51 |     dfs(0);
52 |     reverse(all(ans));
53 |     for (int i = 0; i < n - 1; i++) cout << 0;
54 |     for (int x : ans) cout << x % 2;
55 |     cout << "\n";
56 | }
57 | 
58 | signed main() {
59 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
60 |     int tc = 1;
61 |     // cin >> tc;
62 |     for (int t = 1; t <= tc; t++) {
63 |         // cout << "Case #" << t << ": ";
64 |         solve(t);
65 |     }
66 | }


--------------------------------------------------------------------------------
/src/1712.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | ll qexp(ll a, ll b, ll m) {
32 |     ll res = 1;
33 |     while (b > 0) {
34 |         if (b & 1) res = res * a % m;
35 |         a = a * a % m;
36 |         b >>= 1;
37 |     }
38 |     return res;
39 | }
40 | 
41 | void solve(int tc = 0) {
42 |     int a, b, c; cin >> a >> b >> c;
43 |     cout << qexp(a, qexp(b, c, MOD - 1), MOD) << "\n";
44 | }
45 | 
46 | signed main() {
47 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
48 |     int tc = 1;
49 |     cin >> tc;
50 |     for (int t = 1; t <= tc; t++) {
51 |         // cout << "Case #" << t << ": ";
52 |         solve(t);
53 |     }
54 | }


--------------------------------------------------------------------------------
/src/1713.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     int ans = 0;
36 |     for (int i = 1; i * i <= n; i++) {
37 |         if (n % i == 0) {
38 |             ans++;
39 |             if (i * i != n) ans++;
40 |         }
41 |     }
42 |     cout << ans << "\n";
43 | }
44 | 
45 | signed main() {
46 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
47 |     int tc = 1;
48 |     cin >> tc;
49 |     for (int t = 1; t <= tc; t++) {
50 |         // cout << "Case #" << t << ": ";
51 |         solve(t);
52 |     }
53 | }


--------------------------------------------------------------------------------
/src/1725.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n, a, b; cin >> n >> a >> b;
35 |     vector<vector<ld>> dp(n + 1, vector<ld>(6 * n + 1));
36 |     dp[0][0] = 1;
37 |     for (int i = 1; i <= n; i++) {
38 |         for (int j = 6 * i; j > 0; j--) {
39 |             for (int k = 1; k <= 6 && j - k >= 0; k++) {
40 |                 dp[i][j] += dp[i - 1][j - k] / 6;
41 |             }
42 |         }
43 |     }
44 |     ld ans = 0;
45 |     for (int i = a; i <= b; i++) ans += dp[n][i];
46 |     cout << fixed << setprecision(6) << ans << "\n";
47 | }
48 | 
49 | signed main() {
50 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
51 |     int tc = 1;
52 |     // cin >> tc;
53 |     for (int t = 1; t <= tc; t++) {
54 |         // cout << "Case #" << t << ": ";
55 |         solve(t);
56 |     }
57 | }


--------------------------------------------------------------------------------
/src/1727.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // Y = max(X1, X2, ..., Xn)
32 |  
33 | void solve(int tc = 0) {
34 |     int n, k; cin >> n >> k;
35 |     ld ans = 0;
36 |     for (int i = 1; i <= k; i++) {
37 |         ans += (pow((ld) i / k, n) - pow((ld) (i - 1) / k, n)) * i;
38 |     }
39 |     cout << fixed << setprecision(6) << ans << "\n";
40 | }
41 | 
42 | signed main() {
43 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
44 |     int tc = 1;
45 |     // cin >> tc;
46 |     for (int t = 1; t <= tc; t++) {
47 |         // cout << "Case #" << t << ": ";
48 |         solve(t);
49 |     }
50 | }


--------------------------------------------------------------------------------
/src/1728.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     ld ans = 0;
38 |     for (int i = 0; i < n; i++) {
39 |         for (int j = i + 1; j < n; j++) {
40 |             int mn = min(a[i], a[j]);
41 |             ld p = mn * (mn - 1) / 2;
42 |             if (a[i] > a[j]) p += (a[i] - a[j]) * a[j];
43 |             p /= (a[i] * a[j]);
44 |             ans += p;
45 |         }
46 |     }
47 |     cout << fixed << setprecision(6) << ans << "\n";
48 | }
49 | 
50 | signed main() {
51 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
52 |     int tc = 1;
53 |     // cin >> tc;
54 |     for (int t = 1; t <= tc; t++) {
55 |         // cout << "Case #" << t << ": ";
56 |         solve(t);
57 |     }
58 | }


--------------------------------------------------------------------------------
/src/1729.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n, m; cin >> m >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     vector<bool> dp(m + 1);
38 |     for (int i = 1; i <= m; i++) {
39 |         for (int x : a) {
40 |             if (i >= x) {
41 |                 dp[i] = dp[i] | !dp[i - x];
42 |             }
43 |         }
44 |     }
45 |     for (int i = 1; i <= m; i++) cout << (dp[i] ? "W" : "L");
46 |     cout << "\n";
47 | }
48 | 
49 | signed main() {
50 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
51 |     int tc = 1;
52 |     // cin >> tc;
53 |     for (int t = 1; t <= tc; t++) {
54 |         // cout << "Case #" << t << ": ";
55 |         solve(t);
56 |     }
57 | }


--------------------------------------------------------------------------------
/src/1730.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // Nim Game
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     int sum = 0;
36 |     while (n--) {
37 |         int x; cin >> x;
38 |         sum ^= x;
39 |     }
40 |     cout << (sum ? "first" : "second") << "\n";
41 | }
42 | 
43 | signed main() {
44 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
45 |     int tc = 1;
46 |     cin >> tc;
47 |     for (int t = 1; t <= tc; t++) {
48 |         // cout << "Case #" << t << ": ";
49 |         solve(t);
50 |     }
51 | }


--------------------------------------------------------------------------------
/src/1732.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | vector<int> preprocess(const string &s) {
32 |     int n = sz(s);
33 |     vector<int> f(n); // f[0] = 0 by default
34 |     for (int i = 1; i < n; i++) {
35 |         int j = f[i - 1];
36 |         while (j && s[i] != s[j]) 
37 |             j = f[j - 1];
38 |         f[i] = j + (s[i] == s[j]);
39 |     }
40 |     return f;
41 | }
42 |  
43 | void cntBorder(const string &s) {
44 |     int n = sz(s);
45 |     auto f = preprocess(s);
46 |     vector<int> ans;
47 |     for (int i = n; 0 < f[i - 1] && f[i - 1] < n; i = f[i - 1]) ans.push_back(f[i - 1]);
48 |     reverse(all(ans));
49 |     for (int x : ans) cout << x << " ";
50 |     cout << "\n";
51 | }
52 |  
53 | void solve(int tc = 0) {
54 |     string s; cin >> s;
55 |     cntBorder(s);
56 | }
57 | 
58 | signed main() {
59 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
60 |     int tc = 1;
61 |     // cin >> tc;
62 |     for (int t = 1; t <= tc; t++) {
63 |         // cout << "Case #" << t << ": ";
64 |         solve(t);
65 |     }
66 | }


--------------------------------------------------------------------------------
/src/1733.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | vector<int> preprocess(const string &s) {
32 |     int n = sz(s);
33 |     vector<int> f(n); // f[0] = 0 by default
34 |     for (int i = 1, l = 0, r = 0; i < n; i++) {
35 |         if (i <= r) 
36 |             f[i] = min(r - i + 1, f[i - l]);
37 |         while (i + f[i] < n && s[f[i]] == s[i + f[i]]) 
38 |             f[i]++;
39 |         if (i + f[i] - 1 > r) 
40 |             l = i, r = i + f[i] - 1;
41 |     }
42 |     return f;
43 | }
44 |  
45 | void cntPeriod(const string &s) {
46 |     int n = sz(s);
47 |     auto f = preprocess(s);
48 |     for (int i = 1; i < n; i++) {
49 |         if (i + f[i] >= n) {
50 |             cout << i << " ";
51 |         }
52 |     }
53 |     cout << n << "\n";
54 | }
55 |  
56 | void solve(int tc = 0) {
57 |     string s; cin >> s;
58 |     cntPeriod(s);
59 | }
60 | 
61 | signed main() {
62 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
63 |     int tc = 1;
64 |     // cin >> tc;
65 |     for (int t = 1; t <= tc; t++) {
66 |         // cout << "Case #" << t << ": ";
67 |         solve(t);
68 |     }
69 | }


--------------------------------------------------------------------------------
/src/1744.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp[i][j] = min cost to split a i x j rectangle
32 | // all the possible transitions are all the possible splits
33 | 
34 | void solve(int tc = 0) {
35 |     int a, b; cin >> a >> b;
36 |     vector<vector<int>> dp(a + 1, vector<int>(b + 1, INF));
37 |     for (int i = 1; i <= a; i++) {
38 |         for (int j = 1; j <= b; j++) {
39 |             if (i == j) {
40 |                 dp[i][j] = 0;
41 |             } else {
42 |                 for (int k = 1; k <= i - k; k++) dp[i][j] = min(dp[i][j], dp[k][j] + dp[i - k][j] + 1);
43 |                 for (int k = 1; k <= j - k; k++) dp[i][j] = min(dp[i][j], dp[i][k] + dp[i][j - k] + 1);
44 |             }
45 |         }
46 |     }
47 |     cout << dp[a][b] << "\n";
48 | }
49 | 
50 | signed main() {
51 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
52 |     int tc = 1;
53 |     // cin >> tc;
54 |     for (int t = 1; t <= tc; t++) {
55 |         // cout << "Case #" << t << ": ";
56 |         solve(t);
57 |     }
58 | }


--------------------------------------------------------------------------------
/src/1745.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // dp[i] = whether it is possible to make a sum of i
32 | // dp[i] = or sum of { dp[i - x] }, where i >= x
33 | 
34 | void solve(int tc = 0) {
35 |     int n; cin >> n;
36 |     vector<int> a(n);
37 |     int m = 0;
38 |     for (int &x : a) cin >> x, m += x;
39 |     vector<bool> dp(m + 1);
40 |     dp[0] = true;
41 |     int cnt = 0;
42 |     for (int x : a) {
43 |         for (int i = m; i >= x; i--) {
44 |             if (!dp[i] && dp[i - x]) {
45 |                 dp[i] = true;
46 |                 cnt++;
47 |             }
48 |         }
49 |     }
50 |     cout << cnt << "\n";
51 |     for (int i = 1; i <= m; i++) {
52 |         if (dp[i]) {
53 |             cout << i << " ";
54 |         }
55 |     }
56 |     cout << "\n";
57 | }
58 | 
59 | signed main() {
60 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
61 |     int tc = 1;
62 |     // cin >> tc;
63 |     for (int t = 1; t <= tc; t++) {
64 |         // cout << "Case #" << t << ": ";
65 |         solve(t);
66 |     }
67 | }


--------------------------------------------------------------------------------
/src/1749.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | #include <ext/pb_ds/assoc_container.hpp>
32 | #include <ext/pb_ds/tree_policy.hpp>
33 | using namespace __gnu_pbds;
34 | template <class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
35 |  
36 | void solve(int tc = 0) {
37 |     int n; cin >> n;
38 |     ordered_set<ar<int,2>> os;
39 |     for (int i = 0; i < n; i++) {
40 |         int x; cin >> x;
41 |         os.insert({i + 1, x});
42 |     }    
43 |     while (n--) {
44 |         int i; cin >> i; i--;
45 |         auto it = os.find_by_order(i);
46 |         cout << (*it)[1] << " ";
47 |         os.erase(it);
48 |     }
49 |     cout << "\n";
50 | }
51 | 
52 | signed main() {
53 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
54 |     int tc = 1;
55 |     // cin >> tc;
56 |     for (int t = 1; t <= tc; t++) {
57 |         // cout << "Case #" << t << ": ";
58 |         solve(t);
59 |     }
60 | }


--------------------------------------------------------------------------------
/src/1750.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 2e5 + 5;
25 | const int MAX_L = 30;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | int n, q, par[MAX_N][MAX_L];
32 |  
33 | int kthAnc(int u, int k) {
34 |     for (int i = 0; i < MAX_L; i++)
35 |         if (k & (1 << i))
36 |             u = par[u][i];
37 |     return u;
38 | }
39 | 
40 | // functional graph
41 |  
42 | void solve(int tc = 0) {
43 |     cin >> n >> q;
44 |     for (int i = 1; i <= n; i++) cin >> par[i][0];
45 |     for (int i = 1; i < MAX_L; i++) 
46 |         for (int u = 1; u <= n; u++)
47 |             par[u][i] = par[par[u][i - 1]][i - 1];
48 |     while (q--) {
49 |         int u, k; cin >> u >> k;
50 |         cout << kthAnc(u, k) << "\n";
51 |     }        
52 | }
53 | 
54 | signed main() {
55 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
56 |     int tc = 1;
57 |     // cin >> tc;
58 |     for (int t = 1; t <= tc; t++) {
59 |         // cout << "Case #" << t << ": ";
60 |         solve(t);
61 |     }
62 | }


--------------------------------------------------------------------------------
/src/1751.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 2e5 + 5;
25 | const int MAX_L = 30;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | int n, q, par[MAX_N], dep[MAX_N], cy[MAX_N];
32 |  
33 | void dfs(int u, int d = 0) {
34 |     cy[u] = --d;
35 |     int v = par[u];
36 |     if (cy[v] == 0) {
37 |         dfs(v, d);
38 |     }
39 |     if (cy[v] < 0) {
40 |         cy[u] = cy[v] - cy[u] + 1;
41 |         dep[u] = cy[u];
42 |         while (v != u) {
43 |             dep[v] = cy[v] = cy[u];
44 |             v = par[v];
45 |         }
46 |     } else if (cy[u] != cy[v]) {
47 |         cy[u] = cy[v];
48 |         dep[u] = dep[v] + 1 ;
49 |     }
50 | }
51 |  
52 | void solve(int tc = 0) {
53 |     cin >> n;
54 |     for (int i = 1; i <= n; i++) cin >> par[i];
55 |     for (int i = 1; i <= n; i++) {
56 |         if (cy[i] == 0) {
57 |             dfs(i);
58 |         }
59 |     }
60 |     for (int i = 1; i <= n; i++) cout << dep[i] << " ";
61 |     cout << "\n";
62 | }
63 | 
64 | signed main() {
65 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
66 |     int tc = 1;
67 |     // cin >> tc;
68 |     for (int t = 1; t <= tc; t++) {
69 |         // cout << "Case #" << t << ": ";
70 |         solve(t);
71 |     }
72 | }


--------------------------------------------------------------------------------
/src/1753.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | vector<int> preprocess(const string &s) {
32 |     int n = sz(s);
33 |     vector<int> f(n); // f[0] = 0 by default
34 |     for (int i = 1; i < n; i++) {
35 |         int j = f[i - 1];
36 |         while (j > 0 && s[i] != s[j]) 
37 |             j = f[j - 1];
38 |         f[i] = j + (s[i] == s[j]);
39 |     }
40 |     return f;
41 | }
42 | 
43 | int cntMatching(const string &s, const string &t) {
44 |     string ts = t + "#" + s;
45 |     int n = sz(t), nm = sz(ts);
46 |     auto f = preprocess(ts);
47 |     int res = 0;
48 |     for (int i = n + 1; i < nm; i++) 
49 |         res += (f[i] == n);
50 |     return res;
51 | }
52 | 
53 | void solve(int tc = 0) {
54 |     string s, t; cin >> s >> t;
55 |     cout << cntMatching(s, t) << "\n";
56 | }
57 | 
58 | signed main() {
59 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
60 |     int tc = 1;
61 |     // cin >> tc;
62 |     for (int t = 1; t <= tc; t++) {
63 |         // cout << "Case #" << t << ": ";
64 |         solve(t);
65 |     }
66 | }


--------------------------------------------------------------------------------
/src/1754.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // observe patterns
32 | 
33 | void solve(int tc = 0) {
34 |     int a, b; cin >> a >> b;
35 |     cout << (((a + b) % 3 || min(a, b) < (a + b) / 3) ? "NO" : "YES") << "\n"; 
36 | }
37 | 
38 | signed main() {
39 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
40 |     int tc = 1;
41 |     cin >> tc;
42 |     for (int t = 1; t <= tc; t++) {
43 |         // cout << "Case #" << t << ": ";
44 |         solve(t);
45 |     }
46 | }


--------------------------------------------------------------------------------
/src/1755.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // simple palindrome construction
32 | 
33 | void solve(int tc = 0) {
34 |     string s; cin >> s;
35 |     vector<int> cnt(MAX_C);
36 |     for (char c : s) cnt[c - 'A']++;
37 |     int odd = -1;
38 |     for (int i = 0; i < MAX_C; i++) {
39 |         if (cnt[i] % 2) {
40 |             if (odd != -1) {
41 |                 cout << "NO SOLUTION\n";
42 |                 return;
43 |             } else {
44 |                 odd = i;
45 |                 cnt[i]--;
46 |             }
47 |         }
48 |     }
49 |     string t1;
50 |     for (int i = 0; i < MAX_C; i++) {
51 |         t1 += string(cnt[i] / 2, 'A' + i);
52 |     }
53 |     string t2(t1.rbegin(), t1.rend());
54 |     if (odd != -1) t1 += (char) ('A' + odd);
55 |     cout << t1 << t2 << "\n";
56 | }
57 | 
58 | signed main() {
59 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
60 |     int tc = 1;
61 |     // cin >> tc;
62 |     for (int t = 1; t <= tc; t++) {
63 |         // cout << "Case #" << t << ": ";
64 |         solve(t);
65 |     }
66 | }


--------------------------------------------------------------------------------
/src/2136.cpp:
--------------------------------------------------------------------------------
 1 | #pragma GCC optimize("O3,unroll-loops")
 2 | #pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
 3 | 
 4 | #include <bits/stdc++.h>
 5 | 
 6 | using namespace std;
 7 | 
 8 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 9 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
10 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
11 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
12 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
13 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
14 | #ifdef LOCAL
15 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
16 | #else
17 | #define dbg(...)
18 | #endif
19 | 
20 | using ll = long long;
21 | using ld = long double;
22 | #define ar array
23 | #define sz(x) ((int)x.size())
24 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
25 | #define all(a) (a).begin(), (a).end()
26 | 
27 | const int MAX_N = 1e5 + 5;
28 | const int MAX_L = 20;
29 | const int MAX_C = 26;
30 | const ll MOD = 1e9 + 7;
31 | const ll INF = 1e9;
32 | const ld EPS = 1e-9;
33 | 
34 | const int MAX_K = 30;
35 | 
36 | // Bitset
37 | 
38 | void solve(int tc = 0) {
39 |     int n, m; cin >> n >> m;
40 |     vector<bitset<MAX_K>> a(n);
41 |     for (int i = 0; i < n; i++) {
42 |         for (int j = 0; j < m; j++) {
43 |             char c; cin >> c;
44 |             if (c == '1') {
45 |                 a[i].set(j);
46 |             }
47 |         }
48 |     }
49 |     int ans = m;
50 |     for (int i = 0; i < n; i++) {
51 |         for (int j = i + 1; j < n; j++) {
52 |             ans = min(ans, (int) (a[i] ^ a[j]).count());
53 |         }
54 |     }
55 |     cout << ans << "\n";
56 | }
57 | 
58 | signed main() {
59 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
60 |     int tc = 1;
61 |     // cin >> tc;
62 |     for (int t = 1; t <= tc; t++) {
63 |         // cout << "Case #" << t << ": ";
64 |         solve(t);
65 |     }
66 | }


--------------------------------------------------------------------------------
/src/2137.cpp:
--------------------------------------------------------------------------------
 1 | #pragma GCC optimize("O3,unroll-loops")
 2 | #pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
 3 | 
 4 | #include <bits/stdc++.h>
 5 | 
 6 | using namespace std;
 7 | 
 8 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 9 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
10 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
11 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
12 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
13 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
14 | #ifdef LOCAL
15 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
16 | #else
17 | #define dbg(...)
18 | #endif
19 | 
20 | using ll = long long;
21 | using ld = long double;
22 | #define ar array
23 | #define sz(x) ((int)x.size())
24 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
25 | #define all(a) (a).begin(), (a).end()
26 | 
27 | const int MAX_N = 1e5 + 5;
28 | const int MAX_L = 20;
29 | const int MAX_C = 26;
30 | const ll MOD = 1e9 + 7;
31 | const ll INF = 1e9;
32 | const ld EPS = 1e-9;
33 | 
34 | const int MAX_K = 3e3;
35 | 
36 | // Bitset
37 | 
38 | void solve(int tc = 0) {
39 |     int n; cin >> n;
40 |     vector<bitset<MAX_K>> a(n);
41 |     for (int i = 0; i < n; i++) {
42 |         for (int j = 0; j < n; j++) {
43 |             char c; cin >> c;
44 |             if (c == '1') a[i].set(j);
45 |         }
46 |     }
47 |     ll ans = 0;
48 |     for (int i = 0; i < n; i++) {
49 |         for (int j = i + 1; j < n; j++) {
50 |             int k = (a[i] & a[j]).count();
51 |             ans += (ll) k * (k - 1) / 2;
52 |         }
53 |     }
54 |     cout << ans << "\n";
55 | }
56 | 
57 | signed main() {
58 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
59 |     int tc = 1;
60 |     // cin >> tc;
61 |     for (int t = 1; t <= tc; t++) {
62 |         // cout << "Case #" << t << ": ";
63 |         solve(t);
64 |     }
65 | }


--------------------------------------------------------------------------------
/src/2162.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // simulate using an ordered set
32 | 
33 | #include <ext/pb_ds/assoc_container.hpp>
34 | #include <ext/pb_ds/tree_policy.hpp>
35 | using namespace __gnu_pbds;
36 | template <class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
37 |  
38 | void solve(int tc = 0) {
39 |     int n; cin >> n;
40 |     vector<int> a(n);
41 |     iota(all(a), 1);
42 |     ordered_set<int> os(all(a));
43 |     int idx = 0;
44 |     while (!os.empty()) {
45 |         idx = (idx + 1) % sz(os);
46 |         auto it = os.find_by_order(idx);
47 |         cout << *it << " ";
48 |         os.erase(it);
49 |     }
50 |     cout << "\n";
51 | }
52 | 
53 | signed main() {
54 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
55 |     int tc = 1;
56 |     // cin >> tc;
57 |     for (int t = 1; t <= tc; t++) {
58 |         // cout << "Case #" << t << ": ";
59 |         solve(t);
60 |     }
61 | }


--------------------------------------------------------------------------------
/src/2163.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // simulate using an ordered set
32 | 
33 | #include <ext/pb_ds/assoc_container.hpp>
34 | #include <ext/pb_ds/tree_policy.hpp>
35 | using namespace __gnu_pbds;
36 | template <class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
37 |  
38 | void solve(int tc = 0) {
39 |     int n, k; cin >> n >> k;
40 |     vector<int> a(n);
41 |     iota(all(a), 1);
42 |     ordered_set<int> os(all(a));
43 |     int idx = 0;
44 |     while (!os.empty()) {
45 |         idx = (idx + k) % sz(os);
46 |         auto it = os.find_by_order(idx);
47 |         cout << *it << " ";
48 |         os.erase(it);
49 |     }
50 |     cout << "\n";
51 | }
52 | 
53 | signed main() {
54 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
55 |     int tc = 1;
56 |     // cin >> tc;
57 |     for (int t = 1; t <= tc; t++) {
58 |         // cout << "Case #" << t << ": ";
59 |         solve(t);
60 |     }
61 | }


--------------------------------------------------------------------------------
/src/2164.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | int query(int n, int k) {
32 |     if (n == 1) {
33 |         return 1;
34 |     } else if (n % 2) {
35 |         // 2, 4, ...,n - 1, 1
36 |         return (k <= (n + 1) / 2) ? 2 * k % n : 2 * query(n / 2, k - (n + 1) / 2) + 1;
37 |     } else {
38 |         // 2, 4, ..., n
39 |         return (k <= n / 2) ? 2 * k : 2 * query(n / 2, k - n / 2) - 1;
40 |     }
41 | }
42 |  
43 | void solve(int tc = 0) {
44 |     int n, k; cin >> n >> k;
45 |     cout << query(n, k) << "\n";
46 | }
47 | 
48 | signed main() {
49 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
50 |     int tc = 1;
51 |     cin >> tc;
52 |     for (int t = 1; t <= tc; t++) {
53 |         // cout << "Case #" << t << ": ";
54 |         solve(t);
55 |     }
56 | }


--------------------------------------------------------------------------------
/src/2165.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 |  
 3 | using namespace std;
 4 |  
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 |  
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 |  
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 |  
31 | // backtracking
32 | 
33 | void backtrack(int s, int e, int m, int n) {
34 |     if (n == 1) {
35 |         cout << s << " " << e << "\n";
36 |         return;
37 |     }
38 |     backtrack(s, m, e, n - 1);
39 |     backtrack(s, e, m, 1);
40 |     backtrack(m, e, s, n - 1);
41 | }
42 |  
43 | void solve(int tc = 0) {
44 |     int n; cin >> n;
45 |     cout << (1 << n) - 1 << "\n";
46 |     backtrack(1, 3, 2, n);
47 | }
48 |  
49 | signed main() {
50 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
51 |     int tc = 1;
52 |     // cin >> tc;
53 |     for (int t = 1; t <= tc; t++) {
54 |         // cout << "Case #" << t << ": ";
55 |         solve(t);
56 |     }
57 | }


--------------------------------------------------------------------------------
/src/2183.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // observe dp pattern
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     sort(all(a));
38 |     ll ans = 1;
39 |     for (int x : a) {
40 |         if (x > ans) break;
41 |         ans += x;
42 |     }
43 |     cout << ans << "\n";
44 | }
45 | 
46 | signed main() {
47 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
48 |     int tc = 1;
49 |     // cin >> tc;
50 |     for (int t = 1; t <= tc; t++) {
51 |         // cout << "Case #" << t << ": ";
52 |         solve(t);
53 |     }
54 | }


--------------------------------------------------------------------------------
/src/2185.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     ll n; int k; cin >> n >> k;
35 |     vector<ll> a(k);
36 |     for (ll &x : a) cin >> x;
37 |     ll ans = 0;
38 |     for (int mask = 1; mask < (1 << k); mask++) {
39 |         ll lcm = 1; 
40 |         int sgn = -1;
41 |         for (int i = 0; i < k; i++) {
42 |             if (mask & (1 << i)) {
43 |                 if (lcm > (n + a[i] - 1) / a[i]) {
44 |                     lcm = -1;
45 |                     break;
46 |                 }
47 |                 lcm *= a[i];
48 |                 sgn *= -1;
49 |             }
50 |         }
51 |         if (lcm != -1) {
52 |             ans += n / lcm * sgn;
53 |         }
54 |     }
55 |     cout << ans << "\n";
56 | }
57 | 
58 | signed main() {
59 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
60 |     int tc = 1;
61 |     // cin >> tc;
62 |     for (int t = 1; t <= tc; t++) {
63 |         // cout << "Case #" << t << ": ";
64 |         solve(t);
65 |     }
66 | }


--------------------------------------------------------------------------------
/src/2205.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 |  
 3 | using namespace std;
 4 |  
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 |  
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 |  
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // backtracking
32 | 
33 | int n;
34 | vector<bool> vis; 
35 |  
36 | string toBinary(const int &mask) {
37 |     string s(n, '0');
38 |     for (int i = n - 1; i >= 0; i--) {
39 |         if (mask & (1 << i)) {
40 |             s[i] = '1';
41 |         } else {
42 |             s[i] = '0';
43 |         }
44 |     }
45 |     return s;
46 | }
47 |  
48 | void backtrack(int mask) {
49 |     vis[mask] = true;
50 |     cout << toBinary(mask) << "\n";
51 |     for (int i = 0; i < n; i++) {
52 |         int nmask = mask ^ (1 << i);
53 |         if (!vis[nmask]) {
54 |             backtrack(nmask);
55 |         }
56 |     }
57 | }
58 |  
59 | void solve(int tc = 0) {
60 |     cin >> n;
61 |     vis.assign(1 << n, false);
62 |     backtrack(0);
63 | }
64 |  
65 | signed main() {
66 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
67 |     int tc = 1;
68 |     // cin >> tc;
69 |     for (int t = 1; t <= tc; t++) {
70 |         // cout << "Case #" << t << ": ";
71 |         solve(t);
72 |     }
73 | }


--------------------------------------------------------------------------------
/src/2207.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | int mex(const vector<int> &a) {
32 |     vector<bool> vis(MAX_N);
33 |     for (int x : a) vis[x] = true;
34 |     for (int i = 0; i < MAX_N; i++) {
35 |         if (!vis[i]) return i;
36 |     }
37 | }
38 |  
39 | // https://oeis.org/A036685, the max value is 1222
40 |  
41 | vector<int> dp = {0, 0, 0};
42 |  
43 | void precompute() {
44 |     for (int i = 3; i <= 1300; i++) {
45 |         vector<int> a;
46 |         for (int j = 1; i - j > j; j++) {
47 |             a.push_back(dp[i - j] ^ dp[j]);
48 |         }
49 |         dp.push_back(mex(a));
50 |     }
51 | }
52 |  
53 | void solve(int tc = 0) {
54 |     int n; cin >> n;
55 |     if (n > 1300) { 
56 |         cout << "first\n";
57 |     } else {
58 |         cout << (dp[n] ? "first" : "second") << "\n";
59 |     }
60 | }
61 | 
62 | signed main() {
63 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
64 |     int tc = 1;
65 |     cin >> tc;
66 |     precompute();
67 |     for (int t = 1; t <= tc; t++) {
68 |         // cout << "Case #" << t << ": ";
69 |         solve(t);
70 |     }
71 | }


--------------------------------------------------------------------------------
/src/2208.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | 
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     bool flag = false;
36 |     while (n--) {
37 |         int x; cin >> x;
38 |         flag |= (x % 2);
39 |     }
40 |     cout << (flag ? "first" : "second") << "\n";
41 | }
42 | 
43 | signed main() {
44 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
45 |     int tc = 1;
46 |     cin >> tc;
47 |     for (int t = 1; t <= tc; t++) {
48 |         // cout << "Case #" << t << ": ";
49 |         solve(t);
50 |     }
51 | }


--------------------------------------------------------------------------------
/src/2216.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // greedy
32 | 
33 | void solve(int tc = 0) {
34 |     int n; cin >> n;
35 |     vector<bool> vis(n);
36 |     int ans = 0;
37 |     while (n--) {
38 |         int x; cin >> x; x--;
39 |         if (x == 0 || !vis[x - 1]) ans++;
40 |         vis[x] = true;
41 |     }
42 |     cout << ans << "\n";
43 | }
44 | 
45 | signed main() {
46 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
47 |     int tc = 1;
48 |     // cin >> tc;
49 |     for (int t = 1; t <= tc; t++) {
50 |         // cout << "Case #" << t << ": ";
51 |         solve(t);
52 |     }
53 | }


--------------------------------------------------------------------------------
/src/2413.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e6 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | ar<int,2> dp[MAX_N];
32 |  
33 | void precompute() {
34 |     dp[1] = {1, 1}; // {separate 1x1 tile, merged 1x2 tile}
35 |     for (int i = 2; i < MAX_N; i++) {
36 |         dp[i][0] = ((ll) dp[i - 1][0] * 4 + dp[i - 1][1]) % MOD;
37 |         dp[i][1] = ((ll) dp[i - 1][1] * 2 + dp[i - 1][0]) % MOD;
38 |     }
39 | }
40 |  
41 | void solve(int tc = 0) {
42 |     int n; cin >> n;
43 |     cout << (dp[n][0] + dp[n][1]) % MOD << "\n";
44 | }
45 | 
46 | signed main() {
47 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
48 |     int tc = 1;
49 |     cin >> tc;
50 |     precompute();
51 |     for (int t = 1; t <= tc; t++) {
52 |         // cout << "Case #" << t << ": ";
53 |         solve(t);
54 |     }
55 | }


--------------------------------------------------------------------------------
/src/2428.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 | 
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 | 
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 | 
31 | // two pointers
32 | 
33 | void solve(int tc = 0) {
34 |     int n, k; cin >> n >> k;
35 |     vector<int> a(n);
36 |     for (int &x : a) cin >> x;
37 |     ll ans = 0;
38 |     map<int,int> mp;
39 |     for (int l = 0, r = 0; r < n; r++) {
40 |         mp[a[r]]++;
41 |         while (sz(mp) > k) {
42 |             mp[a[l]]--;
43 |             if (mp[a[l]] == 0) mp.erase(a[l]);
44 |             l++;
45 |         }
46 |         ans += r - l + 1;
47 |     }
48 |     cout << ans << "\n";
49 | }
50 | 
51 | signed main() {
52 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
53 |     int tc = 1;
54 |     // cin >> tc;
55 |     for (int t = 1; t <= tc; t++) {
56 |         // cout << "Case #" << t << ": ";
57 |         solve(t);
58 |     }
59 | }


--------------------------------------------------------------------------------
/src/2431.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 |  
 3 | using namespace std;
 4 |  
 5 | #define print_op(...) ostream& operator<<(ostream& out, const __VA_ARGS__& u)
 6 | template<typename A, typename B> print_op(pair<A, B>) { return out << "(" << u.first << ", " << u.second << ")"; }
 7 | template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> print_op(T_container) { out << "{"; string sep; for (const T &x : u) out << sep << x, sep = ", "; return out << "}"; }
 8 | template<typename T> void dbg_out(string s, T x) {cerr << "\033[1;35m" << s << "\033[0;32m = \033[33m" << x << "\033[0m\n";}
 9 | template<typename T, typename... Args> void dbg_out(string s, T x, Args... args) {for (int i=0, b=0; i<(int)s.size(); i++) if (s[i] == '(' || s[i] == '{') b++; else
10 | if (s[i] == ')' || s[i] == '}') b--; else if (s[i] == ',' && b == 0) {cerr << "\033[1;35m" << s.substr(0, i) << "\033[0;32m = \033[33m" << x << "\033[31m | "; dbg_out(s.substr(s.find_first_not_of(' ', i + 1)), args...); break;}}
11 | #ifdef LOCAL
12 | #define dbg(...) dbg_out(#__VA_ARGS__, __VA_ARGS__)
13 | #else
14 | #define dbg(...)
15 | #endif
16 |  
17 | #define ar array
18 | #define ll long long
19 | #define ld long double
20 | #define sz(x) ((int)x.size())
21 | #define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++) 
22 | #define all(a) (a).begin(), (a).end()
23 |  
24 | const int MAX_N = 1e5 + 5;
25 | const int MAX_L = 20;
26 | const int MAX_C = 26;
27 | const ll MOD = 1e9 + 7;
28 | const ll INF = 1e9;
29 | const ld EPS = 1e-9;
30 |  
31 | // observe patterns 
32 |  
33 | void solve(int tc = 0) {
34 |     ll n; cin >> n;
35 |     ll p9 = 9, d = 1, cnt = 0, tot = 0;
36 |     while (n > tot) {
37 |         tot += p9 * d;
38 |         cnt += p9;
39 |         p9 *= 10;
40 |         d++;
41 |     }
42 |     // n is in the range [10...00, 99...99], (d - 1) digits
43 |     p9 /= 10; d--; tot -= p9 * d; cnt -= p9; 
44 |     n -= tot;
45 |     ll idx = (n + d - 1) / d;
46 |     cnt += idx;
47 |     ll pos = (n + d - 1) % d;
48 |     string s = to_string(cnt);
49 |     cout << s[pos] << "\n";
50 | }
51 |  
52 | signed main() {
53 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
54 |     int tc = 1;
55 |     cin >> tc;
56 |     for (int t = 1; t <= tc; t++) {
57 |         // cout << "Case #" << t << ": ";
58 |         solve(t);
59 |     }
60 | }


--------------------------------------------------------------------------------