solution
stringlengths
52
181k
difficulty
int64
0
6
#include <bits/stdc++.h> using namespace std; int main() { int d[200000], i; long int n, a; cin >> n; a = n / 2; if (1 == n % 2) d[0] = 7; else d[0] = 1; cout << d[0]; for (i = 1; i < a; i++) { d[i] = 1; cout << d[1]; } return 0; }
3
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; const long long inf = 1e18; long long max(long long a, long long b) { return (a > b) ? a : b; } long long min(long long a, long long b) { return (a < b) ? a : b; } void solve() { vector<long long> v(5); long long sum = 0; for (long long i = 0; i < 5; i++) { cin >> v[i]; sum += v[i]; } sort(v.begin(), v.end()); long long best = 0; for (long long i = 0; i < 5; i++) { if (i + 1 < 5 && v[i] == v[i + 1]) { best = max(best, 2 * v[i]); } if (i + 2 < 5 && v[i] == v[i + 2]) { best = max(best, 3 * v[i]); } } cout << sum - best << "\n"; } signed main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); solve(); return 0; }
1
#include <bits/stdc++.h> using namespace std; int A, B; inline int read() { int ret = 0, f = 1; char ch = getchar(); while (ch < '0' || ch > '9') { if (ch == '-') f = -f; ch = getchar(); } while (ch <= '9' && ch >= '0') ret = ret * 10 + ch - '0', ch = getchar(); return ret * f; } int main() { int n = read(); for (int i = 1; i <= n; i++) { int x = read(); read(); if (x < 0) A++; else B++; } if (A < 2 || B < 2) printf("Yes"); else printf("No"); return 0; }
1
#include <bits/stdc++.h> using namespace std; const long double pai = acos(-1.0L); const long double eps = 1e-10; const long long mod = 1e9 + 7; const int MXN = 1e6 + 5; vector<int> g[MXN], v; int co[MXN]; int go[MXN]; void dfs(int now, int pr, int cg0, int cg1, int dis) { if (dis % 2 == 0) { if ((co[now] + cg1) % 2 != go[now]) v.push_back(now), cg1++; } else { if ((co[now] + cg0) % 2 != go[now]) v.push_back(now), cg0++; } for (auto i : g[now]) { if (i == pr) continue; dfs(i, now, cg0, cg1, dis + 1); } } int main() { int n; cin >> n; for (int i = 1; i < n; i++) { int sa, sb; scanf("%d %d", &sa, &sb); g[sa].push_back(sb); g[sb].push_back(sa); } for (int i = 1; i <= n; i++) scanf("%d", &co[i]); for (int i = 1; i <= n; i++) scanf("%d", &go[i]); dfs(1, -1, 0, 0, 0); cout << (int)v.size() << '\n'; for (auto i : v) cout << i << '\n'; return 0; }
1
#include <bits/stdc++.h> using namespace std; const long long int N = 1e4 + 7; long long expo(long long x, long long n, long long mod) { long long res = 1LL; while (n) { if (n & 1) res = (res * x) % mod; x = (x * x) % mod; n = n / 2; } return res; } int main(int argc, char const *argv[]) { ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); int i, j; unsigned long long n; cin >> n; vector<int> v; if (n < 10) return cout << -1, 0; string s, str; s = to_string(n); int h[26] = {0}; for (int i = (0); i < (int)((s).size()); i++) h[s[i] - '0']++; if ((h[0] < 2) && (h[0] == 0 || h[5] == 0) && (h[7] == 0 || h[5] == 0) && (h[2] == 0 || h[5] == 0)) return cout << -1 << ' ', 0; int c; if (h[0] > 0 && h[5] > 0) { str = s; c = 0; for (i = (int)((str).size()) - 1; i >= 0; i--) if (str[i] == '0') break; for (int j = (i); j < (int)((s).size()) - 1; j++) swap(str[j], str[j + 1]), c++; for (i = (int)((str).size()) - 2; i >= 0; i--) if (str[i] == '5') break; for (int j = (i); j < (int)((s).size()) - 2; j++) swap(str[j], str[j + 1]), c++; if (str[0] == '0') { i = 0; while (str[i] == '0' && i < (int)((str).size())) i++; for (j = i; j > 0; j--) swap(str[j], str[j - 1]), c++; } v.push_back(c); } if (h[0] > 1) { str = s; c = 0; for (i = (int)((str).size()) - 1; i >= 0; i--) if (str[i] == '0') break; for (int j = (i); j < (int)((s).size()) - 1; j++) swap(str[j], str[j + 1]), c++; for (i = (int)((str).size()) - 2; i >= 0; i--) if (str[i] == '0') break; for (int j = (i); j < (int)((s).size()) - 2; j++) swap(str[j], str[j + 1]), c++; if (str[0] == '0') { i = 0; while (str[i] == '0' && i < (int)((str).size())) i++; for (j = i; j > 0; j--) swap(str[j], str[j - 1]), c++; } v.push_back(c); } if (h[5] > 0 && h[7] > 0) { str = s; c = 0; for (i = (int)((str).size()) - 1; i >= 0; i--) if (str[i] == '5') break; for (int j = (i); j < (int)((s).size()) - 1; j++) swap(str[j], str[j + 1]), c++; for (i = (int)((str).size()) - 2; i >= 0; i--) if (str[i] == '7') break; for (int j = (i); j < (int)((s).size()) - 2; j++) swap(str[j], str[j + 1]), c++; if (str[0] == '0') { i = 0; while (str[i] == '0' && i < (int)((str).size())) i++; for (j = i; j > 0; j--) swap(str[j], str[j - 1]), c++; } v.push_back(c); } if (h[2] > 0 && h[5] > 0) { str = s; c = 0; for (i = (int)((str).size()) - 1; i >= 0; i--) if (str[i] == '5') break; for (int j = (i); j < (int)((s).size()) - 1; j++) swap(str[j], str[j + 1]), c++; for (i = (int)((str).size()) - 2; i >= 0; i--) if (str[i] == '2') break; for (int j = (i); j < (int)((s).size()) - 2; j++) swap(str[j], str[j + 1]), c++; if (str[0] == '0') { i = 0; while (str[i] == '0' && i < (int)((str).size())) i++; for (j = i; j > 0; j--) swap(str[j], str[j - 1]), c++; } v.push_back(c); } if (!v.empty()) { sort(v.begin(), v.end()); cout << v[0]; } else cout << 0; return 0; }
5
#include<bits/stdc++.h> #define rep(i,n) for(int i = 0; i < (n); ++i) using namespace std; int t[100][6]; int ans = 0; bool remove(){ bool ret = 0; rep(i,20)rep(j,4){ if(t[i][j] != 0 && t[i][j] == t[i][j+1] && t[i][j+1] == t[i][j+2]){ //cout << t[i][j] << " " << t[i][j+1] << endl; for(int jj = j + 1; t[i][jj] == t[i][j]; jj++){ ans += t[i][jj]; t[i][jj] = 0; } ans += t[i][j]; t[i][j] = 0; ret = 1; } } return ret; } void fall(){ rep(tt,50)rep(i,20)rep(j,5)if(t[i][j] == 0)t[i][j] = t[i+1][j],t[i+1][j] = 0; } int main(){ int x; while(cin >> x, x){ ans = 0; rep(i,100)rep(j,6)t[i][j] = 0; rep(i,x)rep(j,5) cin >> t[x-i-1][j]; rep(i,500){ remove(); fall(); //rep(i,x){{rep(j,5)cout << t[i][j] << " ";}cout<<endl;}cout << endl; } cout << ans << endl; } }
0
#include <bits/stdc++.h> using namespace std; char s1[105][101], s2[105][105], s3[105], s4[105]; int mm[105]; void change(char s[]) { int l = strlen(s); for (int i = 0; i < l; i++) { if (s[i] >= 'A' && s[i] <= 'Z') s[i] += 32; } } int main() { int i, j, t, k, n, z, flag; char letter; while (scanf("%d", &n) != EOF) { memset(mm, 0, sizeof(mm)); getchar(); for (i = 0; i < n; i++) { gets(s1[i]); strcpy(s2[i], s1[i]); change(s2[i]); } gets(s3); strcpy(s4, s3); change(s4); scanf("%c", &letter); int l = strlen(s4); for (i = 0; i < strlen(s4); i++) for (k = 0; k < n; k++) { for (z = 0, flag = 1, j = i; j < i + strlen(s1[k]); j++) { if (s4[j] != s2[k][z++]) flag = 0; } if (l - strlen(s1[k]) + 1 >= i && flag == 1) for (t = i; t < i + strlen(s1[k]); t++) mm[t] = 1; } if (letter >= 'A' && letter <= 'Z') letter += 32; for (int i = 0; i < l; i++) if (mm[i]) { if (s4[i] == letter) { char tmp; if (s4[i] == 'a') tmp = 'b'; else tmp = 'a'; if (s3[i] >= 'A' && s3[i] <= 'Z') s3[i] = tmp - 32; else s3[i] = tmp; } else if (s3[i] >= 'A' && s3[i] <= 'Z') s3[i] = letter - 32; else s3[i] = letter; } puts(s3); } return 0; }
3
#include <bits/stdc++.h> using namespace std; template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) { os << '{'; string sep; for (const auto &x : v) os << sep << x, sep = ", "; return os << '}'; } template <typename A, typename B> ostream &operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.first << ", " << p.second << ')'; } void dbg_out() { cerr << endl; } template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); } template <typename T> struct fenwick_tree { int tree_n = 0; T tree_sum = 0; vector<T> tree; fenwick_tree(int n = -1) { if (n >= 0) init(n); } void init(int n) { tree_n = n; tree_sum = 0; tree.assign(tree_n + 1, 0); } template <typename T_array> void build(const T_array &initial) { assert((int)initial.size() == tree_n); tree_sum = 0; for (int i = 1; i <= tree_n; i++) { tree[i] = initial[i - 1]; tree_sum += initial[i - 1]; for (int k = (i & -i) >> 1; k > 0; k >>= 1) tree[i] += tree[i - k]; } } void update(int index, const T &change) { assert(0 <= index && index < tree_n); tree_sum += change; for (int i = index + 1; i <= tree_n; i += i & -i) tree[i] += change; } T query(int count) const { assert(count <= tree_n); T sum = 0; for (int i = count; i > 0; i -= i & -i) sum += tree[i]; return sum; } T query_suffix(int start) const { return tree_sum - query(start); } T query(int a, int b) const { return query(b) - query(a); } T get(int a) const { assert(0 <= a && a < tree_n); int above = a + 1; T sum = tree[above]; above -= above & -above; while (a != above) { sum -= tree[a]; a -= a & -a; } return sum; } bool set(int index, T value) { assert(0 <= index && index < tree_n); T current = get(index); if (current == value) return false; update(index, value - current); return true; } int find_last_prefix(T sum) const { if (sum < 0) return -1; int prefix = 0; for (int k = 31 - __builtin_clz(tree_n); k >= 0; k--) if (prefix + (1 << k) <= tree_n && tree[prefix + (1 << k)] <= sum) { prefix += 1 << k; sum -= tree[prefix]; } return prefix; } }; const int ALPHABET = 26; const char MIN_CHAR = 'a'; int N; string S; vector<int> eq_freq; fenwick_tree<int> tree; int needed() { int maximum = 0, sum = 0; for (int c = 0; c < ALPHABET; c++) { maximum = max(maximum, eq_freq[c]); sum += eq_freq[c]; } return max(maximum, (sum + 1) / 2) + 1; } bool can_match(char x, char y) { if (x == y) return false; int before = needed(); eq_freq[x - MIN_CHAR]--; eq_freq[y - MIN_CHAR]--; int after = needed(); eq_freq[x - MIN_CHAR]++; eq_freq[y - MIN_CHAR]++; return after == before - 1; } void run_case() { cin >> S; N = S.size(); tree.init(N); tree.build(vector<int>(N, 1)); vector<pair<int, int>> moves; auto &&add_move = [&](int start, int end) { int under_start = tree.query(start); int under_end = tree.query(end); moves.emplace_back(under_start, under_end); while (true) { int x = tree.find_last_prefix(under_start); if (x >= end) break; tree.update(x, -1); } }; eq_freq.assign(ALPHABET, 0); vector<pair<int, int>> eq_vec; for (int i = 0; i < N - 1; i++) if (S[i] == S[i + 1]) { eq_vec.emplace_back(i, i + 1); eq_freq[S[i] - MIN_CHAR]++; } vector<pair<int, int>> eq_stack; for (pair<int, int> &eq : eq_vec) if (!eq_stack.empty() && can_match(S[eq_stack.back().first], S[eq.first])) { eq_freq[S[eq_stack.back().first] - MIN_CHAR]--; eq_freq[S[eq.first] - MIN_CHAR]--; add_move(eq_stack.back().second, eq.first + 1); eq_stack.pop_back(); } else { eq_stack.push_back(eq); } while (!eq_stack.empty()) { add_move(eq_stack.back().second, N); eq_stack.pop_back(); } add_move(0, N); cout << moves.size() << '\n'; for (pair<int, int> &move : moves) cout << move.first + 1 << ' ' << move.second << '\n'; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int tests; cin >> tests; while (tests-- > 0) run_case(); }
4
#include <bits/stdc++.h> using namespace std; ifstream file("input.txt"); int main() { int n, m = 0; string str; cin >> n >> str; for (int i = 0; i < n; i++) { if (str[i] == '<') m++; else break; } for (int i = n - 1; i >= 0; i--) { if (str[i] == '>') m++; else break; } cout << m; }
1
#include <bits/stdc++.h> using namespace std; int main() { int n, m, i, j, l, p; cin >> n >> m; p = n; int arr[m]; string s[n]; int k = 0; for (i = 0; i < m; i++) { arr[i] = 0; } while (p-- > 0) { cin >> s[k]; for (i = 0; i < m; i++) { arr[i] = arr[i] + (s[k][i] % 48); } k++; } for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { arr[j] -= (s[i][j] % 48); } for (l = 0; l < m; l++) { if (arr[l] == 0) break; } if (l == m) { cout << "YES" << endl; return 0; } for (j = 0; j < m; j++) { arr[j] += (s[i][j] % 48); } } cout << "NO"; return 0; }
2
#include <bits/stdc++.h> using namespace std; const int INF = 1000000005; const long long INFLL = 1000000000000000002ll; const long long MOD = 1000000007; inline long long min(long long a, long long b, long long c) { return min(min(a, b), c); } inline long long min(long long a, long long b, long long c, long long d) { return min(min(min(a, b), c), d); } inline long long max(long long a, long long b, long long c) { return max(max(a, b), c); } inline long long max(long long a, long long b, long long c, long long d) { return max(max(max(a, b), c), d); } int A[300005], DP[300005][20], Last[20], N, Q; int main() { cin >> N >> Q; for (int i = (1); i <= (N); i++) cin >> A[i]; for (int b = (0); b <= (18); b++) Last[b] = INF; for (int i = (N); i >= (1); i--) { for (int b = (0); b <= (18); b++) DP[i][b] = INF; for (int b = (0); b <= (18); b++) for (int b2 = (0); b2 <= (18); b2++) if (A[i] & (1 << b2) && Last[b2] < INF) DP[i][b] = min(DP[i][b], DP[Last[b2]][b]); for (int b = (0); b <= (18); b++) if (A[i] & (1 << b)) { Last[b] = i; DP[i][b] = Last[b]; } } while (Q--) { int x, y; cin >> x >> y; bool found = false; for (int b = (0); b <= (18); b++) if ((A[y] & (1 << b)) && DP[x][b] <= y) found = true; if (found) cout << "Shi\n"; else cout << "Fou\n"; } }
3
#include <bits/stdc++.h> using namespace std; inline int read() { int x = 0; char ch = getchar(); bool positive = 1; for (; ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') positive = 0; for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0'; return positive ? x : -x; } int N, M, a[405][405]; int f[405][405], tmp[405][405]; unsigned short g[405][160005]; int main() { N = read(), M = read(); for (int i = 1; i <= N; ++i) for (int j = 1; j <= M; ++j) a[i][j] = read(); int ans = 0; for (int i = 1; i <= N; ++i) { for (int l = M; l; --l) for (int r = l; r <= M; ++r) { if (l == r) tmp[l][r] = g[l][a[i][l]]; else { tmp[l][r] = max(tmp[l][r - 1], tmp[l + 1][r]); tmp[l][r] = max(tmp[l][r], (int)g[r][a[i][l]]); tmp[l][r] = max(tmp[l][r], (int)g[l][a[i][r]]); if (a[i][l] == a[i][r]) tmp[l][r] = i; } f[l][r] = max(f[l][r], tmp[l][r]); ans = max(ans, (r - l + 1) * (i - f[l][r])); } for (int j = 1; j <= M; ++j) g[j][a[i][j]] = i; } cout << ans << endl; return 0; }
4
#include <bits/stdc++.h> const int MAXN = 150005; const int INF = 1500000; using namespace std; int n, a[MAXN]; vector<int> v; bool yes[MAXN]; int scan() { int t = 0, m = 1; char c; c = getchar(); while ((c < '0' || c > '9') and c != '-') c = getchar(); if (c == '-') c = getchar(), m = -1; while (c >= '0' && c <= '9') t = (t << 3) + (t << 1) + c - '0', c = getchar(); return (t * m); } bool judge(int x) { if (x < 1 || x == n) return true; if (x % 2 == 0 && a[x] > a[x + 1]) return true; if (x % 2 == 1 && a[x] < a[x + 1]) return true; return false; } int main() { n = scan(); for (int i = 1; i <= n; i++) a[i] = scan(); for (int i = 1; i <= n; i++) { if (!judge(i)) yes[i] = yes[i + 1] = true; } for (int i = 1; i <= n; i++) if (yes[i]) v.push_back(i); if (v.size() > 6) { cout << 0; return 0; } long long res = 0; for (int i = 1; i <= n; i++) if (yes[i]) for (int j = 1; j <= n; j++) { if (j > i || !yes[j]) { swap(a[i], a[j]); if (judge(i - 1) && judge(i) && judge(j - 1) && judge(j)) { for (int k = 0; k < v.size(); k++) if (!judge(v[k])) goto stop; res++; } stop: swap(a[i], a[j]); } } cout << res; return 0; }
3
#include <bits/stdc++.h> using namespace std; long long int mod = 998244353; using namespace std; long long int t, n, u, x, y; const long long int N = 100001; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); t = 1; cin >> t; while (t--) { cin >> n; long long int ans = -1; if (n % 2 == 0) { cout << n / 2 << " " << n / 2 << endl; continue; } for (long long int i = 2; i <= sqrt(n); ++i) { if (n % i == 0) { ans = n / i; break; } } if (ans == -1) cout << n - 1 << " " << 1 << endl; else cout << ans << " " << n - ans << endl; } }
2
// #pragma GCC target ("avx2") #pragma GCC optimization ("O3") // #pragma GCC optimization ("unroll-loops") #include<bits/stdc++.h> using namespace std; #define crap ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL) typedef long long int ll; typedef unsigned long long ull; #define int ll typedef std::vector<int> vi; typedef std::vector<ll> vll; typedef std::vector<vi > vvi; typedef std::vector<vll > vvll; typedef std::pair<int,int> ii; typedef std::pair<int, ii > iii; typedef std::pair< ll, ll > lp; typedef std::vector<ii> vii; typedef std::vector<vii > vvii; #define pb push_back #define PB pop_back #define pf push_front #define PF pop_front #define mp make_pair #define ub(a,b) upper_bound(all(a),b) #define lb(a,b) lower_bound(all(a),b) #define bs(a,b) binary_search(all(a),b) #define mem(a,b) memset(a,b,sizeof(a)) #define in(a,n) F(i,0,n-1)cin>>a[i] #define in1(a,n) F(i,1,n)cin>>a[i] #define out(a,n) F(i,0,n-1)cout<<a[i]<<" ";cout<<endl #define ff first #define ss second #define F(i,a,b) for (ll i=a;i<=b;i++) #define RF(i,a,b) for(ll i=a;i>=b;i--) #define rep(i,n) F(i,0,n-1) #define clr(a) (a).clear() #define rz resize #define sqr(a) ((a) * (a)) #define sz(a) int((a).size()) #define len(a) int((a).length()) #define all(a) (a).begin(), (a).end() #define rall(a) (a).rbegin() ,(a).rend() #define endl '\n' #define flush cout.flush() int mod; // #define mod (int)1e9+123 // #define mod LLONG_MAX // #define mod 998244353 // ################################## Debugging statements ################################## string to_string(string s) {return '"' + s + '"';} string to_string(const char* s) {return to_string((string) s);} string to_string(bool b) {return (b ? "true" : "false");} template <typename A, typename B> string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";} template <typename A> string to_string(A v) {bool first = true; string res = "{";for (const auto &x : v) {if (!first) { res += ", "; }first = false; res += to_string(x);}res += "}";return res;} void debug_out() { cerr << endl; } template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {cerr << " " << to_string(H);debug_out(T...);} #define TRACE // comment this out for submission #ifdef TRACE #define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__) #else #define debug(...) #endif // ########################################################################################### inline int add(int a, int b){a += b; if(a >= mod)a -= mod; return a;} inline int sub(int a, int b){a -= b; if(a < 0)a += mod; return a;} inline int mul(int a, int b){return (int)((long long) a * b %mod);} inline int poww(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = mul(res, a); a = mul(a, a);b /= 2;} return res;} inline int inv(int a){return poww(a, mod - 2);} int gcd(int a, int b, int &x, int &y){if(a == 0){x = 0, y = 1; return b;} int x1, y1; int d = gcd(b%a, a, x1, y1); x = y1 - (b/a) * x1; y = x1; return d;} // #################################### matrix operations #################################### inline vvi matmul(vvi A, vvi B) {int p = A.size(), q = A[0].size();int r = B.size(), s = B[0].size();assert(q == r);vvi C(p, vi(s, 0LL)); rep(i, p){rep(j, s){rep(k, q){ // C[i][j] += A[i][k] * B[k][j]; C[i][j] = add(C[i][j], mul(A[i][k], B[k][j])); }}}return C;} inline vvi matpow(vvi A, int n){int p = A.size(), q = A[0].size();assert(p == q);vvi res(p, vi(p, 0));rep(i, p)res[i][i] = 1;while (n){if (n&1)res = matmul(res, A);A = matmul(A, A);n >>= 1;}return res;} // ########################################################################################### // #################################### Combinatorics template ############################### struct factorial{ int N;int *fac;int *ifac; int *der; int MOD; factorial(int n, int m = 998244353){N = n;MOD = m;fac = new int[1+N];ifac = new int[1+N];der= new int[N+1];pre_calc(); calc_derangement();} int add(int a, int b){a += b; if(a >= MOD)a -= MOD; return a;} int subtract(int a, int b){a -= b; if(a < 0)a += MOD; return a;} int multiply(int a, int b){return (int)((long long) a * b %MOD);} int binpow(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = multiply(res, a); a = multiply(a, a);b /= 2;} return res;} int inverse(int a){return binpow(a, MOD - 2);} void pre_calc(){fac[0] = ifac[0] = 1;for (int i = 1 ; i <= N ; i++){fac[i] = multiply(fac[i-1], i);ifac[i] = multiply(ifac[i-1], inverse(i));}} int ncr(int n , int r){return multiply(fac[n], multiply(ifac[r], ifac[n-r]));} void calc_derangement(){ der[1] = 0;der[2] = 1; for (int i = 3; i <= N; i++){ der[i] = multiply(i-1, add(der[i-1], der[i-2])); } } int derangement(int n){ if (n == 1) return 1; return der[n]; } }; vi factors_n(int n){std::vector<int> fac;for (int i = 1; i * i <= n ; i++){if (n % i == 0){fac.push_back(i);if (i * i != n){fac.push_back(n/i);}}}return fac;} // ########################################################################################### // ##################################### Fenwick Tree template ############################### struct fenwick_tree{ int *bit;int n; fenwick_tree(){this->n = 200005;this->bit = new int[200005+1]; init_bit();} fenwick_tree(int n){this->n = n;this->bit = new int[n+1]; init_bit();} void init_bit(){for (int i=0; i <= this->n; i++)this->bit[i]=0;} void add(int i, int v){for (; i<=this->n; i+= i&-i){this->bit[i] = (this->bit[i] + v);}} int get(int i){int s = 0;for (; i; i -= i&-i){s = (this->bit[i] + s);}return s;} }; struct suffix_fenwick_tree{ int *bit;int n; suffix_fenwick_tree(){this->n = 200005;this->bit = new int[200005+1]; init_bit();} suffix_fenwick_tree(int n){this->n = n;this->bit = new int[n+1]; init_bit();} void init_bit(){for (int i=0; i <= this->n; i++)this->bit[i]=0;} void add(int i, int v){for (; i; i-= i&-i){this->bit[i] = (this->bit[i] + v);}} int get(int i){int s = 0;for (; i <= this->n; i += i&-i){s = (this->bit[i] + s);}return s;} }; // ########################################################################################### // ######################################## Policy-based DS ################################## // #include<ext/pb_ds/assoc_container.hpp> // using namespace __gnu_pbds; // template<class key, class value = null_type, class cmp = std::less<key>> // using ordered_tree = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>; // order_of_key (val): returns the no. of values less than val // find_by_order (k): returns the iterator to kth largest element.(0-based) // ########################################################################################### // ######################################## Bit manipulations ################################## int no_of_ones(int n){return __builtin_popcount(n);} int setmask(int mask, int i){return mask | (1 << i);} int unsetmask(int mask, int i){return (mask & !(1 << i));} // ########################################################################################### // ###################################### Convex Hull Trick ################################## // struct Line { // mutable ll k, m, p; // bool operator<(const Line& o) const { return k < o.k; } // bool operator<(ll x) const { return p < x; } // }; // struct LineContainer : multiset<Line, less<>> { // // (for doubles, use inf = 1/.0, div(a,b) = a/b) // const ll inf = LLONG_MAX; // ll div(ll a, ll b) { // floored division // return a / b - ((a ^ b) < 0 && a % b); } // bool isect(iterator x, iterator y) { // if (y == end()) { x->p = inf; return false; } // if (x->k == y->k) x->p = x->m > y->m ? inf : -inf; // else x->p = div(y->m - x->m, x->k - y->k); // return x->p >= y->p; // } // void add(ll k, ll m) { // y = k * x + m // auto z = insert({k, m, 0}), y = z++, x = y; // while (isect(y, z)) z = erase(z); // if (x != begin() && isect(--x, y)) isect(x, y = erase(y)); // while ((y = x) != begin() && (--x)->p >= y->p) // isect(x, erase(y)); // } // ll query(ll x) { // assert(!empty()); // auto l = *lower_bound(x); // return l.k * x + l.m; // } // }; // ########################################################################################### // ######################################## Disjoint Set ################################## // struct disjoint_sets{ // int n; // vector<int> par; // vector<int> ranks; // disjoint_sets(int _n):n(_n){ // for (int i = 0; i <= n; i++){ // par.emplace_back(i); // ranks.emplace_back(1); // } // } // int find_root(int u){// path compression // return (par[u] == u) ? u : (par[u] = find_root(par[u])); // } // void merge_node(int u, int v){ // u = find_root(u), v = find_root(v); // if (u == v) // return; // if (ranks[u] < ranks[v]) // swap(u, v); // par[v] = u; // ranks[u] += ranks[v]; // } // }; // ########################################################################################### int dx[] = {0, 0, 1, -1}; int dy[] = {1, -1, 0, 0}; // ################################### Template ends here #################################### void solve(){ int n; cin >> n; int a[1+n]; in1(a, n); fenwick_tree ft(6+n); F(i, 1, n){ if (a[i] == 0) continue; int l = max(1ll, i - a[i] + 1), r = i; ft.add(l, 1); ft.add(r+1, -1); } F(i, 1, n){ int val = 0; if (ft.get(i) > 0) val = 1; cout << val << " \n"[i==n]; } } void init(){ } void pre(){ } signed main(){ crap; int tt = 1; cin >> tt; int t0 = 1; pre(); while (tt--){ // cout<<"Case "<< t0++ <<": "; init(); solve(); } }
2
#include <bits/stdc++.h> using namespace std; template <typename T, typename U> inline void amin(T &x, U y) { if (y < x) x = y; } template <typename T, typename U> inline void amax(T &x, U y) { if (x < y) x = y; } long long powmod(long long a, long long b) { long long res = 1; a %= 1000000007; assert(b >= 0); for (; b; b >>= 1) { if (b & 1) res = res * a % 1000000007; a = a * a % 1000000007; } return res; } string s1, s2; long long n, m, q; long long dp[51][51]; long long t[50][3]; long long dp1[51][51][26]; long long dp2[51][51][26]; void pre() { memset(dp1, -1, sizeof(dp1)); memset(dp2, -1, sizeof(dp2)); for (int i = 1; i < n + 1; i++) { for (int j = 1; j < n - i + 2; j++) { long long st = j; long long en = i + j - 1; if (i == 1) dp1[st][en][(s1[st - 1] - 'a')] = 1; else { for (int k = st; k < en; k++) { for (int l = 0; l < q; l++) { if (dp1[st][k][t[l][0]] == 1 && dp1[k + 1][en][t[l][1]] == 1) dp1[st][en][t[l][2]] = 1; } } } } } for (int i = 1; i < m + 1; i++) { for (int j = 1; j < m - i + 2; j++) { long long st = j; long long en = i + j - 1; if (i == 1) dp2[st][en][(s2[st - 1] - 'a')] = 1; else { for (int k = st; k < en; k++) { for (int l = 0; l < q; l++) { if (dp2[st][k][t[l][0]] == 1 && dp2[k + 1][en][t[l][1]] == 1) dp2[st][en][t[l][2]] = 1; } } } } } } int main() { ios::sync_with_stdio(0); cin.tie(NULL); cin >> s1 >> s2; cin >> q; n = ((s1).size()); m = ((s2).size()); for (int i = 0; i < q; i++) { string temp; cin >> temp; t[i][0] = temp[3] - 'a'; t[i][1] = temp[4] - 'a'; t[i][2] = temp[0] - 'a'; } pre(); memset(dp, -1, sizeof(dp)); dp[0][0] = 0; for (int i = 1; i < n + 1; i++) { for (int j = 1; j < m + 1; j++) { for (int k = 0; k < i; k++) { for (int l = 0; l < j; l++) { if (dp[k][l] != -1) { long long temp = -1; for (int d = 0; d < 26; d++) { if (dp1[k + 1][i][d] == 1 && dp2[l + 1][j][d] == 1) temp = 1; } if (temp == 1) temp += dp[k][l]; if (temp != -1 && dp[i][j] != -1) amin(dp[i][j], temp); else if (temp != -1 && dp[i][j] == -1) dp[i][j] = temp; } } } } } cout << dp[n][m]; return 0; }
5
#include <bits/stdc++.h> using namespace std; inline char gc() { static char buf[100000], *p1 = buf, *p2 = buf; return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) ? EOF : *p1++; } inline long long read() { long long t = 0, f = 1; char c = getchar(); while (!isdigit(c)) { if (c == '-') f = -1; c = getchar(); } while (isdigit(c)) t = t * 10 + c - '0', c = getchar(); return t * f; } inline void write(long long x) { if (x < 0) { putchar('-'); write(-x); return; } if (x >= 10) write(x / 10); putchar(x % 10 + '0'); } inline void writeln(long long x) { write(x); puts(""); } inline void write_p(long long x) { write(x); putchar(' '); } const long long N = 650001; long long n, m, in[N], poi[N], nxt[N], head[N], dis[N], cnt[N], t, mx, st; inline void add(long long x, long long y) { poi[++t] = y; nxt[t] = head[x]; head[x] = t; in[x]++; poi[++t] = x; nxt[t] = head[y]; head[y] = t; in[y]++; } inline void Bfs(long long St) { bool ned = 0; if (!st) ned = 1; queue<long long> Q; memset(dis, 0, sizeof dis); dis[St] = 1; Q.push(St); while (!Q.empty()) { long long x = Q.front(); Q.pop(); if (ned) st = x; for (long long i = head[x]; i; i = nxt[i]) if (!dis[poi[i]]) dis[poi[i]] = dis[x] + 1, Q.push(poi[i]); } for (long long i = 1; i <= n; ++i) mx = max(mx, dis[i]); } signed main() { n = read(); m = read(); if (n <= 10000) if (n * (n - 1) / 2 == m) { puts("YES"); for (long long i = 1; i <= n; ++i) write_p(1); return 0; } for (long long i = 1; i <= m; ++i) add(read(), read()); Bfs(1); if (mx == 2) for (long long i = 1; i <= n; ++i) if (mx == dis[i] && in[i] != in[1]) st = i; Bfs(st); for (long long i = 1; i <= n; ++i) if (in[i] == in[st]) if (dis[i] == 2) dis[i] = 1; for (long long i = 1; i <= n; ++i) cnt[dis[i]]++; long long sum = 0; for (long long i = 1; i <= mx; ++i) sum += cnt[i] * (cnt[i] - 1) / 2; for (long long i = 1; i <= mx - 1; ++i) sum += cnt[i] * cnt[i + 1]; if (sum != m) { puts("NO"); exit(0); } puts("YES"); for (long long i = 1; i <= n; ++i) write_p(dis[i]); }
4
#include <bits/stdc++.h> using namespace std; template <class T> inline void read(T &a) { static char c; int f = 0; while (((c = getchar()) < '0' || c > '9') && (c != '-')) ; if (c == '-') { a = 0; f = 1; } else { a = c - '0'; } while ((c = getchar()) <= '9' && c >= '0') a = (a << 3) + (a << 1) + c - '0'; if (f) a = -a; } int a[100005], n, m; char s[10005]; int main() { int i, j, k, l, ans = 0; scanf("%s", s + 1); n = strlen(s + 1); for (i = 1; i <= n; i++) { for (j = i; j <= n; j++) { int tag = 1; for (k = i; k <= j; k++) { if (s[k] != s[i + j - k]) { tag = 0; break; } } if (!tag) ans = max(ans, j - i + 1); } } printf("%d\n", ans); return 0; }
1
#include <bits/stdc++.h> using namespace std; int32_t main() { long long int t; cin >> t; while (t--) { long long int n, m; cin >> n >> m; char arr[n][m]; for (long long int i = 0; i < n; i++) { for (long long int j = 0; j < m; j++) { cin >> arr[i][j]; } } long long int count = 0; for (long long int i = 0; i < n; i++) { if (arr[i][m - 1] == 'R') { count++; } } for (long long int j = 0; j < m; j++) { if (arr[n - 1][j] == 'D') { count++; } } cout << count << endl; } return 0; }
2
#include <bits/stdc++.h> using namespace std; long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } int main() { long long a, b, gc; long long ga, gb, gcc; cin >> a >> b; gc = gcd(a, b); gcc = a / gc * b; ga = gcc / a; gb = gcc / b; if (a < b) ga--; else if (a > b) gb--; if (ga > gb) cout << "Dasha" << endl; else if (ga < gb) cout << "Masha" << endl; else cout << "Equal" << endl; return 0; }
3
#include <bits/stdc++.h> using namespace std; int main() { int A,B; cin >> A >> B; cout<<(A+B-1)/B<<endl; }
0
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; string a[n]; for (int i = 0; i < n; i++) { cin >> a[i]; } int ans = 0; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < m - 1; j++) { int f1 = 0, a1 = 0, c1 = 0, e1 = 0; if (a[i][j] == 'f') f1++; if (a[i][j] == 'a') a1++; if (a[i][j] == 'c') c1++; if (a[i][j] == 'e') e1++; if (a[i][j + 1] == 'f') f1++; if (a[i][j + 1] == 'a') a1++; if (a[i][j + 1] == 'c') c1++; if (a[i][j + 1] == 'e') e1++; if (a[i + 1][j] == 'f') f1++; if (a[i + 1][j] == 'a') a1++; if (a[i + 1][j] == 'c') c1++; if (a[i + 1][j] == 'e') e1++; if (a[i + 1][j + 1] == 'f') f1++; if (a[i + 1][j + 1] == 'a') a1++; if (a[i + 1][j + 1] == 'c') c1++; if (a[i + 1][j + 1] == 'e') e1++; if (f1 == 1 && a1 == 1 && c1 == 1 && e1 == 1) { ans++; } } } cout << ans << endl; return 0; }
1
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; int arr[3]; while (t--) { cin >> arr[0] >> arr[1] >> arr[2]; sort(arr, arr + 3); if (arr[0] + arr[1] >= arr[2] - 1) cout << "Yes\n"; else cout << "No\n"; } }
1
#include <bits/stdc++.h> using namespace std; const long long int MOD = 998244353; long long int fpow(long long int a, long long int k) { long long int r = 1; long long int t = a; while (k) { if (k & 1) { r = r * t % MOD; } t = t * t % MOD; k >>= 1; } return r; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); string s; cin >> s; int n = s.size(); vector<vector<long long int>> dp(n, vector<long long int>(n)); vector<long long int> f(n + 1); for (int i = 0; i < n; i++) { f[i + 1] = f[i]; f[i + 1] += s[i] == '?'; } for (int len = 2; len <= n; len++) { for (int i = 0; i < n - len + 1; i++) { int j = i + len - 1; if (s[i] != '(') { dp[i][j] += dp[i + 1][j]; dp[i][j] %= MOD; } if (s[j] != ')') { dp[i][j] += dp[i][j - 1]; dp[i][j] %= MOD; } if (s[i] != '(' && s[j] != ')') { dp[i][j] -= dp[i + 1][j - 1]; dp[i][j] += MOD; dp[i][j] %= MOD; } if (s[i] != ')' && s[j] != '(') { dp[i][j] += dp[i + 1][j - 1]; dp[i][j] %= MOD; dp[i][j] += fpow((long long int)2, (long long int)(f[j] - f[i + 1])); dp[i][j] %= MOD; } } } cout << dp[0][n - 1] << '\n'; return 0; }
4
#include <bits/stdc++.h> using namespace std; int main() { char keyboard[100] = "qwertyuiopasdfghjkl;zxcvbnm,./"; char x[101]; char d; cin >> d >> x; if (d == 'L') { for (int i = 0; i < strlen(x); i++) { for (int j = 0; j < strlen(keyboard); j++) { if (x[i] == keyboard[j]) { cout << keyboard[j + 1]; break; } } } } else { for (int i = 0; i < strlen(x); i++) { for (int j = 0; j < strlen(keyboard); j++) { if (x[i] == keyboard[j]) { cout << keyboard[j - 1]; break; } } } } }
1
#include <bits/stdc++.h> using namespace std; const int MAXN = 2e5 + 5; const int dx[6] = {1, -1, 0, 0, 0, 0}; const int dy[6] = {0, 0, 1, -1, 0, 0}; const int dz[6] = {0, 0, 0, 0, 1, -1}; template <typename T> void chkmax(T &x, T y) { x = max(x, y); } template <typename T> void chkmin(T &x, T y) { x = min(x, y); } template <typename T> void read(T &x) { x = 0; int f = 1; char c = getchar(); for (; !isdigit(c); c = getchar()) if (c == '-') f = -f; for (; isdigit(c); c = getchar()) x = x * 10 + c - '0'; x *= f; } int n, m, t, l, r; int bx[MAXN], by[MAXN], bz[MAXN]; vector<vector<int>> b[6]; vector<vector<vector<int>>> a; vector<vector<vector<vector<bool>>>> vis; void Make(vector<vector<int>> &b, int n, int m) { b.resize(n + 2); for (int i = 0; i <= n + 1; i++) b[i].resize(m + 2); } bool inside(int x, int y, int z) { return 1 <= x && x <= n && 1 <= y && y <= m && 1 <= z && z <= t; } void add(int x, int y, int z, int d, int v) { assert(!vis[x][y][z][d]); vis[x][y][z][d] = true; if (a[x][y][z] == 0) return; if (v == 0) { r++, a[x][y][z] = 0; bx[r] = x, by[r] = y, bz[r] = z; } else if (a[x][y][z] == -1 || a[x][y][z] == v) a[x][y][z] = v; else { r++, a[x][y][z] = 0; bx[r] = x, by[r] = y, bz[r] = z; } } int main() { read(n), read(m), read(t), l = 1; a.resize(n + 2), vis.resize(n + 2); for (int i = 0; i <= n + 1; i++) { a[i].resize(m + 2); vis[i].resize(m + 2); for (int j = 0; j <= m + 1; j++) { a[i][j].resize(t + 2); vis[i][j].resize(t + 2); for (int k = 0; k <= t + 1; k++) vis[i][j][k].resize(6); } } for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) for (int k = 1; k <= t; k++) a[i][j][k] = -1; Make(b[0], m, t); Make(b[1], m, t); Make(b[2], n, t); Make(b[3], n, t); Make(b[4], n, m); Make(b[5], n, m); for (int i = 1; i <= m; i++) for (int j = 1; j <= t; j++) { read(b[0][i][j]); add(1, i, j, 0, b[0][i][j]); } for (int i = 1; i <= m; i++) for (int j = 1; j <= t; j++) { read(b[1][i][j]); add(n, i, j, 1, b[1][i][j]); } for (int i = 1; i <= n; i++) for (int j = 1; j <= t; j++) { read(b[2][i][j]); add(i, 1, j, 2, b[2][i][j]); } for (int i = 1; i <= n; i++) for (int j = 1; j <= t; j++) { read(b[3][i][j]); add(i, m, j, 3, b[3][i][j]); } for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { read(b[4][i][j]); add(i, j, 1, 4, b[4][i][j]); } for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { read(b[5][i][j]); add(i, j, t, 5, b[5][i][j]); } while (l <= r) { for (int i = 0; i <= 5; i++) { int x = bx[l], y = by[l], z = bz[l], v = 0; if (i <= 1) v = b[i][y][z]; else if (i <= 3) v = b[i][x][z]; else v = b[i][x][y]; if (vis[x][y][z][i]) { while (inside(x, y, z) && a[x][y][z] == 0) { x += dx[i]; y += dy[i]; z += dz[i]; } if (!inside(x, y, z)) { if (v != 0) { puts("-1"); return 0; } } else add(x, y, z, i, v); } } l++; } for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { for (int k = 1; k <= t; k++) printf("%d ", max(a[i][j][k], 0)); printf("\n"); } printf("\n"); } return 0; }
6
#include <bits/stdc++.h> using namespace std; const int maxn = 2000000 + 1, mod = 1000000007; int n; long long dp[maxn] = {}; int main() { int T; scanf("%d", &T); for (int i = 3; i < maxn; ++i) dp[i] = (dp[i - 1] + dp[i - 2] * 2 + (!(i % 3) ? 4 : 0)) % mod; while (T--) { scanf("%d", &n); printf("%d\n", dp[n]); } return 0; }
4
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; struct OP { double flag; int st, ed, lft; OP() {} OP(int a, int b, double c, int d) { st = a; ed = b; flag = c; lft = d; } }; struct node { double P; int lft, rht, flag; void fun(double tmp) { P *= tmp; flag = 1; } }; int B[N], Z[N]; vector<OP> op; vector<int> Y; map<int, int> H; struct Segtree { node tree[N * 4 * 4]; void Pushdown(int rt) { if (tree[rt].flag) { tree[rt << 1].fun(tree[rt].P); tree[rt << 1 | 1].fun(tree[rt].P); tree[rt].flag = 0; tree[rt].P = 1; } } void build(int l, int r, int rt) { tree[rt].lft = l; tree[rt].rht = r; tree[rt].P = 1; tree[rt].flag = 0; if (l == r) return; int m = (l + r) >> 1; build(l, m, rt << 1); build(m + 1, r, rt << 1 | 1); } void update(int L, int R, int rt, double tmp) { int l = tree[rt].lft; int r = tree[rt].rht; if (L <= l && r <= R) tree[rt].fun(tmp); else { Pushdown(rt); int m = (l + r) >> 1; if (L <= m) update(L, R, rt << 1, tmp); if (R > m) update(L, R, rt << 1 | 1, tmp); } } double query(int pos, int rt) { int l = tree[rt].lft; int r = tree[rt].rht; if (l == r) return tree[rt].P; else { Pushdown(rt); int m = (l + r) >> 1; if (pos <= m) return query(pos, rt << 1); else return query(pos, rt << 1 | 1); } } } seg; int main() { int n, m; int i, j, k; while (~scanf("%d %d", &n, &m)) { Y.clear(); op.clear(); H.clear(); for (i = 0; i < n; i++) { int a, b, c, d; scanf("%d %d %d %d", &a, &b, &c, &d); Y.push_back(a - b); Y.push_back(a + b); Y.push_back(a); op.push_back(OP(a - b, a, (100 - c) / 100.0, 1)); op.push_back(OP(a, a + b, (100 - d) / 100.0, 0)); } for (i = 0; i < m; i++) { scanf("%d %d", &B[i], &Z[i]); Y.push_back(B[i]); } sort(Y.begin(), Y.end()); Y.erase(unique(Y.begin(), Y.end()), Y.end()); for (i = 0; i < Y.size(); i++) H[Y[i]] = i; seg.build(0, Y.size() - 1, 1); for (i = 0; i < op.size(); i++) { if (op[i].lft) seg.update(H[op[i].st], H[op[i].ed] - 1, 1, op[i].flag); else seg.update(H[op[i].st] + 1, H[op[i].ed], 1, op[i].flag); } double ans = 0; for (i = 0; i < m; i++) { ans += Z[i] * seg.query(H[B[i]], 1); } printf("%.4f\n", ans); } return 0; }
5
#include <bits/stdc++.h> using namespace std; const int Mod = 1e9 + 7; int add(int a, int b) { return a + b >= Mod ? a + b - Mod : a + b; } int dec(int a, int b) { return a - b < 0 ? a - b + Mod : a - b; } int mul(int a, int b) { return 1ll * a * b % Mod; } void Add(int &a, int b) { a = add(a, b); } void Dec(int &a, int b) { a = dec(a, b); } void Mul(int &a, int b) { a = mul(a, b); } const int N = 1e5 + 50; int n, a[N], pr[N], sf[N]; map<int, int> bin; struct lll { int a, b, c, bc, ac; }; lll operator+(const lll &x, const lll &y) { return (lll){add(x.a, y.a), add(x.b, y.b), add(x.c, y.c), add(x.bc, y.bc), add(x.ac, y.ac)}; } namespace SGT { const int N = ::N << 2; lll t[N]; int tb[N]; int tc[N]; int tbc[N]; int len[N]; void up(int x) { t[x] = t[x << 1] + t[x << 1 | 1]; } void build(int x, int l, int r) { len[x] = r - l + 1; if (l == r) return t[x].a = l - 1, void(); build(x << 1, l, ((l + r) >> 1)); build(x << 1 | 1, ((l + r) >> 1) + 1, r); up(x); } void B(int x, int v) { Add(tb[x], v); Add(t[x].b, mul(len[x], v)); Add(t[x].bc, mul(v, t[x].c)); Add(tbc[x], mul(v, tc[x])); } void C(int x, int v) { Add(tc[x], v); Add(t[x].c, mul(len[x], v)); Add(t[x].bc, mul(v, t[x].b)); Add(tbc[x], mul(v, tb[x])); Add(t[x].ac, mul(v, t[x].a)); } void BC(int x, int v) { Add(t[x].bc, v); Add(tbc[x], v); } void down(int x) { if (tb[x]) B(x << 1, tb[x]), B(x << 1 | 1, tb[x]), tb[x] = 0; if (tc[x]) C(x << 1, tc[x]), C(x << 1 | 1, tc[x]), tc[x] = 0; if (tbc[x]) BC(x << 1, tbc[x]), BC(x << 1 | 1, tbc[x]), tbc[x] = 0; } void mdfb(int x, int l, int r, int L, int R, int v) { if (L <= l && r <= R) return B(x, v); down(x); if (L <= ((l + r) >> 1)) mdfb(x << 1, l, ((l + r) >> 1), L, R, v); if (R > ((l + r) >> 1)) mdfb(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R, v); up(x); } void mdfc(int x, int l, int r, int L, int R, int v) { if (L <= l && r <= R) return C(x, v); down(x); if (L <= ((l + r) >> 1)) mdfc(x << 1, l, ((l + r) >> 1), L, R, v); if (R > ((l + r) >> 1)) mdfc(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R, v); up(x); } lll ask(int x, int l, int r, int L, int R) { if (L > R) return (lll){0}; if (L <= l && r <= R) return t[x]; down(x); if (R <= ((l + r) >> 1)) return ask(x << 1, l, ((l + r) >> 1), L, R); if (L > ((l + r) >> 1)) return ask(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R); return ask(x << 1, l, ((l + r) >> 1), L, R) + ask(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R); } } // namespace SGT int main() { cin >> n; for (int i = 1; i <= n; i++) scanf("%d", &a[i]); for (int i = 1; i <= n; i++) { pr[i] = bin[a[i]]; bin[a[i]] = i; } bin.clear(); for (int i = n; i; i--) { sf[i] = bin[a[i]]; bin[a[i]] = i; if (!sf[i]) sf[i] = n + 1; } SGT ::build(1, 1, n); static int s1[N], s2[N]; int t1 = 0, t2 = 0, mx = 0, ans = 0; for (int i = 1; i <= n; i++) { mx = max(mx, pr[i]); while (t1 && pr[s1[t1]] <= pr[i]) { int h = dec(pr[i], pr[s1[t1]]); SGT ::mdfb(1, 1, n, s1[t1 - 1] + 1, s1[t1], h); --t1; } while (t2 && sf[s2[t2]] >= sf[i]) { int h = dec(sf[i], sf[s2[t2]]); SGT ::mdfc(1, 1, n, s2[t2 - 1] + 1, s2[t2], h); --t2; } s1[++t1] = i, s2[++t2] = i; SGT ::mdfb(1, 1, n, i, i, pr[i]); SGT ::mdfc(1, 1, n, i, i, sf[i]); lll z = SGT ::ask(1, 1, n, mx + 1, i); Dec(ans, z.bc); Dec(ans, mul(i + 1, z.a)); Add(ans, mul(i + 1, z.b)); Add(ans, z.ac); } cout << ans << '\n'; return 0; }
4
#include <bits/stdc++.h> using namespace std; template <typename Arg1> void __f(const char* name, Arg1&& arg1) { std::cerr << name << " : " << arg1 << endl; } template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) { const char* comma = strchr(names + 1, ','); std::cerr.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...); } long long int ar[100010]; long long int chk(long long int num) { if (num == 1) { if (ar[num]) { return ar[num]; } else { ar[num] = num; return -100; } } std::vector<long long int> v; for (long long int i = 2; i <= sqrt(num); i++) { if (num % i == 0) { if (num % i == i) { v.push_back(i); if (ar[i]) { return ar[i]; } } else { v.push_back(i); v.push_back(num / i); if (ar[i]) { return ar[i]; } if (ar[num / i]) { return ar[num / i]; } } } } if (ar[num]) { return ar[num]; } else { v.push_back(num); } for (long long int i = 0; i < v.size(); i++) { ar[v[i]] = num; } return -100; } long long int remove(long long int num) { if (num == 1) { ar[num] = 0; return 0; } std::vector<long long int> v; for (long long int i = 2; i <= sqrt(num); i++) { if (num % i == 0) { if (num % i == i) { v.push_back(i); } else { v.push_back(i); v.push_back(num / i); } } } v.push_back(num); for (long long int i = 0; i < v.size(); i++) { ar[v[i]] = 0; } return 0; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long int T = 1; while (T--) { long long int n, m; cin >> n >> m; for (long long int j = 0; j < m; j = j + 1) { string s; long long int k; cin >> s; cin >> k; if (s[0] == '+') { if (ar[k] == k) { cout << "Already on" << "\n"; continue; } long long int z = chk(k); if (z == -100) { cout << "Success" << "\n"; } else { cout << "Conflict with " << z << "\n"; } } else { if (ar[k] == k) { cout << "Success" << "\n"; remove(k); } else { cout << "Already off" << "\n"; } } } } return 0; }
2
#include <bits/stdc++.h> using namespace std; struct s { int data; int sum; int xu; } a[101]; bool cmp1(s a, s b) { return a.data < b.data; } bool cmp2(s a, s b) { return a.xu < b.xu; } int main() { int n, w; int sum_1 = 0, sum_2 = 0; scanf("%d%d", &n, &w); for (int i = 0; i < n; i++) { scanf("%d", &a[i].data); a[i].xu = i; } sort(a, a + n, cmp1); for (int i = 0; i < n; i++) { sum_1 += a[i].data; } if (sum_1 < w || w < sum_1 / 2) { printf("-1\n"); return 0; } else { for (int i = 0; i < n; i++) { if (a[i].data % 2 == 0) { a[i].sum = a[i].data / 2; sum_2 += a[i].data / 2; } else { a[i].sum = a[i].data / 2 + 1; sum_2 += a[i].data / 2 + 1; } } } if (sum_2 > w) { printf("-1\n"); return 0; } else if (sum_2 == w) { sort(a, a + n, cmp2); for (int i = 0; i < n; i++) { if (i == n - 1) { printf("%d\n", a[i].sum); break; } printf("%d ", a[i].sum); } } else { int x = w - sum_2; for (int i = n - 1; i >= 0; i--) { while (a[i].sum != a[i].data) { a[i].sum++; x--; if (x == 0) break; } if (x == 0) break; } sort(a, a + n, cmp2); for (int i = 0; i < n; i++) { if (i == n - 1) { printf("%d\n", a[i].sum); break; } printf("%d ", a[i].sum); } } return 0; }
3
#include <bits/stdc++.h> using namespace std; int main() { int n, i; cin >> n; int arr[n]; for (i = 0; i < n; i++) { cin >> arr[i]; } int o = sizeof(arr) / sizeof(arr[0]); sort(arr, arr + o); for (i = 0; i < n; i++) { cout << arr[i] << endl; } }
1
#include <bits/stdc++.h> using namespace std; void err(istream_iterator<string> it) {} template <typename T, typename... Args> void err(istream_iterator<string> it, T a, Args... args) { cerr << *it << " = " << a << '\n'; err(++it, args...); } int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); long long int n, m; cin >> n; string str, str1; long long cnt[26] = {0}; bool a[26] = {false}, vis[26] = {false}; cin >> str; vector<string> s; for (long long i = 0; i < n; i++) { if (str[i] != '*') { a[str[i] - 'a'] = true; } } cin >> m; for (long long i = 0; i < m; i++) { cin >> str1; long long t = 0; for (long long j = 0; j < n; j++) { if (str[j] != '*') { if (str[j] != str1[j]) t = 1; } else { if (a[str1[j] - 'a']) t = 1; } } if (!t) s.push_back(str1); } for (auto it : s) { for (long long i = 0; i < 26; i++) { vis[i] = false; } for (long long i = 0; i < n; i++) { if (str[i] == '*' && !vis[it[i] - 'a']) { cnt[it[i] - 'a']++, vis[it[i] - 'a'] = 1; } } } long long ans = 0; for (long long i = 0; i < 26; i++) { if (cnt[i] == s.size()) ans++; } cout << ans; return 0; }
5
#include <bits/stdc++.h> using namespace std; vector<pair<pair<long long, long long>, pair<long long, long long> > > vc; long long n, dp[109][2009], path[109][2009]; long long maximum(long long ind, long long time) { if (ind > n) return 0; if (~dp[ind][time]) return dp[ind][time]; long long ret1 = maximum(ind + 1, time); long long ret2 = -1; if (time + vc[ind].second.first < vc[ind].first.first) ret2 = vc[ind].second.second + maximum(ind + 1, time + vc[ind].second.first); if (ret1 > ret2) path[ind][time] = 1; else path[ind][time] = 0; return dp[ind][time] = max(ret1, ret2); } int main() { long long t, d, p; cin >> n; memset(dp, -1, sizeof dp); memset(path, -1, sizeof path); vc.push_back({{-1, -1}, {-1, -1}}); for (long long i = 1; i <= n; i++) { cin >> t >> d >> p; vc.push_back({{d, i}, {t, p}}); } sort(vc.begin(), vc.end()); cout << maximum(1, 0) << endl; vector<long long> vv; long long ind = 1, time = 0; while (ind <= n) { if (path[ind][time] == 0) { vv.push_back(vc[ind].first.second); time += vc[ind].second.first; } ind++; } cout << vv.size() << endl; for (long long i = 0; i < vv.size(); i++) cout << vv[i] << " "; return 0; }
5
#include <bits/stdc++.h> using namespace std; bool zero(double x) { return fabs(x) <= 1e-8; } int sign(double x) { if (zero(x)) return 0; if (x > 0) return 1; return -1; } struct point { double x, y; double tht; point(double xx = 0.0, double yy = 0.0) { x = xx; y = yy; } void input() { scanf("%lf%lf", &x, &y); } point operator-(const point &b) { return point(x - b.x, y - b.y); } point operator+(const point &b) { return point(x + b.x, y + b.y); } double operator^(const point &b) { return x * b.y - y * b.x; } double operator*(const point &b) { return x * b.x + y * b.y; } }; double dist(point p1, point p2) { return sqrt((p1 - p1) * (p1 - p2)); } double dist2(point p1, point p2) { return (p1 - p2) * (p1 - p2); } bool cmp1(point a, point b) { if (a.y == b.y) return a.x < b.x; return a.y < b.y; } point ttt; bool cmp2(point a, point b) { if (zero(a.tht - b.tht)) return dist2(ttt, a) < dist2(ttt, b); return a.tht < b.tht; } point tubao[100050]; int tbnum; void gettubao(vector<point> p) { int siz = p.size(); memset(tubao, 0, sizeof(tubao)); sort(p.begin(), p.end(), cmp1); for (int i = 1; i < siz; i++) p[i].tht = atan2(p[i].y - p[0].y, p[i].x - p[0].x); ttt = p[0]; sort(++p.begin(), p.end(), cmp2); if (siz == 1) { tbnum = 1; tubao[0] = p[0]; return; } else if (siz == 2) { tbnum = 2; tubao[0] = p[0]; tubao[1] = p[1]; return; } tbnum = 2; tubao[0] = p[0]; tubao[1] = p[1]; for (int i = 2; i < siz; i++) { while (tbnum > 1) { if (((tubao[tbnum - 1] - tubao[tbnum - 2]) ^ (p[i] - tubao[tbnum - 2])) <= 1e-8) { tbnum--; } else break; } tubao[tbnum++] = p[i]; } } vector<point> vec; int dots_inline(point p1, point p2, point p3) { return zero((p2 - p1) ^ (p3 - p1)); } int dot_online_in(point p, point l1, point l2) { return ((l1 - p) * (l2 - p)) <= 1e-8; } int same_side(point p1, point p2, point l1, point l2) { return (((p1 - l1) ^ (l2 - l1)) * ((p2 - l1) ^ (l2 - l1))) > 1e-8; } int intersect_in(point u1, point u2, point v1, point v2) { if (!dots_inline(u1, u2, v1) || !dots_inline(u1, u2, v2)) return !same_side(u1, u2, v1, v2) && !same_side(v1, v2, u1, u2); return dot_online_in(u1, v1, v2) || dot_online_in(u2, v1, v2) || dot_online_in(v1, u1, u2) || dot_online_in(v2, u1, u2); } struct xishu { double a, b, c; }; xishu getline(point x, point y) { struct xishu w; w.a = y.y - x.y; w.b = x.x - y.x; w.c = y.x * x.y - x.x * y.y; return w; } point getnode(xishu l1, xishu l2) { point CrossP; CrossP.x = (l1.c * l2.b - l1.b * l2.c) / (l1.a * l2.b - l1.b * l2.a) * (-1.0); CrossP.y = (l1.c * l2.a - l1.a * l2.c) / (l1.b * l2.a - l1.a * l2.b) * (-1.0); return CrossP; } int main() { int n, p, q; scanf("%d%d%d", &n, &p, &q); double maxx = 0, maxy = 0; for (int i = 0; i < n; i++) { point p; p.input(); maxx = ((maxx) > (p.x) ? (maxx) : (p.x)); maxy = ((maxy) > (p.y) ? (maxy) : (p.y)); vec.push_back(p); } vec.push_back(point(maxx, 0)); vec.push_back(point(0, maxy)); vec.push_back(point(0, 0)); gettubao(vec); for (int i = 1; i < tbnum; i++) { point p1 = point(0, 0); point p2 = point(p, q); if (sign(((p2 - p1) ^ (tubao[i] - p1)) * ((p2 - p1) ^ (tubao[(i + 1) % tbnum] - p1))) <= 0) { xishu l1 = getline(point(0, 0), point(p, q)); xishu l2 = getline(tubao[i], tubao[(i + 1) % tbnum]); point ans = getnode(l1, l2); printf("%.16f\n", p / ans.x); return 0; } } return 0; }
3
#include <bits/stdc++.h> using namespace std; const int N=120; int a[N]; int n,u,v; int solve() { bool allsame = true; for (int i = 1; i < n; i++) { if (abs(a[i]-a[i-1]) > 1) return 0; if (a[i] != a[i-1]) allsame = false; } if (allsame) return min(2*v,u+v); return min(u,v); } int main() { int q; scanf("%d", &q); while (q--) { scanf("%d%d%d", &n, &u, &v); for (int i = 0; i < n; i++) { scanf("%d", a+i); } printf("%d\n", solve()); } }
2
#include <cstdio> #include <vector> #include <algorithm> #include <iostream> #include <cstdio> #include <tuple> #include <utility> #include <queue> using namespace std; using AnsType = long long int; const AnsType INF = 1LL << 60; int pow3[10]; int get_digit(int val, int k) { val /= pow3[k]; return val % 3; } string tri_to_string(int val, int lim) { string res = ""; for(int i=0; i<lim; i++) { res += (char)('0' + get_digit(val, i)); } return res; } int modify_digit(int bit, int k, int val) { int b = get_digit(bit, k); bit -= pow3[k] * b; bit += pow3[k] * val; return bit; } struct Elem { int pos, bit; AnsType cost; Elem() {} Elem(int a, int b, AnsType c) : pos(a), bit(b), cost(c) {} bool operator<(const Elem &e) const { return cost > e.cost; } }; using Graph = vector< vector< pair<int, int> > >; int main() { int N, M, K, P; cin >> N >> M >> K >> P; P--; Graph G(N); for(int i=0; i<M; i++) { int x, y, m; cin >> x >> y >> m; x--; y--; G[x].emplace_back(y, m); G[y].emplace_back(x, m); } vector< vector<int> > S(N), T(N); for(int i=0; i<K; i++) { int s, t; cin >> s >> t; s--; t--; S[s].emplace_back(i); T[t].emplace_back(i); } pow3[0] = 1; for(int i=1; i<=K; i++) pow3[i] = pow3[i-1] * 3; int fullbit = pow3[K] - 1; priority_queue<Elem> que; vector< vector<AnsType> > dist(N, vector<AnsType>(pow3[K], INF)); dist[P][0] = 0; que.emplace(P, 0, 0); while(que.size()) { auto cur = que.top(); que.pop(); int pos = cur.pos, bit = cur.bit; AnsType d = cur.cost; if(d > dist[pos][bit]) continue; // fprintf(stderr, "pos = %d, bit = %s, d = %lld\n", pos + 1, tri_to_string(bit, K).c_str(), d); { int nbit = bit; for(auto s : S[pos]) { int v = get_digit(nbit, s); if(v != 0) continue; nbit = modify_digit(nbit, s, v + 1); } for(auto t : T[pos]) { int v = get_digit(nbit, t); if(v != 1) continue; nbit = modify_digit(nbit, t, v + 1); } if(dist[pos][nbit] > d) { dist[pos][nbit] = d; que.emplace(pos, nbit, d); } } for(auto e : G[pos]) { int to, c; tie(to, c) = e; // fprintf(stderr, "e: to = %d, c = %d\n", to, c); int nbit = bit; if(dist[to][nbit] > d + c) { // fprintf(stderr, "cur = %d, to = %d\n", pos, to); dist[to][nbit] = d + c; que.emplace(to, nbit, d + c); } } } AnsType ans = INF; for(int i=0; i<N; i++) { ans = min(ans, dist[i][fullbit]); } if(ans == INF) cout << "Cannot deliver" << endl; else cout << ans << endl; return 0; }
0
#include <bits/stdc++.h> using namespace std; template <class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; } template <class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; } const int maxn = 2 * (int)1e5 + 1000; int n, m, tot = 1, fa[maxn], vis[maxn], in[maxn], out[maxn], pa[maxn], dep[maxn]; vector<vector<int> > g(maxn); int find_root(int x) { if (x == fa[x]) return fa[x]; else { return fa[x] = find_root(fa[x]); } } void uni_root(int a, int b) { int aa = find_root(a); int bb = find_root(b); if (aa != bb) { fa[bb] = aa; } } bool belong(int a, int b) { if (in[a] <= in[b] && out[b] <= out[a]) return true; return false; } void dfs(int u, int par) { in[u] = tot++; if (par) pa[u] = par; if (par) dep[u] = dep[par] + 1; for (int to : g[u]) { if (to == par) continue; dfs(to, u); } out[u] = tot; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cout.precision(10); cout << fixed; cin >> n >> m; for (int i = 1; i <= (int)(n); ++i) pa[i] = i; for (int i = 0; i < (int)(n - 1); ++i) { int u, v; cin >> u >> v; g[u].emplace_back(v); g[v].emplace_back(u); } memset(vis, 0, sizeof(vis)); memset(dep, 0, sizeof(dep)); dfs(1, 0); for (int i = 0; i < (int)(m); ++i) { bool ok = true; int k; cin >> k; vector<pair<int, int> > v(k); for (int i = 0; i < (int)(k); ++i) { int x; cin >> x; v[i] = {dep[x], x}; } sort((v).begin(), (v).end()); int leaf = v[k - 1].second; for (int i = 0; i < k - 1; ++i) { v[i].second = pa[v[i].second]; } for (int i = 0; i < k - 1; ++i) { if (!belong(v[i].second, leaf)) { ok = false; break; } } cout << (ok ? "YES" : "NO") << '\n'; } return 0; }
5
#include <bits/stdc++.h> #define inf 100000000 using namespace std; int main(){ int simen[200]={}; for(int i=0;i<200;i++)simen[i] = (i+1) * (i+2) * (i+3) / 6; int dp[1000005], kisudp[1000005]; for(int i=0;i<1000005;i++){dp[i] = inf; kisudp[i] = inf;} dp[0]=0;kisudp[0]=0; for(int k=0;k<200;k++)for(int i=1;i<1000005;i++){ if(i >= simen[k])dp[i] = min(dp[i], dp[i-simen[k]] + 1); } for(int k=0;k<200;k++)for(int i=1;i<1000005;i++){ if(i >= simen[k] && simen[k]%2 == 1)kisudp[i] = min(kisudp[i], kisudp[i-simen[k]] + 1); } while(1){ int N; scanf("%d", &N); if(N==0)break; else printf("%d %d\n", dp[N], kisudp[N]); } return 0; }
0
#include <bits/stdc++.h> using namespace std; template <class T> inline bool fs(T &x) { int c = getchar(); int sgn = 1; while (~c && c < '0' || c > '9') { if (c == '-') sgn = -1; c = getchar(); } for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0'; x *= sgn; return ~c; } int parent[200005]; int mark[200005]; void initializeSet(int n) { for (int i = 1; i <= n; i++) parent[i] = i; } int findParent(int x) { if (x == parent[x]) return x; else return parent[x] = findParent(parent[x]); } int unionSet(int x, int y) { int px = findParent(x); int py = findParent(y); if (px == py) return 1; else parent[py] = px; return 0; } int main() { int n, m, cnt = 0, a, b; vector<pair<int, int> > v; cin >> n >> m; initializeSet(n); for (int i = 0; i < m; i++) { cin >> a >> b; mark[a]++; mark[b]++; v.push_back(make_pair(a, b)); } for (int i = 0; i < m; i++) { a = v[i].first; b = v[i].second; if (mark[a] == 2 && mark[b] == 2) cnt += unionSet(a, b); } cout << cnt << endl; return 0; }
5
#include <bits/stdc++.h> using namespace std; int main() { long long n, m, a, b, i; cin >> n >> m; vector<pair<long long, long long> > v; for (i = 0; i < n; i++) { cin >> a >> b; v.push_back({a, b}); } if (v[0].first != 0) { cout << "NO"; return 0; } long long start = 0, end = 0; for (i = 0; i < n - 1; i++) { start = v[i + 1].first; if (v[i].second > end) end = v[i].second; if (start > end) { cout << "NO"; return 0; } } for (i = 0; i < n; i++) { if (v[i].second == m) { cout << "YES"; return 0; } } cout << "NO"; }
1
#include <bits/stdc++.h> using namespace std; int N, D, A, B, Q, op, p, v; int tree[2][200100], lo[200100], hi[200100]; void update(int *Tree, int p, int v) { assert(p > 0); while (p < 200100) { Tree[p] += v; p += p & -p; } } int query(int *Tree, int p) { int ret = 0; while (p > 0) { ret += Tree[p]; p -= p & (-p); } return ret; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> N >> D >> A >> B >> Q; for (int q = 0; q < Q; q++) { cin >> op; if (op == 1) { cin >> p >> v; int lo2 = min(B, lo[p] + v); update(tree[0], p, lo2 - lo[p]); lo[p] = lo2; int hi2 = min(A, hi[p] + v); update(tree[1], p, hi2 - hi[p]); hi[p] = hi2; } else { cin >> p; cout << query(tree[0], p - 1) + query(tree[1], N) - query(tree[1], p + D - 1) << "\n"; } } }
3
#include<bits/stdc++.h> using namespace std; int a[2000][2000]={}; int main(){ int n,f; //int a[2000][2000]={}; map<string,int> M; map<int,string> MD; set<string> S; int c=0; int count=0; cin>>n>>f; for(int i=0;i<n;i++){ int m; cin>>m; vector<string> st; for(int t=0;t<m;t++){ string s; cin>>s; st.push_back(s); if(S.find(s)==S.end()){S.insert(s); MD[count]=s; M[s]=count; count++;} for(int h=0;h<st.size()-1;h++){ a[M[s]][M[st[h]]]++; a[M[st[h]]][M[s]]++; if(a[M[st[h]]][M[s]]==f){c++;} } } } cout<<c<<endl; for(set<string>::iterator i=S.begin();i!=S.end();i++){ for(set<string>::iterator t=i;t!=S.end();t++){ if(a[M[(*i)]][M[(*t)]]>=f){ cout<<(*i)<<" "<<(*t)<<endl; } } } return 0; }
0
#include<iostream> #include<vector> using namespace std; const int N = 100000 ; int size, c, l[N], r[N], b[2*N+1]; vector<int> vec[N]; void dfs(int v){ l[v] = ++c; for(int i=0;i<vec[v].size();i++){ dfs(vec[v][i]); } r[v] = ++c; } void add(int i,int x){ while(i<=size){ b[i] += x; i += i&-i; } } int getSum(int i){ int ans = 0; while(i>0){ ans += b[i]; i -= i&-i; } return ans; } void queryChoose(int i){ if(i == 0){ int v,w; cin>>v>>w; add(l[v],w); add(r[v],-w); }else{ int v; cin>>v; cout<<getSum(r[v] - 1)<<endl; } } int main(){ int n; while(cin>>n){ c = 0; size = 2*n + 1; for(int i=0;i<n;i++){ int k; cin>>k; for(int j=0;j<k;j++){ int child; cin>>child; vec[i].push_back(child); } } dfs(0); int q; cin>>q; for(int i=0;i<q;i++){ int op; cin>>op; queryChoose(op); } } return 0; }
0
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); int N; cin >> N; string s; cin >> s; if (N & 1) cout << ":("; else { int flag = 0, g = 0, l = 0, r = 0; for (int i = 0; i < N; i++) { if (s[i] == '(') l++; else if (s[i] == ')') r++; } int h = 0, j = 0; for (int i = 0; i < N; i++) { if (s[i] == '?') { if (l < N / 2) s[i] = '(', l++, h++; else s[i] = ')', r++, j++; } else if (s[i] == '(') h++; else j++; if (j > h || (j == h && i < N - 1)) flag = 1; } if (l == r && !flag) cout << s; else cout << ":("; } }
3
#include <bits/stdc++.h> using namespace std; template <typename T> string tostr(const T& t) { ostringstream os; os << t; return os.str(); } vector<string> G; bool vis[15][15][15][15]; int dr[] = {2, -2, 2, -2}; int dc[] = {2, 2, -2, -2}; bool calc() { memset(vis, false, sizeof vis); int r1, c1, r2, c2; r1 = -1; for (int i = (int)(0); i <= (int)(8 - 1); ++i) { for (int j = (int)(0); j <= (int)(8 - 1); ++j) { if (G[i][j] == 'K') { if (r1 == -1) { r1 = i; c1 = j; } else { r2 = i; c2 = j; } } } } queue<int> q; q.push(r1); q.push(c1); q.push(r2); q.push(c2); while (!q.empty()) { r1 = q.front(); q.pop(); c1 = q.front(); q.pop(); r2 = q.front(); q.pop(); c2 = q.front(); q.pop(); if (r1 == r2 && c1 == c2 && G[r1][c1] != '#') return true; if (vis[r1][c1][r2][c2]) continue; vis[r1][c1][r2][c2] = true; for (int i = (int)(0); i <= (int)(4 - 1); ++i) { int nr1 = r1 + dr[i]; int nc1 = c1 + dc[i]; if (nr1 < 0 || nr1 >= 8 || nc1 < 0 || nc1 >= 8) continue; for (int j = (int)(0); j <= (int)(4 - 1); ++j) { int nr2 = r2 + dr[j]; int nc2 = c2 + dc[j]; if (nr2 < 0 || nr2 >= 8 || nc2 < 0 || nc2 >= 8) continue; q.push(nr1); q.push(nc1); q.push(nr2); q.push(nc2); } } } return false; } int main() { int ntests; cin >> ntests; for (int testnum = (int)(0); testnum <= (int)(ntests - 1); ++testnum) { G.clear(); for (int i = (int)(0); i <= (int)(8 - 1); ++i) { string s; cin >> s; G.push_back(s); } bool ans = calc(); if (ans) cout << "YES" << endl; else cout << "NO" << endl; } return 0; }
1
#include <bits/stdc++.h> using namespace std; struct line { long long m, y0; line(long long y0 = 0, long long m = 0) : y0(y0), m(m) {} }; struct ConvexHullTrick { int pos = 0; bool check(line a, line b, line c) { return (a.y0 - b.y0) * (c.m - a.m) < (a.y0 - c.y0) * (b.m - a.m); } vector<line> H; void update(line l) { if (H.size() >= 1 && l.m == H.back().m) { if (l.y0 >= H.back().y0) return; H.pop_back(); } while (H.size() >= 2 && !check(H[H.size() - 2], H[H.size() - 1], l)) H.pop_back(); H.push_back(l); } long long eval(int id, int x) { return H[id].y0 + H[id].m * x; } long long query(int x) { while (pos + 1 < H.size() && eval(pos, x) > eval(pos + 1, x)) ++pos; return eval(pos, x); } }; const int N = 1e5 + 7; ConvexHullTrick c[5 * N]; pair<int, int> a[N]; long long ac[N], ans[N]; int x[N], y[N]; void update(int n, int b, int e, int pos, line l) { c[n].update(l); if (b == e) return; int m = (b + e) / 2; if (pos <= m) update(2 * n, b, m, pos, l); else update(2 * n + 1, m + 1, e, pos, l); } long long query(int n, int b, int e, int i, int j, int x) { if (b > j || e < i) return 1e16; if (b >= i && e <= j) return c[n].query(x); int m = (b + e) / 2; return min(query(2 * n, b, m, i, j, x), query(2 * n + 1, m + 1, e, i, j, x)); } int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { scanf("%d", &a[i].first); a[i].second = i; ac[i] = ac[i - 1] + a[i].first; } sort(a + 1, a + n + 1); reverse(a + 1, a + n + 1); for (int i = 1; i <= n; i++) { update(1, 1, n, a[i].second, line(1ll * a[i].first * a[i].second - ac[a[i].second], a[i].first)); } int q; cin >> q; for (int i = 1; i <= q; i++) { scanf("%d%d", &x[i], &y[i]); a[i].first = x[i] - y[i]; a[i].second = i; } sort(a + 1, a + q + 1); for (int i = 1; i <= q; i++) { int j = a[i].second; ans[j] = ac[y[j]] + query(1, 1, n, y[j] - x[j] + 1, y[j], x[j] - y[j]); } for (int i = 1; i <= q; i++) { cout << ans[i] << endl; } return 0; }
5
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n; cin >> n; int ans = pow(2, n / 2 + 1); cout << ans - 2 << endl; } }
1
#include <bits/stdc++.h> using namespace std; const int MAXS = 2e4; int sizeL = MAXS, sizeR = MAXS; bool vis[MAXS]; int par[MAXS]; vector<int> adj[MAXS]; bool match(int u) { for (int v : adj[u]) { if (vis[v]) continue; vis[v] = true; if (par[v] == -1 || match(par[v])) { par[v] = u; return true; } } return false; } int maxmatch() { fill_n(par, sizeR, -1); int ret = 0; for (int i = 0; i < sizeL; i++) { fill_n(vis, sizeR, false); ret += match(i); } return ret; } long long try_board(int n, int m) { vector<vector<int> > idxl(n, vector<int>(m, 0)), idxr(n, vector<int>(m, 0)); int nl = 0, nr = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if ((i + j) % 2 == 0) { idxl[i][j] = nl++; } else { idxr[i][j] = nr++; } } } sizeL = nl; sizeR = nr; for (auto i = (0); i != (nl); ++i) adj[i].clear(); for (int i = 0; i < n; i++) { for (int first = 0; first < n; first++) { if (abs(i - first) >= 3) continue; for (int j = 0; j < m; j++) { if ((i + j) % 2 != 0) continue; for (int second = 0; second < m; second++) { int d = abs(i - first) + abs(j - second); if (d != 3) continue; assert((first + second) % 2 == 1); adj[idxl[i][j]].push_back(idxr[first][second]); } } } } return 2LL * maxmatch(); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int N, M; cin >> N >> M; if (N > M) swap(N, M); int rN = N % 6, rM = M % 6; long long ret = 1LL * N * M - 1LL * (rN * rM); for (int qN = 0; qN < 10 && 6 * qN + rN <= N; qN++) { for (int qM = 0; qM < 10 && 6 * qM + rM <= M; qM++) { int sn = 6 * qN + rN; int sm = 6 * qM + rM; long long alt = 1LL * N * M; alt -= 1LL * sn * sm; alt += try_board(sn, sm); ret = max(ret, alt); } } if (N == 2) { int tmp[4] = {0, -2, -4, -2}; ret = max(ret, 2LL * M + tmp[M % 4]); } cout << ret << endl; return 0; }
4
#include <bits/stdc++.h> using namespace std; const int Max = 2e6 + 10; const int Mod = 1e9 + 7; const long long int Inf = 1LL << 62; unordered_map<int, int> cntup, cntlw, duplicate; unordered_set<int> up, lw; int main() { ios_base::sync_with_stdio(false); cin.tie(0); int x, y, n, need; cin >> n; need = n / 2 + (n & 1); while (n--) { cin >> x >> y; up.insert(x); cntup[x]++; lw.insert(y); cntlw[y]++; if (x == y) { duplicate[x]++; } } int ans = 1e9; for (int x : up) { cntlw[x] -= duplicate[x]; if (cntup[x] >= need) { cout << 0 << endl; return 0; } else if (cntup[x] + cntlw[x] >= need) { ans = min(ans, need - cntup[x]); } cntlw[x] += duplicate[x]; } for (int x : lw) { cntup[x] -= duplicate[x]; int lagbe = need - cntup[x]; if (lagbe <= 0) { cout << 0 << endl; return 0; } else if (cntup[x] + cntlw[x] >= need) { ans = min(ans, need - cntup[x]); } cntlw[x] += duplicate[x]; } if (ans == 1e9) { ans = -1; } cout << ans << endl; return 0; }
4
#include <iostream> #include <algorithm> #include <vector> #include <queue> #include <map> #include <stack> #include <cstring> #define FOR(i, a, b) for(int i = (a); i < (b); i++) #define rep(i, n) for(int i = 0; i < (n); i++) #define MP make_pair #define X first #define Y second using namespace std; typedef vector<int> vi; typedef pair<int, int> P; const int INF = 1<<29; int field[100][100]; int visit[100][100]; int dx[] = {0, 1, 0, -1}; int dy[] = {1, 0, -1, 0}; int w, h; int dfs(int x, int y){ int res = 0; rep(i, 4){ int nx = x+dx[i], ny = y+dy[i]; if(nx < 0 || nx >= w || ny < 0 || ny >= h) continue; if(!field[ny][nx]) continue; if(visit[ny][nx]) continue; visit[ny][nx] = 1; res = max(res, dfs(nx, ny)); visit[ny][nx] = 0; } return res+1; } int main(){ while(cin >> w >> h, w|h){ rep(i, h) rep(j, w) cin >> field[i][j]; int ans = 0; rep(i, h) rep(j, w){ if(field[i][j]){ memset(visit, 0, sizeof(visit)); visit[i][j] = 1; ans = max(ans, dfs(j, i)); } } cout << ans << endl; } return 0; }
0
#include <bits/stdc++.h> using namespace std; int main() { int q; cin >> q; string prev; cin >> prev; q--; set<string> s; s.insert(prev); bool ok = true; while(q--) { string next; cin >> next; ok &= next.front() == prev.back(); ok &= (not s.count(next)); s.insert(next); prev = next; } cout << (ok ? "Yes" : "No") << endl; return 0; }
0
#include <bits/stdc++.h> using namespace std; char ans[11000][11000]; char a[10] = {"aeiou"}; int main() { int k; int flag = 0; cin >> k; for (int i = 5; i <= k; i++) { if (k % i == 0 && k / i >= 5) { flag = i; break; } } if (!flag) { cout << "-1" << endl; return 0; } int n = flag; int m = k / n; for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { ans[i][j] = a[(i + j) % 5]; } } for (int i = 5; i < n; i++) { for (int j = 0; j < 5; j++) { ans[i][j] = a[j]; } for (int j = 5; j < m; j++) { ans[i][j] = 'm'; } } for (int i = 5; i < m; i++) { for (int j = 0; j < 5; j++) { ans[j][i] = a[j]; } for (int j = 5; j < n; j++) { ans[j][i] = 'm'; } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cout << ans[i][j]; } } return 0; }
2
#include <bits/stdc++.h> using namespace std; const int N = 10; int h[N][N]; int f[N * N]; double dp[N * N]; pair<int, int> coord(int i) { int r = i / N; int c = i % N; if (r & 1) c = N - c - 1; return {r, c}; } int getidx(int r, int c) { if (r & 1) c = N - c - 1; return N * r + c; } int main() { ios::sync_with_stdio(false); cin.tie(0); for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { cin >> h[i][j]; f[getidx(i, j)] = getidx(i - h[i][j], j); } } for (int i = 0; i < N * N; i++) { pair<int, int> p = coord(i); h[p.first][p.second] = i; } dp[0] = 0; dp[1] = 6.0 + dp[0]; dp[2] = 3.0 + 0.5 * (dp[0] + dp[1]); dp[3] = 2.0 + (dp[0] + dp[1] + dp[2]) / 3.0; dp[4] = 1.5 + (dp[0] + dp[1] + dp[2] + dp[3]) / 4.0; dp[5] = 1.2 + (dp[0] + dp[1] + dp[2] + dp[3] + dp[4]) / 5.0; for (int i = 6; i < N * N; i++) { for (int j = 0; j < 6; j++) { dp[i] += min(dp[i - j - 1], dp[f[i - j - 1]]); } dp[i] = 1 + dp[i] / 6.0; } cout << fixed << setprecision(8) << dp[N * N - 1] << endl; }
5
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 5; const int maxm = 50; int edge[maxm + 1][maxm + 1]; int main() { int n, m; scanf("%d%d", &n, &m); for (int i = 0; i < m; ++i) { int u, v; scanf("%d%d", &u, &v); if (u <= maxm && v <= maxm) edge[u][v] = edge[v][u] = 1; } for (int i = 1; i <= min(n, maxm); ++i) { for (int j = i + 1; j <= min(n, maxm); ++j) { for (int k = j + 1; k <= min(n, maxm); ++k) { if (!(edge[i][j] && edge[i][k] && edge[j][k] || !edge[i][j] && !edge[i][k] && !edge[j][k])) continue; for (int h = k + 1; h <= min(n, maxm); ++h) { if (!(edge[i][j] && edge[i][h] && edge[j][h] && edge[k][h] || !edge[i][j] && !edge[i][h] && !edge[j][h] && !edge[k][h])) continue; for (int l = h + 1; l <= min(n, maxm); ++l) { if (!(edge[i][j] && edge[i][l] && edge[j][l] && edge[k][l] && edge[h][l] || !edge[i][j] && !edge[i][l] && !edge[j][l] && !edge[k][l] && !edge[h][l])) continue; return printf("%d %d %d %d %d\n", i, j, k, h, l), 0; } } } } } printf("-1\n"); }
6
#include <bits/stdc++.h> using namespace std; #define int long long const int tx[]={0,0,1,-1}; const int ty[]={1,-1,0,0}; int getd(int a,int b,int x,int y){ return abs(a-x)+abs(b-y); } char getc(int &a,int &b,int d,int x,int y){ int Mn=2e9,op=-1; for (int i=0;i<4;i++){ int xx=a+tx[i]*d,yy=b+ty[i]*d; int dis=getd(xx,yy,x,y); if (dis<Mn) {Mn=dis; op=i;} } a=a+tx[op]*d; b=b+ty[op]*d; if (op==0) return 'U'; if (op==1) return 'D'; if (op==2) return 'R'; return 'L'; } int x[1111],y[1111],d[222],cnt[2],m; signed main(){ int T; scanf("%lld",&T); for (int i=1;i<=T;i++){ scanf("%lld%lld",&x[i],&y[i]); cnt[(x[i]+y[i])%2]++; } if (cnt[1]&& cnt[0]) return puts("-1"),0; for (int i=0;i<=30;i++) d[i+1]=1<<(30-i); if (cnt[0]) d[32]=1,m=32; else m=31; printf("%lld\n",m); for (int i=1;i<=m;i++) printf("%lld ",d[i]); puts(""); for (int i=1;i<=T;i++){ int a=0,b=0; for (int j=1;j<=m;j++) putchar(getc(a,b,d[j],x[i],y[i])); puts(""); } return 0; }
0
#include <bits/stdc++.h> using namespace std; double dp[305][305][305]; double dish(int a,int b,int c,int n){ if(a<0 or b<0 or c<0) return 0; if(a==0 and b==0 and c==0) dp[a][b][c]=0; if(dp[a][b][c]==-1){ dp[a][b][c]=(a*dish(a-1,b+1,c,n)+b*dish(a,b-1,c+1,n)+c*dish(a,b,c-1,n)+n)/(a+b+c); } return dp[a][b][c]; } int main(){ int n; cin >> n; std::fill_n(&dp[0][0][0],305*305*305,-1.0); int a=0,b=0,c=0; for(int i=0;i<n;i++){ int x; cin >> x; if(x==3) a++; else if(x==2) b++; else c++; } cout << setprecision(50) << dish(a,b,c,n) << endl; }
0
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; for (int i = 0; i < s.size() / 2; i++) if (s[i] != s[s.size() - i - 1]) { cout << "NO"; return 0; } for (int i = 0; i < s.size(); i++) if ((s[i] != 'A') && (s[i] != 'W') && (s[i] != 'T') && (s[i] != 'Y') && (s[i] != 'U') && (s[i] != 'I') && (s[i] != 'O') && (s[i] != 'H') && (s[i] != 'X') && (s[i] != 'V') && (s[i] != 'M')) { cout << "NO"; return 0; } cout << "YES"; return 0; }
2
#include <bits/stdc++.h> using namespace std; bool divc[100001][318]; int sum[100001][318]; int n; int x[100001], y[100001]; set<pair<int, int> > comp; int main() { memset(divc, 0, sizeof(divc)); memset(sum, 0, sizeof(sum)); comp.clear(); cin >> n; for (int i = 0; i < (int)(n); i++) cin >> x[i + 1] >> y[i + 1]; for (int i = 1; i <= n; i++) { for (int j = 1; j < 318; j++) { if (x[i] % j == 0) { divc[i][j] = 1; sum[i][j]++; int c = x[i] / j; if (c >= 318) { comp.insert(make_pair(c, i)); } } if (i + 1 < 100001) { sum[i + 1][j] = sum[i][j]; } } } for (int i = 1; i <= n; i++) { int ans = 0; for (int j = 1; j < 318; j++) { if (!divc[i][j]) continue; if (!(sum[i - 1][j] - sum[i - y[i] - 1][j])) { ans++; } int c = x[i] / j; if (c >= 318) { set<pair<int, int> >::iterator it = comp.lower_bound(make_pair(c, i)); if (it != comp.begin()) { it--; if (it->first != c || it->second < i - y[i]) { ans++; } } else { ans++; } } } cout << ans << endl; } return 0; }
2
#include <bits/stdc++.h> using namespace std; #pragma comment(linker, "/STACK:512000000") template <class T> T sqr(T a) { return a * a; } int n; vector<vector<int> > g; int val[1 << 17]; bool was[1 << 17] = {0}; pair<long long, long long> dfs(int v) { was[v] = 1; long long d1 = 0, d2 = 0; for (int i = 0; i < (int)(g[v]).size(); ++i) { int to = g[v][i]; if (was[to]) continue; pair<long long, long long> r = dfs(to); d1 = min(d1, r.first); d2 = max(d2, r.second); } int tval = val[v] + d1 + d2; if (tval > 0) d1 -= tval; else d2 -= tval; return make_pair(d1, d2); } int main() { scanf("%d", &n); g.resize(n); for (int i = 0; i < n - 1; ++i) { int u, v; scanf("%d%d", &u, &v); --u; --v; g[u].push_back(v); g[v].push_back(u); } for (int i = 0; i < n; ++i) scanf("%d", &val[i]); pair<long long, long long> res = dfs(0); cout << res.second - res.first << endl; return 0; }
2
#include <bits/stdc++.h> using namespace std; const int maxn = 312345; int n, mx, fa[maxn][20], dep[maxn]; vector<int> v1, v2; inline int lca(int u, int v) { if (dep[u] < dep[v]) swap(u, v); int det = dep[u] - dep[v]; for (int i = 0; i < 20; ++i) if (det >> i & 1) u = fa[u][i]; if (u == v) return u; for (int i = 19; i >= 0; --i) if (fa[u][i] != fa[v][i]) { u = fa[u][i]; v = fa[v][i]; } return fa[u][0]; } inline int dis(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; } int main() { for (int i = 0; i < 20; ++i) fa[1][i] = 1; v1.push_back(1); scanf("%d", &n); for (int u = 2; u <= n + 1; ++u) { int x; scanf("%d", &x); dep[u] = dep[x] + 1; fa[u][0] = x; for (int i = 1; i < 20; ++i) fa[u][i] = fa[fa[u][i - 1]][i - 1]; int d1 = dis(u, v1[0]); int d2 = !v2.size() ? 0 : dis(u, v2[0]); if (max(d1, d2) == mx) { if (d2 == mx) v1.push_back(u); else v2.push_back(u); } else if (max(d1, d2) > mx) { mx = max(d1, d2); if (d2 == mx) { for (auto v : v1) if (dis(u, v) == mx) v2.push_back(v); v1.clear(); v1.push_back(u); } else { v2.clear(); v2.push_back(u); } } printf("%d\n", v1.size() + v2.size()); } return 0; }
5
#include <bits/stdc++.h> using namespace std; long long sumofdigit(long long n) { long long ans = 0; while (n) { ans += (n % 10); n = n / 10; } return ans; } long long power(long long n, long long p) { long long res = n; for (long long i = 1; i < p; i++) { res *= n; } return res; } int32_t main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); vector<long long> ans; long long a, b, c; cin >> a >> b >> c; for (long long i = 1; i <= 81; i++) { long long x = power(i, a) * b + c; if (x > 1e9) { break; } if (sumofdigit(x) == i) { ans.push_back(x); } } cout << ans.size() << "\n"; for (auto i : ans) { cout << i << " "; } }
2
#include <bits/stdc++.h> using namespace std; int main() { int n, x, s = 0, d = 0; cin >> n; vector<int> v; for (int i = 0; i < n; i++) { cin >> x; v.push_back(x); } while (!v.empty()) { if (v[0] >= v[v.size() - 1]) { s += v[0]; v.erase(v.begin()); } else { s += v[v.size() - 1]; v.erase(v.end() - 1); } if (!v.empty() && v[0] >= v[v.size() - 1]) { d += v[0]; v.erase(v.begin()); } else if (!v.empty() && v[0] < v[v.size() - 1]) { d += v[v.size() - 1]; v.erase(v.end() - 1); } } cout << s << " " << d; return 0; }
1
#include<bits/stdc++.h> using namespace std; struct block{ double xr; double xl; double g; set<int> chil; }; int dx[]={1,-1,0,0}; int dy[]={0,0,1,-1}; int w,h; int inde=1; bool isrange(int i,int j){ return 0<=i && i<h && 0<=j && j<w; } void draw(int i,int j,char x,vector<string> &f,vector<vector<int>> &c){ f[i][j]='.'; c[i][j]=inde; for(int dir=0;dir<4;dir++){ int toi=i+dx[dir]; int toj=j+dy[dir]; if(isrange(toi,toj) && f[toi][toj]==x){ draw(toi,toj,x,f,c); } } return; } vector<block> bs; pair<double,double> gggg(int x){ double gg=bs[x].g; double wei=4; for(auto b:bs[x].chil){ auto ret=gggg(b); gg=(ret.first*ret.second+wei*gg)/(wei+ret.first); wei+=ret.first; } return make_pair(wei,gg); } int main(){ while(cin>>w>>h,w){ vector<string> f(h); for(int i=0;i<h;i++) cin>>f[i]; vector<vector<int>> c(h,vector<int>(w,0)); inde=1; for(int i=0;i<h;i++){ for(int j=0;j<w;j++){ if(isdigit(f[i][j])){ draw(i,j,f[i][j],f,c); inde++; } } } bs.clear(); bs.resize(inde); for(int i=0;i<inde;i++){ bs[i].xl=400000; bs[i].xr=0; bs[i].g=0; } for(int i=0;i<h;i++){ for(int j=0;j<w;j++){ if(c[i][j]!=0){ bs[c[i][j]].g+=j; for(int dir=0;dir<2;dir++){ int toi=i+dx[dir]; int toj=j; if(isrange(toi,toj)&&c[toi][toj]!=0 && c[toi][toj]!=c[i][j]){ if(dir==0){ bs[c[i][j]].xl=min<double>(bs[c[i][j]].xl,j); bs[c[i][j]].xr=max<double>(bs[c[i][j]].xr,j); } else{ bs[c[i][j]].chil.insert(c[toi][toj]); } } else if(!isrange(toi,toj) && dir==0){ bs[c[i][j]].xl=min<double>(bs[c[i][j]].xl,j); bs[c[i][j]].xr=max<double>(bs[c[i][j]].xr,j); } } } } } for(int i=0;i<inde;i++) { bs[i].g/=4; bs[i].xl-=0.5; bs[i].xr+=0.5; } bool isok=true; for(int i=1;i<inde;i++){ auto ret=gggg(i); isok&=(bs[i].xl<ret.second && ret.second<bs[i].xr); } cout<<(isok ? "STABLE" : "UNSTABLE")<<endl; } return 0; }
0
#include <bits/stdc++.h> using namespace std; struct _ { ios_base::Init i; _() { cin.sync_with_stdio(0); cin.tie(0); } } _; double a[500]; int main() { int n, m; cin >> n >> m; for (int i = 0; i < n; ++i) cin >> a[i]; double ans = 0; for (int i = 0; i < m; ++i) { int from, to; double x; cin >> from >> to >> x; --from; --to; ans = max(ans, (a[from] + a[to]) / x); } cout.precision(20); cout << ans; return 0; }
1
#include <bits/stdc++.h> using namespace std; const int MN = 100005, note = 100; int C[MN], W[MN], czy[MN], ile[MN]; priority_queue<pair<long long, int> > Q; long long wynik; int main() { int n; long long hajs; scanf("%d%I64d", &n, &hajs); for (int i = 1; i <= n; ++i) { scanf("%d", &C[i]); ile[i] = C[i] / note; C[i] %= note; } for (int i = 1; i <= n; ++i) scanf("%d", &W[i]); for (int i = 1; i <= n; ++i) { if (!C[i]) continue; long long currDis = ((long long)(note - C[i])) * ((long long)W[i]); if (C[i] <= hajs) { hajs -= C[i]; Q.push(make_pair(-currDis, i)); czy[i] = 1; } else { if (!Q.empty() && -Q.top().first < currDis) { czy[Q.top().second] = 0; czy[i] = 1; wynik -= Q.top().first; Q.pop(); Q.push(make_pair(-currDis, i)); } else { wynik += currDis; } hajs += (100 - C[i]); } } printf("%I64d\n", wynik); for (int i = 1; i <= n; ++i) { if (czy[i] || !C[i]) printf("%d %d\n", ile[i], C[i]); else printf("%d 0\n", ile[i] + 1); } }
5
#include <bits/stdc++.h> using namespace std; char grid[2010][2010]; bool vis[2010][2010]; int dx[] = {0, 0, 1, -1}; int dy[] = {-1, 1, 0, 0}; bool valid(int x, int y, int n, int m) { if (x == n || y == m || x == -1 || y == -1 || vis[x][y] || grid[x][y] == '*') { return 0; } return 1; } int main() { int n, m; int sr, sc; int x, y; scanf("%d%d%d%d%d%d", &n, &m, &sr, &sc, &x, &y); sr--, sc--; for (int i = 0; i < n; i++) { scanf("%s", grid[i]); } int ans = 0; queue<pair<pair<int, int>, pair<int, int> > > q[2]; int curQ = 0, nxtQ = 1; q[curQ].push(make_pair(make_pair(sr, sc), make_pair(x, y))); while (q[curQ].size()) { while (q[curQ].size()) { pair<pair<int, int>, pair<int, int> > cur = q[curQ].front(); q[curQ].pop(); int curX = cur.first.first; int curY = cur.first.second; int rem[] = {cur.second.first, cur.second.second}; if (valid(curX, curY, n, m) == 0) { continue; } ans++; vis[curX][curY] = 1; for (int i = 0; i < 4; i++) { if (i < 2) { if (rem[i] == 0) continue; rem[i]--; q[nxtQ].push(make_pair(make_pair(curX + dx[i], curY + dy[i]), make_pair(rem[0], rem[1]))); rem[i]++; } else { q[curQ].push(make_pair(make_pair(curX + dx[i], curY + dy[i]), make_pair(rem[0], rem[1]))); } } } curQ = !curQ; nxtQ = !nxtQ; } printf("%d\n", ans); return 0; }
4
#include <bits/stdc++.h> #define ll long long #define endl "\n" #define IOS cin.tie(0);cout.tie(0);ios::sync_with_stdio(0); using namespace std; const int mod = 1e9+7; int MSB(unsigned x){ //most significant bit-read IEEE 754 union { double a; int64_t b; }; a = x; return (b >> 20) - 1023; } struct custom_hash { static uint64_t splitmix64(uint64_t x) { // http://xorshift.di.unimi.it/splitmix64.c x += 0x9e3779b97f4a7c15; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; x = (x ^ (x >> 27)) * 0x94d049bb133111eb; return x ^ (x >> 31); } size_t operator()(uint64_t x) const { static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); return splitmix64(x + FIXED_RANDOM); } }; ll bpow(ll a,ll b){ll s=1;while(b){if(b&1)s*=a;a*=a;b>>=1;}return s;} ll bmpow(ll a,ll b){ll s=1;while(b){if(b&1)s*=a,s%=mod;a*=a;a%=mod;b>>=1;}return s;} const int N = 1e6+13; int a[N]; void solve(){ int n,W;cin>>n>>W; multiset<int> g; for(int i=0;i<n;i++)cin>>a[i]; sort(a,a+n,greater<int>()); for(int i=0;i<n;i++){ g.insert(W); } for(int i=0;i<n;i++){ int x = a[i]; int y = *g.lower_bound(x); //cout << x << " " << y << endl; auto it = g.find(y); if(it!=g.end())g.erase(it); g.insert(y-x); } int c = g.count(W); // for(auto x:g)cout<<x<<" ";cout<<endl; cout << n-c << endl; } int main(){ IOS; int t; cin>>t; while(t--)solve(); }
2
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; map<string, string> mp1, mp2; map<string, string>::iterator it; while (n--) { string s1, s2; cin >> s1 >> s2; if (mp2.find(s1) == mp2.end()) { mp1[s1] = s2; mp2[s2] = s1; } else { string s3 = mp2[s1]; mp1[s3] = s2; mp2[s2] = s3; } } cout << mp1.size() << endl; for (it = mp1.begin(); it != mp1.end(); it++) { cout << it->first << " " << it->second << endl; } }
2
#include<iostream> #include<algorithm> #include<queue> #include<vector> #include<set> #include<stack> #include<cstring> #include<cstdio> //#include<bits/stdc++.h> using namespace std; void work(){ int n,k; cin>>n>>k; int x=0; for(int i=0;i<n;i++){ if(i==0)x=0; else x=(i^(i-1)); printf("%d\n",x); fflush(stdout); int f; cin>>f;if(f==1)break; } fflush(stdout); return ; } int main() { int t;cin>>t; while(t--)work(); return 0; } //x^2 2^3
4
#include <bits/stdc++.h> using namespace std; const long long mod = 1000000007; int main() { long long n; cin >> n; long long a[2][2] = {{3, 1}, {1, 3}}; long long r[2][2]; long long t[2][2]; r[0][0] = r[1][1] = 1; r[1][0] = r[0][1] = 0; while (n) { if (n & 1) { memset(t, 0, sizeof(t)); for (int i = 0; i < (2); i++) for (int j = 0; j < (2); j++) for (int k = 0; k < (2); k++) { t[i][j] = (t[i][j] + r[i][k] * a[k][j]) % mod; } memcpy(r, t, sizeof(r)); } n /= 2; memset(t, 0, sizeof(t)); for (int i = 0; i < (2); i++) for (int j = 0; j < (2); j++) for (int k = 0; k < (2); k++) { t[i][j] = (t[i][j] + a[i][k] * a[k][j]) % mod; } memcpy(a, t, sizeof(a)); } cout << r[0][0] << endl; return 0; }
1
#include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; int numeros[n + 1]; for (int i = 0; i < n; i++) { int a; cin >> a; numeros[i] = a; } sort(numeros, numeros + n); set<int> largo; for (int i = 0; i < n; ++i) { int l, m; l = (abs(numeros[i] % k)); m = largo.count(numeros[i] / k); if ((l > 0) || (m == 0)) { int a; a = numeros[i]; largo.insert(a); } } cout << largo.size(); return 0; }
1
#include <bits/stdc++.h> using namespace std; signed main() { long long tt; cin >> tt; while (tt--) { long long n, k; cin >> n; vector<long long> a(n + 1); map<long long, vector<long long>> mp; map<long long, set<long long>> ans; for (long long i = 1; i <= n; ++i) { cin >> a[i]; mp[a[i]].push_back(i); } for (auto it : mp) { long long maxx = it.second[0]; for (long long i = 1; i < it.second.size(); ++i) { long long diff = it.second[i] - it.second[i - 1]; maxx = max(maxx, diff); } long long diff = n - it.second.back() + 1; maxx = max(maxx, diff); ans[maxx].insert(it.first); } long long minn = LLONG_MAX; for (long long i = 1; i <= n; ++i) { if (ans[i].empty()) { if (minn == LLONG_MAX) cout << -1; else cout << minn; } else { minn = min(minn, *(ans[i].begin())); cout << minn; } cout << " "; } cout << '\n'; } }
1
#include <bits/stdc++.h> using namespace std; const int MAXN = 200000 + 86; long long x[MAXN], c[MAXN]; int main() { int n, q; int L, R; long long tot = 0; cin >> n >> q; for (int i = 1; i <= n; ++i) cin >> x[i]; for (int i = 0; i < q; ++i) cin >> L >> R, --c[L - 1], ++c[R]; for (int i = n - 1; i > 0; --i) c[i] += c[i + 1]; sort(x + 1, x + n + 1); sort(c + 1, c + n + 1); for (int i = 1; i <= n; ++i) tot += c[i] * x[i]; cout << tot << endl; return 0; }
3
#include <bits/stdc++.h> using namespace std; int const inf = 1000 * 1000 * 1000; long long const inf64 = 1ll * inf * inf; int const K = 300005; int const N = 1005; int n, m, k; int mat[N][N]; struct picture { int color; int li, lj, ri, rj; void read() { char type; scanf("%d %d %d %d %c", &li, &lj, &ri, &rj, &type); color = type - 'a'; } } p[K]; int diff[K]; long long total_diff = 0; int d[N][N]; inline int get_sum(int li, int lj, int ri, int rj) { return d[ri][rj] - d[li - 1][rj] - d[ri][lj - 1] + d[li - 1][lj - 1]; } int cnt[N][N]; int cnt_col[N][N]; long long sum_col[N][N]; long long cur_diff[N][N]; long long sum_diff[N][N]; long long sum_cnt_col[N][N]; long long tmp[K]; inline long long get_sum_diff(int li, int lj, int ri, int rj) { return sum_diff[ri][rj] - sum_diff[li - 1][rj] - sum_diff[ri][lj - 1] + sum_diff[li - 1][lj - 1]; } inline long long get_sum_col(int li, int lj, int ri, int rj) { return sum_col[ri][rj] - sum_col[li - 1][rj] - sum_col[ri][lj - 1] + sum_col[li - 1][lj - 1]; } inline long long get_sum_cnt_col(int li, int lj, int ri, int rj) { return sum_cnt_col[ri][rj] - sum_cnt_col[li - 1][rj] - sum_cnt_col[ri][lj - 1] + sum_cnt_col[li - 1][lj - 1]; } void build() { for (int i = 1; i <= k; i++) { cnt[p[i].ri][p[i].rj]++; cnt[p[i].li - 1][p[i].rj]--; cnt[p[i].ri][p[i].lj - 1]--; cnt[p[i].li - 1][p[i].lj - 1]++; } for (int i = n; i >= 1; i--) { for (int j = m; j >= 1; j--) { cnt[i - 1][j] += cnt[i][j]; cnt[i][j - 1] += cnt[i][j]; cnt[i - 1][j - 1] -= cnt[i][j]; } } for (int c = 0; c < 26; c++) { for (int i = 0; i <= n; i++) { for (int j = 0; j <= m; j++) { cnt_col[i][j] = 0; } } for (int i = 1; i <= k; i++) { if (p[i].color != c) continue; cnt_col[p[i].ri][p[i].rj]++; cnt_col[p[i].li - 1][p[i].rj]--; cnt_col[p[i].ri][p[i].lj - 1]--; cnt_col[p[i].li - 1][p[i].lj - 1]++; } for (int i = n; i >= 1; i--) { for (int j = m; j >= 1; j--) { cnt_col[i - 1][j] += cnt_col[i][j]; cnt_col[i][j - 1] += cnt_col[i][j]; cnt_col[i - 1][j - 1] -= cnt_col[i][j]; } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { cur_diff[i][j] += 1ll * abs(mat[i][j] - c) * cnt_col[i][j]; } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { sum_col[i][j] = (mat[i][j] == c) * cnt[i][j]; sum_col[i][j] += sum_col[i - 1][j] + sum_col[i][j - 1] - sum_col[i - 1][j - 1]; sum_cnt_col[i][j] = sum_cnt_col[i - 1][j] + sum_cnt_col[i][j - 1] - sum_cnt_col[i - 1][j - 1]; sum_cnt_col[i][j] += cnt_col[i][j]; } } for (int i = 1; i <= k; i++) { tmp[i] -= 1ll * get_sum_col(p[i].li, p[i].lj, p[i].ri, p[i].rj) * abs(c - p[i].color); tmp[i] += 1ll * get_sum_cnt_col(p[i].li, p[i].lj, p[i].ri, p[i].rj) * abs(c - p[i].color); } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { sum_diff[i][j] = sum_diff[i - 1][j] + sum_diff[i][j - 1] - sum_diff[i - 1][j - 1] + cur_diff[i][j]; } } } int main() { scanf("%d %d %d", &n, &m, &k); if (k == 1) { puts("0"); return 0; } for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { char c; scanf(" %c", &c); mat[i][j] = c - 'a'; } } for (int i = 1; i <= k; i++) { p[i].read(); } for (int c = 0; c < 26; c++) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { d[i][j] = d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1] + (mat[i][j] == c); } } for (int i = 1; i <= k; i++) { diff[i] += abs(c - p[i].color) * get_sum(p[i].li, p[i].lj, p[i].ri, p[i].rj); } } for (int i = 1; i <= k; i++) { total_diff += diff[i]; } long long res = inf64; build(); for (int i = 1; i <= k; i++) { tmp[i] += total_diff - diff[i] + 1ll * diff[i] * (k - 1) + diff[i]; } for (int i = 1; i <= k; i++) { tmp[i] -= (get_sum_diff(p[i].li, p[i].lj, p[i].ri, p[i].rj) - diff[i]); } for (int i = 1; i <= k; i++) { res = min(res, tmp[i]); } cout << res << "\n"; return 0; }
6
#include<bits/stdc++.h> using namespace std; int main(){ int A,B,C,D;cin>>A>>B>>C>>D; for(int i=0;i<D-B;i++)cout<<'U'; for(int i=0;i<C-A;i++)cout<<'R'; for(int i=0;i<D-B;i++)cout<<'D'; for(int i=0;i<C-A;i++)cout<<'L'; cout<<'L'; for(int i=0;i<D-B+1;i++)cout<<'U'; for(int i=0;i<C-A+1;i++)cout<<'R'; cout<<'D'; cout<<'R'; for(int i=0;i<D-B+1;i++)cout<<'D'; for(int i=0;i<C-A+1;i++)cout<<'L'; cout<<'U'<<endl; }
0
#include <bits/stdc++.h> using namespace std; int main() { (ios_base::sync_with_stdio(false), cin.tie(NULL)); ; int t, n, x; cin >> t; while (t--) { cin >> n >> x; int c = 2, ans = 1; while (c < n) { c += x; ans++; } cout << ans << endl; } return 0; }
1
#include <bits/stdc++.h> using namespace std; string dtob(long long int n) { string r = ""; long long int t = n; while (n > 0) { r = to_string(n % 2) + r; n /= 2; } return r; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; long long int n, q; cin >> n >> q; map<long long int, long long int> m; for (long long int i = 0; i < n; i++) { long long int x; cin >> x; m[x] += 1; } vector<pair<long long int, long long int> > v1; map<long long int, long long int>::iterator itr; for (itr = m.begin(); itr != m.end(); itr++) v1.insert(v1.begin(), make_pair(itr->first, itr->second)); for (long long int i = 0; i < q; i++) { long long int x; cin >> x; long long int ind = 0, res = 0; vector<pair<long long int, long long int> > v = v1; while (ind < v.size() and x > 0) { if (x <= v[ind].first * v[ind].second) { long long int need = x / v[ind].first; res += need; x -= need * v[ind].first; v[ind].second -= need; } else { res += v[ind].second; x -= v[ind].first * v[ind].second; v[ind].second = 0; } ind += 1; } if (x == 0) cout << res << endl; else cout << "-1" << endl; } }
4
#include <bits/stdc++.h> using namespace std; vector<long long int> v, v2, v3, v4; int main() { long long ar[102] = {0}, arb[102] = {0}; long long int i = 0, j, temp = 0, c, d, n, m, k, flag = 0, mi2 = 0, sum = 0, a, b, cur, ma = 0, ans = 0; float re; vector<pair<long long, long long> > vp, vp2; string st; cin >> st; v.push_back(-1); for (i = 0; i < st.size(); i++) { if (st[i] == 'A' || st[i] == 'I' || st[i] == 'O' || st[i] == 'E' || st[i] == 'U' || st[i] == 'Y') { if (st.size() == 1) { cout << 1; return 0; } v.push_back(i); } } v.push_back(st.size()); for (i = 1; i < v.size(); i++) { ma = v[i] - v[i - 1]; if (ma > flag) { flag = ma; } } cout << flag; return 0; }
1
#include <bits/stdc++.h> using namespace std; int main() { int n; int count = 0, count2 = 0; int i, j, k = -1; cin >> n; int a[n]; for (i = 0; i < n; i++) cin >> a[i]; for (i = 0; i < n; i++) { if (a[i] == 1) { k = i; break; } } if (k == -1) { cout << "0"; return 0; } for (i = k; i < n;) { if (a[i] == 1) { count++; i++; } else { for (j = i;; j++) { if (a[j] == 1) break; else count2++; } if (count2 == 1) { i++; count++; count2 = 0; } else { i += count2; count2 = 0; } } } cout << count; return 0; }
1
#include <bits/stdc++.h> int a[100009]; int S[100009]; struct sLine { int K, B; int L, R; } lines[2000009]; int linesCnt; struct sTree { int l, r; sLine* arr; int pl, pr; int cnt; } tree[200009]; int treeSize; int BuildTree(int l, int r) { int cur = treeSize++; tree[cur].l = l; tree[cur].r = r; if (l < r) { tree[cur].pl = BuildTree(l, (l + r) / 2); tree[cur].pr = BuildTree((l + r) / 2 + 1, r); tree[cur].arr = &lines[linesCnt + 1]; int i = 0, j = 0; int lCnt = tree[tree[cur].pl].r - tree[tree[cur].pl].l + 1; int rCnt = tree[tree[cur].pr].r - tree[tree[cur].pr].l + 1; for (int k = 0; k < r - l + 1; k++) { if (i < lCnt && (j >= rCnt || (tree[tree[cur].pl].arr[i].K > tree[tree[cur].pr].arr[j].K || (tree[tree[cur].pl].arr[i].K == tree[tree[cur].pr].arr[j].K && tree[tree[cur].pl].arr[i].B < tree[tree[cur].pr].arr[j].B)))) tree[cur].arr[k] = tree[tree[cur].pl].arr[i++]; else tree[cur].arr[k] = tree[tree[cur].pr].arr[j++]; } linesCnt += lCnt + rCnt; } else { tree[cur].arr = &lines[l]; } return cur; } void BuildCH(int cur) { int j = 1; for (int k = 1; k < tree[cur].r - tree[cur].l + 1; k++) { if (tree[cur].arr[k].K == tree[cur].arr[k - 1].K) continue; int intersect = -1; while (j) { intersect = (tree[cur].arr[j - 1].B - tree[cur].arr[k].B) / (tree[cur].arr[k].K - tree[cur].arr[j - 1].K); if (intersect >= tree[cur].arr[j - 1].L) break; j--; intersect = -1; } if (j) { tree[cur].arr[j - 1].R = intersect; } tree[cur].arr[j] = tree[cur].arr[k]; tree[cur].arr[j].L = intersect + 1; j++; } tree[cur].cnt = j; if (tree[cur].l < tree[cur].r) { BuildCH(tree[cur].pl); BuildCH(tree[cur].pr); } } int Find(int X, int cur) { int l = 0, r = tree[cur].cnt - 1; while (l <= r) { int m = (l + r) / 2; if (tree[cur].arr[m].L <= X && X <= tree[cur].arr[m].R) return tree[cur].arr[m].K * X + tree[cur].arr[m].B; if (X < tree[cur].arr[m].L) r = m - 1; else l = m + 1; } } int calcAns(int l, int r, int cur) { if (l <= tree[cur].l && r >= tree[cur].r) return Find(l - 1, cur); int ans = 100000000; if (l <= tree[tree[cur].pl].r && tree[tree[cur].pl].l <= r) { int tmp = calcAns(l, r, tree[cur].pl); if (ans > tmp) ans = tmp; } if (l <= tree[tree[cur].pr].r && tree[tree[cur].pr].l <= r) { int tmp = calcAns(l, r, tree[cur].pr); if (ans > tmp) ans = tmp; } return ans; } int main() { int n; scanf("%d", &n); for (int i = 1; i <= n; i++) { scanf("%d", &a[i]); S[i] = S[i - 1] + a[i]; linesCnt++; lines[linesCnt].K = -a[i]; lines[linesCnt].B = a[i] * i - S[i]; lines[linesCnt].L = 0; lines[linesCnt].R = 100000000; } int root = BuildTree(1, n); BuildCH(root); int m; scanf("%d", &m); while (m--) { int x, y; scanf("%d %d", &x, &y); printf("%d\n", S[y] + calcAns(y - x + 1, y, root)); } }
5
#include <iostream> using namespace std; int main(){ int S, W; cin >> S >> W; cout << (S > W ? "safe" : "unsafe"); }
0
#include <bits/stdc++.h> using namespace std; const int MAXN = 600010; int mem[MAXN], lan[MAXN], accept[MAXN], like[MAXN], b[MAXN]; int cnt[MAXN]; int n, m, tmp, t; void discrete() { for (int i = 1; i <= tmp; i++) b[i] = lan[i]; sort(b + 1, b + tmp + 1); t = unique(b + 1, b + tmp + 1) - b - 1; } int query(int x) { return lower_bound(b + 1, b + 1 + t, x) - b; } int main() { cin >> n; for (int i = 1; i <= n; i++) { cin >> mem[i]; lan[++tmp] = mem[i]; } cin >> m; for (int i = 1; i <= m; i++) { cin >> like[i]; lan[++tmp] = like[i]; } for (int i = 1; i <= m; i++) { cin >> accept[i]; lan[++tmp] = accept[i]; } discrete(); for (int i = 1; i <= n; i++) cnt[query(mem[i])]++; int ans = 1, max1 = 0, max2 = 0; for (int i = 1; i <= m; i++) { int x = cnt[query(like[i])], y = cnt[query(accept[i])]; if (x > max1 || x == max1 && y > max2) { ans = i; max1 = x; max2 = y; } } printf("%d\n", ans); return 0; }
3
#include <bits/stdc++.h> using namespace std; int ans[2000][2000]; int main() { long long n, k, d, f = 0; cin >> n >> k >> d; long long x = 1; for (int i = 1; i <= d; i++) { x *= k; if (x >= n) { f = 1; break; } } if (!f) { cout << -1 << endl; return 0; } for (int i = 0; i < n; i++) { int l = i, j = 0; while (l > 0) { ans[j++][i] = l % k; l /= k; } } for (int i = 0; i < d; i++) { for (int j = 0; j < n; j++) cout << ans[i][j] + 1 << " "; cout << endl; } }
3
#include <bits/stdc++.h> using namespace std; long long B[4001], c[4001][4001], n, ans = 0; int main() { while (scanf("%d", &n) != EOF) { for (int i = 0; i <= n; i++) c[i][0] = 1; for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007; B[1] = 1; B[0] = 1; for (int i = 2; i <= n; i++) for (int k = 0; k < i; k++) B[i] = (B[i] + 1LL * c[i - 1][k] * B[k] % 1000000007) % 1000000007; for (int i = 1; i <= n; i++) ans = (ans + 1LL * c[n][i] * B[n - i] % 1000000007) % 1000000007; printf("%d\n", ans); } }
4
#include<bits/stdc++.h> using namespace std; int n; char s[1000100]; char t[1000100]; queue<int>q; int main() { scanf("%d",&n); scanf("%s",s+1); scanf("%s",t+1); int ans=0; for(int i=1;i<=n;++i) if(s[i]!=t[i]){ans=1;break;} if(!ans) { puts("0"); return 0; } for(int up=n,dn=n;dn;--dn) { while(t[dn-1]==t[dn])dn--; up=min(up,dn); while(s[up]!=t[dn]&&up)up--; if(!up) { puts("-1"); return 0; } while(!q.empty()) { if(q.front()-q.size()+1>dn)q.pop(); else break; } if(up!=dn)q.push(up); ans=max(ans,(int)q.size()+1); } printf("%d\n",ans); return 0; }
0
#include <bits/stdc++.h> int main() { long long int n, a, b, i, t; scanf("%lld %lld %lld", &n, &a, &b); t = n / a + 1; for (i = 0; i < t; i++) { if ((n - (a * i)) % b == 0 && n - (a * i) >= 0) { printf("YES\n%lld %lld", i, (n - (a * i)) / b); return 0; } } printf("NO"); return 0; }
2
#include <bits/stdc++.h> using namespace std; int n, msize = 0, head = 1, tail = 0; long long t[300010] = {0}, w[300010] = {0}, mheap[300010]; int mqueue[300010]; void insert_heap(long long key) { mheap[++msize] = key; long long tmp = mheap[msize]; int cur = msize, fc = msize / 2; while (cur > 1) { if (mheap[fc] <= tmp) break; mheap[cur] = mheap[fc]; cur = fc; fc = cur / 2; } mheap[cur] = tmp; } void del_heap(int x) { mheap[x] = mheap[msize--]; int cur = x, sc = x * 2; long long tmp = mheap[cur]; while (sc <= msize) { if (sc < msize && mheap[sc] > mheap[sc + 1]) sc++; if (tmp <= mheap[sc]) break; mheap[cur] = mheap[sc]; cur = sc; sc *= 2; } mheap[cur] = tmp; } bool cmp(int x, int y) { return t[x] > t[y]; } int work() { sort(mqueue + 1, mqueue + tail + 1, cmp); int ans = msize + 1; long long tmp = mheap[1]; while (t[1] >= tmp + 1 && msize > 0) { t[1] -= (tmp + 1); del_heap(1); while (t[mqueue[head]] > t[1] && head <= tail) { insert_heap(w[mqueue[head]] - t[mqueue[head]]); head++; } ans = min(ans, msize + 1); tmp = mheap[1]; } return ans; } int main() { scanf("%d", &n); for (int i = 1; i <= n; i++) { cin >> t[i] >> w[i]; if (i > 1 && t[i] <= t[1]) { mqueue[++tail] = i; } if (i > 1 && t[i] > t[1]) { insert_heap(w[i] - t[i]); } } printf("%d\n", work()); return 0; }
4
#include <bits/stdc++.h> using namespace std; vector<int> g[100010]; bool vis[100010]; double len[100010]; bool chk[100010]; void dfs(int s) { bool f = 0; for (int i = 0; i < g[s].size(); i++) { int j = g[s][i]; if (!vis[j]) f = 1; } if (!f) { chk[s] = 1; return; } for (int i = 0; i < g[s].size(); i++) { int j = g[s][i]; if (!vis[j]) { vis[j] = 1; len[j] = len[s] + 1; dfs(j); } } double sum = 0, ct = 0; bool ff = 0; for (int i = 0; i < g[s].size(); i++) { int j = g[s][i]; if (chk[j]) { sum += len[j]; ff = 1; ct++; } } if (ff) { chk[s] = 1; len[s] = sum / ct; } } int main() { int n; scanf("%d", &n); for (int i = 1; i < n; i++) { int a, b; scanf("%d%d", &a, &b); g[a].push_back(b); g[b].push_back(a); } memset(vis, 0, sizeof(vis)); vis[1] = 1; dfs(1); printf("%.15f", len[1]); return (0); }
3
#include <bits/stdc++.h> using namespace std; int main(){ int n; string s; cin>>n>>s; if(s.substr(0,n/2)==s.substr(n/2,n)&&n%2==0) cout<<"Yes"<<endl; else cout<<"No"<<endl; }
0
#include <bits/stdc++.h> using namespace std; long long mod = 1e6 + 3; long long inf = 1e18; double eps = 1e-2; ifstream in("input.txt"); ofstream out("output.txt"); int main() { int n, q; cin >> n >> q; string s; cin >> s; vector<vector<int>> links(n + 3, vector<int>(26, n + 1)); for (int i = n - 1; i >= 0; i--) { for (int j = 0; j < 26; j++) { links[i][j] = links[i + 1][j]; } links[i][s[i] - 'a'] = i; } string s1, s2, s3; vector<vector<vector<int>>> dp( 251, vector<vector<int>>(251, vector<int>(251, n + 2))); dp[0][0][0] = 0; int a = 0, b = 0, c = 0; for (int w = 0; w < q; w++) { char ch; cin >> ch; int t; cin >> t; if (ch == '+') { cin >> ch; if (t == 1) { s1.push_back(ch); a++; for (int i = 0; i <= b; i++) { for (int j = 0; j <= c; j++) { dp[a][i][j] = links[dp[a - 1][i][j]][ch - 'a'] + 1; if (i > 0) dp[a][i][j] = min(dp[a][i][j], links[dp[a][i - 1][j]][s2[i - 1] - 'a'] + 1); if (j > 0) dp[a][i][j] = min(dp[a][i][j], links[dp[a][i][j - 1]][s3[j - 1] - 'a'] + 1); } } } if (t == 2) { s2.push_back(ch); b++; for (int i = 0; i <= a; i++) { for (int j = 0; j <= c; j++) { dp[i][b][j] = links[dp[i][b - 1][j]][ch - 'a'] + 1; if (i > 0) dp[i][b][j] = min(dp[i][b][j], links[dp[i - 1][b][j]][s1[i - 1] - 'a'] + 1); if (j > 0) dp[i][b][j] = min(dp[i][b][j], links[dp[i][b][j - 1]][s3[j - 1] - 'a'] + 1); } } } if (t == 3) { s3.push_back(ch); c++; for (int i = 0; i <= a; i++) { for (int j = 0; j <= b; j++) { dp[i][j][c] = links[dp[i][j][c - 1]][ch - 'a'] + 1; if (i > 0) dp[i][j][c] = min(dp[i][j][c], links[dp[i - 1][j][c]][s1[i - 1] - 'a'] + 1); if (j > 0) dp[i][j][c] = min(dp[i][j][c], links[dp[i][j - 1][c]][s2[j - 1] - 'a'] + 1); } } } } else { if (t == 1) { for (int i = 0; i <= b; i++) { for (int j = 0; j <= c; j++) { dp[a][i][j] = n + 2; } } s1.pop_back(); a--; } if (t == 2) { for (int i = 0; i <= a; i++) { for (int j = 0; j <= c; j++) { dp[i][b][j] = n + 2; } } s2.pop_back(); b--; } if (t == 3) { for (int i = 0; i <= a; i++) { for (int j = 0; j <= b; j++) { dp[i][j][c] = n + 2; } } s3.pop_back(); c--; } } if (dp[a][b][c] != n + 2) { cout << "YES" << endl; } else { cout << "NO" << endl; } } return 0; }
2
#include <bits/stdc++.h> using namespace std; int read() { int x = 0, sgn = 1; char ch = getchar(); for (; !isdigit(ch); ch = getchar()) if (ch == '-') sgn = -1; for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48); return x * sgn; } const int N = 3e5 + 10; int h[N], cnt, deg[N], m, n, f[N], u[N], v[N]; bool cannot[N]; struct edge { int v, nxt; } e[N << 1]; void link(int x, int y) { e[++cnt] = (edge){y, h[x]}; h[x] = cnt; deg[y]++; } void check(int x, int y, int w) { for (int i = h[y], t; i; i = e[i].nxt) { t = e[i].v; if (deg[t] == 1) return cannot[x] = 1, void(); } f[x] += w; } void topsort() { int tot = 0; queue<int> q; for (int i = 1; i <= n; i++) if (!deg[i]) q.push(i), tot++; while (q.size()) { int x = q.front(); q.pop(); if (!q.size()) f[x] += n - tot; if (q.size() == 1) check(x, q.front(), n - tot); for (int i = h[x], y; i; i = e[i].nxt) { y = e[i].v; deg[y]--; if (!deg[y]) q.push(y), tot++; } } } int main() { n = read(), m = read(); for (int i = 1; i <= m; i++) { u[i] = read(), v[i] = read(); link(u[i], v[i]); } topsort(); memset(h, 0, sizeof(h)); memset(deg, 0, sizeof(deg)); cnt = 0; for (int i = 1; i <= m; i++) link(v[i], u[i]); topsort(); int ans = 0; for (int i = 1; i <= n; i++) if (!cannot[i] && f[i] >= n - 2) ans++; printf("%d\n", ans); return 0; }
6
#include <cstdio> #include <cstring> #include <algorithm> #define fo(i,a,b) for(int i=a;i<=b;i++) #define fd(i,a,b) for(int i=a;i>=b;i--) #define rep(i,a) for(int i=lst[a];i;i=nxt[i]) #define mp(a,b) make_pair(a,b) using namespace std; typedef pair<int,int> pii; #define fi first #define se second int read() { char ch; for(ch=getchar();ch<'0'||ch>'9';ch=getchar()); int x=ch-'0'; for(ch=getchar();ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0'; return x; } const int N=2e3+5; int t[N<<1],nxt[N<<1],lst[N],l; void add(int x,int y) {t[++l]=y;nxt[l]=lst[x];lst[x]=l;} int n,m,deg[N],fa[N][11],dep[N],c[N],u[N],v[N],p[N]; bool col[N],ban[N]; pii now[N]; void dfs(int x,int y) { dep[x]=dep[y]+1;fa[x][0]=y; rep(i,x) if (t[i]!=y) dfs(t[i],x); } int lca(int x,int y) { if (dep[x]<dep[y]) swap(x,y); fd(j,10,0) if (dep[fa[x][j]]>dep[y]) x=fa[x][j]; x=dep[x]==dep[y]?x:fa[x][0]; fd(j,10,0) if (fa[x][j]!=fa[y][j]) x=fa[x][j],y=fa[y][j]; return x==y?x:fa[x][0]; } void calc(int x,int y) {rep(i,x) if (t[i]!=y) calc(t[i],x),c[x]+=c[t[i]];} int main() { n=read();m=read(); fo(i,1,n-1) { int x=read(),y=read(); add(x,y);add(y,x); deg[x]++;deg[y]++; } dfs(1,0); fo(j,1,10) fo(i,1,n) fa[i][j]=fa[fa[i][j-1]][j-1]; fo(i,1,m) { u[i]=read(),v[i]=read(); int z=lca(u[i],v[i]); c[u[i]]++;c[v[i]]++;c[z]-=2; } calc(1,0); fo(i,1,m) now[i]=mp(u[i],v[i]); int ans=0; fo(i,1,n) ans+=min(c[i],2); printf("%d\n",ans); fo(tim,1,n-1) { int x,y; fo(i,2,n) if (!ban[i]&&deg[i]==1) {x=i;break;} rep(j,x) if (!ban[t[j]]) y=t[j]; ban[x]=1;deg[y]--; int p1=0,p2=0; fo(i,1,m) if ((now[i].fi==x)^(now[i].se==x)) { if (!p1) p1=i; else if (!p2) p2=i; } if (!p1) continue; if (!p2) { if (now[p1].fi==x) now[p1].fi=y; else now[p1].se=y; continue; } if (now[p1].fi==x) { if (now[p2].fi==x) { now[p1].fi=now[p2].se; col[p2]^=1; } else now[p1].fi=now[p2].fi; } else { if (now[p2].se==x) { now[p1].se=now[p2].fi; col[p2]^=1; } else now[p1].se=now[p2].se; } p[p2]=p1;now[p2].fi=now[p2].se; fo(i,1,m) { if (now[i].fi==x) now[i].fi=y; if (now[i].se==x) now[i].se=y; } } fo(i,1,m) if (p[i]) col[i]^=col[p[i]]; fo(i,1,m) { if (col[i]) swap(u[i],v[i]); printf("%d %d\n",u[i],v[i]); } return 0; }
0
#include <iostream> #include <vector> #include <algorithm> using namespace std; struct BIT { int n; vector<int> v; BIT(int n) : v(n+1) { this->n = n; } void add(int a, int x) { for (int i = a; i <= n; i += i & -i) v[i] += x; } int sum(int a) { int res = 0; for (int i = a; i > 0; i -= i & -i) res += v[i]; return res; } }; int main() { cin.tie(0); ios::sync_with_stdio(false); int N; cin >> N; vector<int> a(N); int maxA = 0; for (int i = 0; i < N; i++) { cin >> a[i]; maxA = max(maxA, a[i]); } long long ml = (1LL + N) * N / 2; int low = 0, high = maxA+1; while (high - low > 1) { int mid = (low + high) / 2; BIT bit(N*2+2); int cs = N+1; long long res = 0; bit.add(cs, 1); for (int i = 0; i < N; i++) { cs += a[i] < mid ? -1 : 1; res += bit.sum(cs); bit.add(cs, 1); } if (res >= (ml+1)/2) low = mid; else high = mid; } cout << low << "\n"; }
0
#include <bits/stdc++.h> using namespace std; char in[10]; int res = 10; void dfs(int sum1, int sum2, int nm, int cur) { if (cur == 6) { if (sum1 == sum2) res = min(res, nm); return; } for (int i = 0; i < 10; i++) if (cur < 3) dfs(sum1 + i, sum2, nm + (i != in[cur] - '0'), cur + 1); else dfs(sum1, sum2 + i, nm + (i != in[cur] - '0'), cur + 1); } int main() { ios_base::sync_with_stdio(0); for (int i = 0; i < 6; i++) { cin >> in[i]; } dfs(0, 0, 0, 0); cout << res << "\n"; return 0; }
2
#include<bits/stdc++.h> using namespace std; int main(){ int a,b,c;cin>>a>>b>>c; int x=7*a+b,cnt=0; cnt+=c/x*7;int y=c%x;if(y>0)cnt+=min((y-1+a)/a,7); cout<<cnt<<endl; }
0
#include <bits/stdc++.h> using namespace std; map<long long, long long> m; long long a[10004]; long long f(long long a, long long b) { m[a]--; m[b]--; vector<long long> v; v.push_back(a); v.push_back(b); long long x = b; long long y = a + b; while (m[y] != 0) { m[y]--; v.push_back(y); y = x + y; x = y - x; } for (long long i = 0; i < v.size(); i++) m[v[i]]++; return v.size(); } signed main() { long long n, ans; cin >> n; for (long long i = 0; i < n; i++) { cin >> a[i]; m[a[i]]++; } ans = -1; for (long long i = 0; i < n; i++) { for (long long j = 0; j < n; j++) { if (i != j) { if (a[i] == a[j] && !a[i]) ans = max(ans, m[0]); else { ans = max(ans, f(a[i], a[j])); } } } } cout << ans << endl; }
4
#include <bits/stdc++.h> int main() { int q; scanf("%d", &q); while (q--) { long long a, b, c; scanf("%lld%lld%lld", &a, &b, &c); printf("%lld\n", (a + b + c) / 2); } return 0; }
1
#include <bits/stdc++.h> using namespace std; const unsigned long long mod = 1e9 + 7; template <class S, class T> ostream& operator<<(ostream& os, const pair<S, T> v) { os << "(" << v.first << ", " << v.second << ")"; return os; } template <class T> ostream& operator<<(ostream& os, const vector<T> v) { for (int i = 0; i < v.size(); i++) { if (i > 0) { os << " "; } os << v[i]; } return os; } template <class T> ostream& operator<<(ostream& os, const vector<vector<T>> v) { for (int i = 0; i < v.size(); i++) { if (i > 0) { os << endl; } os << v[i]; } return os; } struct point { long long id, x, y, z; bool operator<(const point& right) const { if (x == right.x) { if (y == right.y) { return z < right.z; } else { return y < right.y; } } else { return x < right.x; } } }; long long dist(point& p1, point& p2) { long long dx = abs(p1.x - p2.x); long long dy = abs(p1.y - p2.y); long long dz = abs(p1.z - p2.z); return dx + dy + dz; } int main() { cin.tie(0); ios::sync_with_stdio(false); long long n; cin >> n; vector<point> P; vector<point> Q; vector<point> R; for (int i = 0; i < (int)n; ++i) { long long x, y, z; cin >> x >> y >> z; point p = {i, x, y, z}; P.push_back(p); } sort(P.begin(), P.end()); for (int i = 0; i < (int)n; ++i) { int j = i; while (j < n && P[i].x == P[j].x && P[i].y == P[j].y) j++; int len = j - i; for (int k = 0; k < (int)len / 2; ++k) { cout << P[i + 2 * k].id + 1 << " " << P[i + 2 * k + 1].id + 1 << endl; } if (len % 2 == 1) Q.push_back(P[i + len - 1]); i = j - 1; } sort(Q.begin(), Q.end()); long long m = Q.size(); for (int i = 0; i < (int)m; ++i) { int j = i; while (j < m && Q[i].x == Q[j].x) j++; int len = j - i; for (int k = 0; k < (int)len / 2; ++k) { cout << Q[i + 2 * k].id + 1 << " " << Q[i + 2 * k + 1].id + 1 << endl; } if (len % 2 == 1) R.push_back(Q[i + len - 1]); i = j - 1; } for (int i = 0; i < (int)R.size() / 2; ++i) { cout << R[2 * i].id + 1 << " " << R[2 * i + 1].id + 1 << endl; } return 0; }
3
#include <algorithm> #include <cmath> #include <iomanip> #include <iostream> #include <queue> using namespace std; struct Node { double x, y, r; Node(double x, double y, double r) : x(x), y(y), r(r) {} }; int n, k; vector<int> x, y, c; double distance(double px, double py) { vector<double> dis(n); for (int i = 0; i < n; ++i) { dis[i] = c[i] * hypot(px - x[i], py - y[i]); } nth_element(dis.begin(), dis.begin() + k - 1, dis.end()); return dis[k - 1]; } double distance_lb(double px, double py, double r) { vector<double> dis(n); for (int i = 0; i < n; ++i) { dis[i] = c[i] * hypot(max(abs(px - x[i]) - r, 0.0), max(abs(py - y[i]) - r, 0.0)); } nth_element(dis.begin(), dis.begin() + k - 1, dis.end()); return dis[k - 1]; } int main() { cin >> n >> k; x.resize(n); y.resize(n); c.resize(n); for (int i = 0; i < n; ++i) { cin >> x[i] >> y[i] >> c[i]; } queue<Node> que; double res = distance(0, 0); que.emplace(0, 0, 1000); while (!que.empty()) { auto node = que.front(); que.pop(); for (double dx : {-0.5, 0.5}) { for (double dy : {-0.5, 0.5}) { double nx = node.x + dx * node.r, ny = node.y + dy * node.r, nr = node.r / 2; double dis_lb = distance_lb(nx, ny, nr); if (res - dis_lb > 5e-7 * max(1.0, dis_lb)) { res = min(res, distance(nx, ny)); que.emplace(nx, ny, nr); } } } } cout << fixed << setprecision(15) << res << endl; }
0