solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
int a = (k + 1) / 2;
int r = (a - 1) / m + 1;
int c = (a - 1) % m + 1;
cout << r << ' ' << c << ' ';
cout << ((k % 2 == 0) ? "R" : "L") << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int INF = 0x3f3f3f3f;
using namespace std;
int n;
long long a[9], sum[(1 << (8))];
int dp[(1 << (8))][(1 << (8))], cnt[(1 << (8))];
map<long long, int> h;
int prim[N], pn;
bool isPrim[N];
void make_prim() {
memset(isPrim, 1, sizeof(isPrim));
pn = 0;
for (int i = 2; i < N; i++) {
if (isPrim[i]) prim[pn++] = i;
for (int j = 0; prim[j] * i < N && j < pn; j++) {
isPrim[prim[j] * i] = 0;
if (i % prim[j]) break;
}
}
}
int work(long long x) {
long long t = x;
if (h.find(x) != h.end()) return h[x];
int ret = 0;
for (int i = 0; 1ll * prim[i] * prim[i] <= x; i++) {
while (x % prim[i] == 0) ret++, x /= prim[i];
}
if (x > 1) ret++;
return h[t] = ret;
}
int dfs(int x, int y) {
int& ret = dp[x][y];
if (ret + 1) return ret;
ret = 0;
if ((x | y) == (1 << n) - 1) {
for (int i = 0; i < n; i++)
if ((y & (1 << i)) && work(a[i]) > 1) ret += work(a[i]);
return ret;
}
ret = INF;
for (int k = 0; k < n; k++) {
if ((y & (1 << k)) == 0) continue;
for (int i = 1; i < (1 << n); i++) {
if ((x | y) & i) continue;
if (a[k] % sum[i]) continue;
int tx = x | (1 << k);
int ty = y ^ (1 << k);
ty |= i;
ret = min(ret, dfs(tx, ty) + work(a[k] / sum[i]) + cnt[i]);
}
}
return ret;
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < (1 << n); i++) {
sum[i] = 1;
cnt[i] = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) {
if (1.0 * sum[i] * a[j] > 1e13)
sum[i] = 1e13;
else
sum[i] = sum[i] * a[j];
cnt[i]++;
}
}
memset(dp, -1, sizeof(dp));
int ret = INF;
for (int i = 1; i < (1 << n); i++) {
int t = dfs(0, i) + cnt[i];
if (cnt[i] > 1) t++;
ret = min(ret, t);
}
cout << ret << endl;
}
int main() {
make_prim();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char last;
int c0 = 0, c1 = 0, cx = 0;
while (cin >> last) {
if (last == '0')
c0++;
else if (last == '1')
c1++;
else
cx++;
}
if (c0 + cx > c1) cout << "00\n";
if (last == '1' && c1 + cx >= c0 && c0 + cx >= c1 - 1)
cout << "01\n";
else if (last == '?' && c1 + cx >= c0 && c0 + cx - 1 >= c1)
cout << "01\n";
if (last == '0' && c1 + cx >= c0 && c0 + cx >= c1 - 1)
cout << "10\n";
else if (last == '?' && c1 + cx - 1 >= c0 + 1 && c0 + cx >= c1 - 1)
cout << "10\n";
if (c1 + cx > c0 + 1) cout << "11\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 10;
char str[maxn];
long long N;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> str + 1;
N = strlen(str + 1);
long long pos = 1;
vector<long long> v;
while (pos <= N) {
long long num = 0;
while (pos <= N && str[pos] != ',') {
num = num * 10 + str[pos] - '0';
++pos;
}
++pos;
v.push_back(num);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
vector<pair<long long, long long> > stk;
for (long long i = 0; i < v.size(); ++i) {
if (stk.empty() || stk.back().second + 1 != v[i]) {
stk.push_back({v[i], v[i]});
} else {
pair<long long, long long> top = stk.back();
stk.pop_back();
stk.push_back({top.first, top.second + 1});
}
}
for (long long i = 0; i < stk.size(); ++i) {
pair<long long, long long> now = stk[i];
if (now.first == now.second) {
cout << now.first;
} else {
cout << now.first << "-" << now.second;
}
if (i == (long long)stk.size() - 1) {
cout << endl;
} else {
cout << ",";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, a;
scanf("%I64d%I64d%I64d", &n, &m, &k);
if (n + m - 2 < k)
printf("-1");
else {
if (n > m) {
a = n;
n = m;
m = a;
}
if (n >= k + 1) {
printf("%I64d", max((m / (k + 1)) * n, (n / (k + 1)) * m));
} else {
if (m >= k + 1)
printf("%I64d", (m / (k + 1)) * n);
else
printf("%I64d", n / (k - m + 2));
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, B[36];
long long N[4],
A[36] = {2, 1, 4, 3, 1, 1, 1, 1,
1, 5, 10, 200, 500, 10000, 50000, 100000,
200000, 1002, 2, 10002, 2, 200000, 2, 99,
9955, 199752, 200000, 200000, 199316, 200000, 8, 149253,
149252, 148505, 149479, 169995},
C[36],
H[36] = {25,
125,
230,
120,
27,
26,
2000000000000000000,
2,
52,
53,
207,
6699,
6812,
622832834,
620189650,
624668154,
625406094,
12972,
12972,
216245,
216245,
240314083,
240314083,
122973,
1038071,
20203527703,
19018621728,
247432457339710,
229533246298127,
20929602014808,
7900,
17544094280356,
17544044596722,
17469733613212,
27728032700840,
221336290388556};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
B[1] = 1;
C[1] = 2;
B[4] = 3;
C[4] = 2;
B[5] = 3;
C[5] = 4;
B[6] = 2;
C[6] = 1000000000000000000;
B[7] = 2;
C[7] = 1000000;
B[0] = 1;
C[0] = 1;
B[18] = 1;
C[18] = 1002;
B[20] = 1;
C[20] = 10002;
B[16] = 1;
C[16] = 200000;
B[21] = 1;
C[21] = 2;
B[22] = 1;
C[22] = 200000;
B[26] = 1;
C[26] = 199990;
B[27] = 1;
C[27] = 199907;
for (i = 0; i < 4; i++) {
cin >> N[i];
}
for (i = 0; 1; i++) {
if (N[0] == A[i] && (B[i] == 0 || N[B[i]] == C[i])) {
cout << H[i] << '\n';
return 0;
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long MOD1 = 998244353;
const long long MIN_LL = -1e18;
const long long MAX_LL = 1e18;
const int MAX_INT = 1e9;
const int MIN_INT = -1e9;
const long double pie = 3.1415926535;
long long fpow(long long n, long long p) {
;
long long m = 1;
while (p) {
if (p % 2) m *= n;
p >>= 1;
n *= n;
}
return m;
}
long long mfpow(long long n, long long p, long long M) {
long long m = 1;
n %= M;
while (p) {
if (p % 2) m = (m * n) % M;
n = (n * n) % M;
p >>= 1;
}
return m % M;
}
long long invmod(long long n, long long m) { return mfpow(n, m - 2, m); }
const vector<long long> days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool br, br1, br2;
char ch, ch1, ch2;
long long n, m, k, x, y, z, d, mini, maxi, l, r, sum, t, w, h;
pair<long long, long long> p, p1, p2;
string s, s1, s2, s3;
multiset<long long> mst;
set<long long> st, st1, st2, st3;
map<long long, long long> mp, mp1, mp2;
vector<long long> v, v1, v2;
void solve() {
cin >> n;
v.resize(n);
for (auto &i : v) cin >> i;
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i + 2 < n && v[i] == v[i + 2]) br = true;
if (i && v[i - 1] == v[i])
v2.push_back(v[i]);
else
v1.push_back(v[i]);
}
cout << (br ? "NO" : "YES") << endl;
if (!br) {
cout << v1.size() << endl;
for (auto i : v1) cout << i << " ";
cout << endl;
sort(v2.begin(), v2.end(), greater<long long>());
cout << v2.size() << endl;
for (auto i : v2) cout << i << " ";
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct aaa {
long long x, w;
} a[500010];
long long D, mx, m, ans, la, f[500010], nt[500010];
bool cmp(aaa a, aaa b) { return a.x < b.x; }
long long lowbit(long long x) { return x & (-x); }
void ins(long long x, long long w) {
long long i;
for (i = x; i <= m; i += lowbit(i)) f[i] = min(f[i], w);
}
long long query(long long x) {
long long i, xlh = 1e17;
for (i = x; i; i -= lowbit(i)) xlh = min(xlh, f[i]);
return xlh;
}
int main() {
long long i, l, r, mid, mn;
scanf("%lld%lld%lld", &D, &mx, &m);
for (i = 1; i <= m; i++) scanf("%lld%lld", &a[i].x, &a[i].w);
sort(a + 1, a + m + 1, cmp);
a[++m].x = D;
memset(f, 44, sizeof(f));
for (i = 1; i <= m; i++)
if (a[i].x - a[i - 1].x > mx) return puts("-1"), 0;
la = mx - a[1].x;
for (i = m; i; i--) {
l = i + 1;
r = m;
mn = m + 1;
while (l <= r) {
mid = (l + r) / 2;
if (query(mid) < a[i].w) {
mn = mid;
r = mid - 1;
} else
l = mid + 1;
}
nt[i] = mn;
ins(i, a[i].w);
}
i = 1;
while (i < m) {
mn = nt[i];
if (mn <= m && a[mn].x - a[i].x <= mx) {
ans += a[i].w * max(a[mn].x - a[i].x - la, 0ll);
la = max(0ll, la - (a[mn].x - a[i].x));
i = nt[i];
} else {
ans += a[i].w * (mx - la);
la = mx - a[i + 1].x + a[i].x;
i++;
}
}
printf("%lld", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> primes;
void GeneratingPrimes(int top) {
vector<bool> p(top + 1, 1);
p[0] = p[1] = 0;
for (int i = 2; i <= sqrt(top); i++) {
if (p[i]) {
for (int j = i * i; j <= top; j += i) {
p[j] = 0;
}
}
}
for (int i = 0; i < top + 1; i++)
if (p[i]) primes.push_back(i);
}
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
long long POW(long long x, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret *= x;
x *= x;
p /= 2;
}
return ret;
}
int main() {
int n;
cin >> n;
vector<int> v(n);
vector<pair<int, int>> per;
for (int i = 0; i < n; i++) scanf("%d", &v[i]);
int maxiP = 0;
for (int i = 1; i < n - 1; i++) {
int j = i;
while (j < n - 1 && v[j] != v[j + 1] && v[j] != v[j - 1]) {
j++;
}
maxiP = max(maxiP, j - i);
if (i != j) per.push_back(make_pair(i, j - 1));
i = j;
}
cout << ceil(maxiP / 2.0) << endl;
for (int i = 0; i < per.size(); i++) {
pair<int, int> p = per[i];
if (v[p.first - 1] == v[p.second + 1]) {
for (int j = p.first; j <= per[i].second; j++) v[j] = v[j - 1];
} else {
int x = v[p.first - 1];
for (int j = p.first; j <= (p.first + p.second) / 2; j++) v[j] = x;
for (int j = (p.first + p.second) / 2 + 1; j <= p.second; j++) v[j] = !x;
}
}
for (int x : v) cout << x << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int veci[100003];
int cal() {
int t, k, c = 0, cc = 0;
scanf("%d%d", &t, &k);
for (int i = 0; i < t; i++) scanf("%d", &veci[i]);
for (int i = k; i < t; i++)
if (veci[i] != veci[i - 1]) return -1;
if (k == 1 && (veci[0] == veci[1] || t == 1)) return 0;
int i = k - 2;
for (; i >= 0 && c != -1; i--)
if (veci[i] != veci[k - 1]) break;
return i + 1;
}
int main() { cout << cal(); }
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
void sadd(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int add(int a, int b) {
sadd(a, b);
return a;
}
int mul(int a, int b) { return (a * 1LL * b) % MOD; }
int fpow(int x, long long n) {
if (n == 0) return 1;
int a = fpow(x, n >> 1);
a = mul(a, a);
if (n & 1) a = mul(a, x);
return a;
}
int rev(int x) { return fpow(x, MOD - 2); }
int divi(int a, int b) { return mul(a, rev(b)); }
const int N = (int)2e5 + 100;
int fact[N], rfact[N], ri[N];
void init() {
fact[0] = 1;
rfact[0] = 1;
ri[1] = 1;
for (int i = 1; i < N; i++) {
fact[i] = mul(fact[i - 1], i);
if (i > 1) ri[i] = mul(MOD / i, MOD - ri[MOD % i]);
rfact[i] = mul(rfact[i - 1], ri[i]);
}
}
int C(int n, int k) {
if (n < 0 || k < 0 || k > n) return 0;
int ans = mul(fact[n], mul(rfact[k], rfact[n - k]));
return ans;
}
int CNT(int n, int k) {
if (k == 0 && n > 0) return 0;
if (k == 0 && n == 0) return 1;
return C(n + k - 1, n);
}
int solve(int f, int w, int h) {
int ans = 0;
for (int kf = 0; kf <= f; kf++) {
long long takef = kf;
long long remf = f - takef;
if (remf < 0) continue;
for (int kw = kf - 1; kw <= kf + 1; kw++) {
if (kw < 0 || kw > w) continue;
long long takew = kw * 1LL * (h + 1);
long long remw = w - takew;
if (remw < 0) continue;
int Cf = CNT(remf, kf);
int Cw = CNT(remw, kw);
int cur = mul(Cf, Cw);
sadd(ans, cur);
if (kf == kw) sadd(ans, cur);
}
}
return ans;
}
int main(int, char **) {
init();
int f, w, h;
scanf("%d%d%d", &f, &w, &h);
int good = solve(f, w, h);
int all = solve(f, w, 0);
int ans = divi(good, all);
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
vector<long long> g[N];
long long a[N], pos[N], neg[N];
void dfs(long long node, long long par) {
for (auto it : g[node]) {
if (it == par) continue;
dfs(it, node);
pos[node] = max(pos[node], pos[it]);
neg[node] = max(neg[node], neg[it]);
}
a[node] -= pos[node];
a[node] += neg[node];
pos[node] += max(0LL, a[node]);
neg[node] += max(0LL, -1 * a[node]);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
long long n;
cin >> n;
for (long long i = 1; i < n; i++) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (long long i = 1; i <= n; i++) cin >> a[i];
dfs(1, 1);
cout << pos[1] + neg[1] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int f = 1;
char k = getchar();
x = 0;
for (; k > '9' || k < '0'; k = getchar())
if (k == '-') f = -1;
for (; k >= '0' && k <= '9'; k = getchar()) x = x * 10 + k - '0';
x *= f;
}
int a, b, c, d;
int main() {
read(a);
read(b);
read(c);
read(d);
printf("%d", ((a ^ b) & (c | d)) ^ ((b & c) | (a ^ d)));
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int IT_MAX;
const int MOD = 1000000007;
const int INF = 1034567891;
const long long LL_INF = 2234567890123456789ll;
const double PI = 3.141592653589793238;
int in[100050];
int main() {
int N, K, i;
int gr = 0;
scanf("%d %d", &N, &K);
if (K % 2 == 0) {
for (i = 1; i <= N; i++) {
scanf("%d", &in[i]);
if (in[i] == 1)
gr ^= 1;
else if (in[i] == 2)
gr ^= 2;
else if (in[i] % 2 == 0)
gr ^= 1;
}
if (gr)
printf("Kevin\n");
else
printf("Nicky\n");
return 0;
} else {
for (i = 1; i <= N; i++) {
scanf("%d", &in[i]);
if (in[i] == 1) {
gr ^= 1;
continue;
} else if (in[i] == 3) {
gr ^= 1;
continue;
} else if (in[i] == 2 || in[i] % 2 == 1)
continue;
int v = 0, t = in[i];
while (t % 2 == 0) {
v++;
t /= 2;
}
if (t == 3) {
if (v % 2 == 0)
gr ^= 1;
else
gr ^= 2;
} else {
if (v % 2 == 1)
gr ^= 1;
else
gr ^= 2;
}
}
if (gr)
printf("Kevin\n");
else
printf("Nicky\n");
return 0;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> val(8, INT_MAX);
val[0] = 0;
while (n--) {
long long x, y = 0;
string s;
cin >> x >> s;
for (char c : s) {
if (c == 'A')
y++;
else if (c == 'B')
y += 2;
else
y += 4;
}
val[y] = min(val[y], x);
}
long long ans = INT_MAX;
for (long long i = 0; i < 8; i++)
for (long long j = 0; j < 8; j++)
for (long long k = 0; k < 8; k++) {
if ((i | j | k) == 7) ans = min(ans, val[i] + val[j] + val[k]);
}
if (ans == INT_MAX) {
ans = -1;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char inp[1003][1003];
int n, m, mx = 0, ans;
map<pair<int, int>, int> memo;
int DFS(int i, int j, int cur, int val, int vall) {
if (i > n - 1 || j > m - 1 || j < 0 || i < 0) return 0;
if (cur == 4) val++, vall++;
int res = 0, con = val, ans1 = 0, ans2 = 0, ans3 = 0, ans4 = 0;
if (memo[make_pair(i, j)]) return memo[make_pair(i, j)];
if (vall > n * m / 4) return val;
char nxt;
if (cur == 1)
nxt = 'I', cur++;
else if (cur == 2)
nxt = 'M', cur++;
else if (cur == 3)
nxt = 'A', cur++;
else if (cur == 4)
nxt = 'D', cur = 1, val = 0;
if (inp[i][j + 1] == nxt) ans1 = DFS(i, j + 1, cur, val, vall);
if (inp[i][j - 1] == nxt) ans2 = DFS(i, j - 1, cur, val, vall);
if (inp[i + 1][j] == nxt) ans3 = DFS(i + 1, j, cur, val, vall);
if (inp[i - 1][j] == nxt) ans4 = DFS(i - 1, j, cur, val, vall);
int MAX = max(max(ans1, ans2), max(ans3, ans4));
memo[make_pair(i, j)] = MAX;
return MAX + con;
}
int main() {
cin >> n >> m;
string s;
for (int i = 0; i < n; i++) cin >> inp[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (inp[i][j] == 'D') ans = DFS(i, j, 1, 0, 0);
if (ans > n * m / 4) {
cout << "Poor Inna!" << endl;
return 0;
} else
mx = max(mx, ans);
}
if (!mx)
puts("Poor Dima!");
else
cout << mx << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n, p;
cin >> n;
long long x[n];
for (long long i = 0; i < n; i++) {
cin >> x[i];
}
long long q = n - 1;
while (q - 1 >= 0 && x[q - 1] >= x[q]) q--;
while (q - 1 >= 0 && x[q - 1] <= x[q]) q--;
cout << q << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<string> v;
map<string, int> mp;
int main() {
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = n - 1; i >= 0; i--) {
if (mp[s[i]] == 0) {
v.push_back(s[i]);
}
mp[s[i]]++;
}
for (int i = 0; i < v.size(); i++) {
cout << v[i] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long p2u(unsigned long long u) {
if (u == 0) return 1;
if (u == 1) return 2;
unsigned long long v = p2u(u / 2);
v %= 1000000009;
v *= v;
v %= 1000000009;
if (u % 2) {
v *= 2;
v %= 1000000009;
}
return v;
}
int main() {
unsigned long long n, m, k;
cin >> n >> m >> k;
unsigned long long km = k * m, vn = (k - 1) * n,
y = (km < vn) ? 0 : (km - vn) / k, pu = p2u(y + 1),
qu = pu < 2 ? pu + 1000000009 - 2 : pu - 2,
r = k * qu + (m - k * y);
cout << (r % 1000000009) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1048577;
int n, m, s, sz, cnt;
double ans;
long long f[maxn], bin[55];
double dp[maxn];
char c[55][25];
int main() {
bin[0] = 1;
for (int i = 1; i <= 50; i++) bin[i] = bin[i - 1] << 1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s", c[i] + 1);
m = strlen(c[1] + 1);
sz = bin[m] - 1;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
s = 0;
for (int k = 1; k <= m; k++)
if (c[i][k] == c[j][k]) s |= bin[k - 1];
f[s] |= (bin[i - 1] | bin[j - 1]);
}
for (int i = sz; i >= 0; i--)
for (int j = 0; j < m; j++)
if (i & bin[j]) f[i ^ bin[j]] |= f[i];
dp[0] = 1;
for (int i = 0; i <= sz; i++) {
cnt = 0;
for (int j = 0; j < m; j++)
if (i & bin[j]) cnt++;
for (int j = 0; j < m; j++)
if (!(i & bin[j])) dp[i | bin[j]] += dp[i] / (double)(m - cnt);
for (int j = 0; j < n; j++)
if (f[i] & bin[j]) ans += dp[i];
}
printf("%.15f\n", ans / (double)n);
return 0;
}
| 9 |
#include <bits/stdc++.h>
char a[100010], b[100010];
int main() {
scanf("%s", a);
scanf("%s", b);
int dif4 = 0, dif7 = 0, dif = 0;
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] != b[i]) {
if (a[i] == '4') {
if (dif7 != 0) {
dif7--;
dif++;
} else
dif4++;
}
if (a[i] == '7') {
if (dif4 != 0) {
dif4--;
dif++;
} else
dif7++;
}
}
}
printf("%d", dif + dif4 + dif7);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int a, b, pos;
double w;
};
edge e[100005];
edge e1[100005];
int f[100005];
int ans[100005];
int n, m, k, i, now, a, b;
double l = -1e6, r = 1e6, mid;
bool operator<(edge e, edge e1) { return e.w < e1.w; }
int find(int x) {
if (f[x] == 0) return x;
f[x] = find(f[x]);
return f[x];
}
int kruskal() {
int i, t = 0, now = 0;
for (i = 1; i <= m; ++i) {
e1[i] = e[i];
e1[i].a == 1 ? e1[i].w += mid : 0;
}
memset(f, 0, sizeof(f));
sort(e1 + 1, e1 + m + 1);
for (i = 1; i <= m; ++i) {
a = find(e1[i].a), b = find(e1[i].b);
if (a != b) {
ans[++t] = e1[i].pos;
now += e1[i].a == 1;
f[a] = b;
}
}
return now;
}
int main() {
int i;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= m; ++i) {
scanf("%d%d%lf", &e[i].a, &e[i].b, &e[i].w);
if (e[i].a > e[i].b) swap(e[i].a, e[i].b);
e[i].pos = i;
}
while (l < r) {
mid = (l + r) / 2;
now = kruskal();
if (now == k) break;
if (now < k)
r = mid;
else
l = mid;
}
if (now == k) {
printf("%d\n", n - 1);
for (i = 1; i < n; ++i) printf("%d ", ans[i]);
} else
printf("-1\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0;
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
return x * f;
}
void print(long long x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 1010;
int n, m, a, b;
int f[N][N][20], h[N][N], lg[N], ans1[N * N], ans2[N * N];
long long sum[N][N], val[N][N], ans3[N * N];
multiset<long long> s;
pair<int, int> ans[N * N];
bool book[N][N];
long long query(int p, int l, int r) {
int k = lg[r - l + 1];
return min(f[p][l][k], f[p][r - (1 << k) + 1][k]);
}
int main() {
n = read(), m = read(), a = read(), b = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) h[i][j] = f[i][j][0] = read();
lg[0] = -1;
for (int i = 1; i <= n; i++) lg[i] = lg[i >> 1] + 1;
for (int p = 1; p <= n; p++)
for (int j = 1; j <= 10; j++)
for (int i = 1; i + (1 << j) - 1 <= m; i++)
f[p][i][j] = min(f[p][i][j - 1], f[p][i + (1 << j - 1)][j - 1]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + h[i][j];
for (int j = 1; j <= m - b + 1; j++) {
s.clear();
for (int i = 1; i <= a; i++) s.insert(query(i, j, j + b - 1));
for (int i = 1; i <= n - a + 1; i++) {
val[i][j] = sum[i + a - 1][j + b - 1] - sum[i + a - 1][j - 1] -
sum[i - 1][j + b - 1] + sum[i - 1][j - 1] -
(*(s.begin())) * a * b;
s.erase(s.find(query(i, j, j + b - 1)));
if (i + a <= n) s.insert(query(i + a, j, j + b - 1));
}
}
int cnt = 0;
for (int i = 1; i <= n - a + 1; i++)
for (int j = 1; j <= m - b + 1; j++) ans[++cnt] = make_pair(i, j);
sort(ans + 1, ans + 1 + cnt, [&](pair<int, int> a, pair<int, int> b) {
if (val[a.first][a.second] == val[b.first][b.second]) return a < b;
return val[a.first][a.second] < val[b.first][b.second];
});
int tot = 0;
for (int k = 1; k <= cnt; k++) {
pair<int, int> now = ans[k];
if (book[now.first][now.second]) continue;
ans1[++tot] = now.first;
ans2[tot] = now.second;
ans3[tot] = val[ans1[tot]][ans2[tot]];
for (int i = ans1[tot] - a + 1; i <= ans1[tot] + a - 1; i++)
for (int j = ans2[tot] - b + 1; j <= ans2[tot] + b - 1; j++)
if (i > 0 && j > 0 && i <= n - a + 1 && j <= m - b + 1) book[i][j] = 1;
}
::print(tot), putchar('\n');
for (int i = 1; i <= tot; i++)
::print(ans1[i]), putchar(' '), ::print(ans2[i]), putchar(' '),
::print(ans3[i]), putchar('\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans;
int pos[6][1009], a[6][1009];
int d[1009], pd[1009][1009], f[1009];
bool vis[1009];
vector<int> e[1009];
bool AssignMax(int* a, int b) {
if (*a < b) {
*a = b;
return true;
} else
return false;
}
int dfs(int u) {
if (f[u] != -1) return f[u];
f[u] = 0;
for (int v : e[u]) f[u] = max(f[u], dfs(v));
return ++f[u];
}
int main() {
scanf("%d%d", &n, &k);
memset(f, -1, sizeof(f));
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
pos[i][a[i][j]] = j;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (i == j) continue;
pd[i][j] = true;
for (int l = 1; l <= k; ++l) {
if (pos[l][i] > pos[l][j]) {
pd[i][j] = false;
break;
}
}
if (!pd[i][j]) continue;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (pd[i][j]) e[i].push_back(j);
}
}
for (int i = 1; i <= n; i++) {
ans = max(ans, dfs(i));
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace RA {
int r(int p) { return 1ll * rand() * rand() % p; }
int r(int L, int R) { return r(R - L + 1) + L; }
} // namespace RA
const int N = 1e5 + 5;
int n, dg[N], sz[N], dep[N], flag[2], f[N];
vector<int> g[N];
void dfs(int u, int p) {
dep[u] = dep[p] + 1, sz[u] = 1;
if (dg[u] == 1) flag[dep[u] & 1] = 1;
for (int v : g[u])
if (v != p) dfs(v, u), sz[u] += sz[v];
int s0 = 0;
for (int v : g[u])
if (v != p) {
if (sz[v] == 1)
s0 = 1;
else
f[u] += f[v] + 1;
}
f[u] += s0;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b), g[b].push_back(a);
dg[a]++, dg[b]++;
}
int root = max_element(dg + 1, dg + n + 1) - dg;
dfs(root, 0);
if (flag[0] & flag[1])
printf("3 ");
else
printf("1 ");
printf("%d\n", f[root]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N];
map<int, int> mp;
int d2[N], d[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
mp[a[i]]++;
}
int l = 0;
for (auto p : mp) {
int t = p.second;
d2[t]++;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= d2[i]; ++j) {
d[++l] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
int tmp = 0;
int st = 1;
for (int j = i; j <= n; j = j * 2) {
int t = lower_bound(d + st, d + l + 1, j) - d;
if (t == l + 1) {
break;
} else {
st = t + 1;
tmp += j;
}
}
ans = max(ans, tmp);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string str;
cin >> n >> str;
for (int i = 1; i <= n; ++i) {
for (int k = 0; k < n; ++k)
for (int j = k, c = 0; j < n; j += i) {
if (str[j] == '.') break;
++c;
if (c == 5) {
cout << "yes";
return 0;
}
}
}
cout << "no";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[201], ans, b[101], c[101];
int main() {
cin >> n;
for (int i = 1; i <= 2 * n; ++i) {
scanf("%d", &a[i]);
if (!b[a[i]])
b[a[i]] = i;
else
c[a[i]] = i;
}
for (int i = 1; i <= 2 * n; ++i) {
for (int j = c[a[i]]; j > i + 1; --j) {
if (b[a[j - 1]] == j - 1)
b[a[j - 1]] = j;
else
c[a[j - 1]] = j;
c[a[j]] = j - 1;
swap(a[j], a[j - 1]);
++ans;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
char a[27], b[27], in[1003], ou[1003];
scanf("%s", a);
scanf("%s", b);
scanf("%s", in);
int len = strlen(in), i, j;
for (i = 0; i < len; i++) {
if (in[i] >= 97 && in[i] <= 122) {
for (j = 0; j < 26; j++)
if (a[j] == in[i]) printf("%c", b[j]);
} else if (in[i] >= 65 && in[i] <= 90) {
in[i] = in[i] + 32;
for (j = 0; j < 26; j++)
if (a[j] == in[i]) printf("%c", b[j] - 32);
} else
printf("%c", in[i]);
}
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
long long dp[55][2], a[55];
int main() {
int n;
cin >> n;
long long sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = n; i >= 1; i--) {
dp[i][0] = max(dp[i + 1][0], dp[i + 1][1]) - a[i];
dp[i][1] = a[i] - max(dp[i + 1][0], dp[i + 1][1]);
}
long long sub = max(dp[1][0], dp[1][1]);
cout << (sum - sub >> 1) << ' ' << (sum + sub >> 1);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, maxv = 0;
string s;
cin >> n;
while (cin >> s) {
for (int i = 0; i < s.size(); i++)
if (s[i] >= 'A' && s[i] <= 'Z') ans++;
maxv = max(maxv, ans);
ans = 0;
}
cout << maxv << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
const int maxn = 100005;
int a[maxn], b[maxn], n;
map<int, int> cnt;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i], &b[i]);
++cnt[a[i]];
++cnt[b[i]];
}
vector<int> c;
for (map<int, int>::iterator it = cnt.begin(); it != cnt.end(); ++it)
if (it->second * 2 >= n) c.push_back(it->first);
int ans = -1;
for (int i = 0; i < c.size(); ++i) {
int c1 = 0, c2 = 0;
for (int j = 0; j < n; ++j)
if (a[j] == c[i])
++c1;
else if (b[j] == c[i]) {
++c2;
}
if ((c1 + c2) * 2 >= n) {
int x = (n + 1) / 2, t;
if (c1 >= x)
t = 0;
else
t = x - c1;
if (ans == -1 || ans > t) ans = t;
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int get(int i) {
int a, b;
cout << "? " << i << endl;
cin >> a;
cout << "? " << i + n / 2 << endl;
cin >> b;
return a - b;
}
int main() {
cin >> n;
int sv = get(1), l = 1, r = n / 2;
if (sv == 0) {
cout << "! 1" << endl;
return 0;
}
while (l <= r) {
int pv = (l + r) / 2, val;
val = get(pv);
if (val == 0) {
cout << "! " << pv << endl;
return 0;
} else if ((sv > 0) ^ (val > 0)) {
r = pv - 1;
} else {
l = pv + 1;
}
}
cout << "! -1" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-9, PI = acos(-1);
bool ge(long double x, long double y) { return x + EPS > y; }
bool le(long double x, long double y) { return x - EPS < y; }
bool eq(long double x, long double y) { return ge(x, y) && le(x, y); }
struct point {
long double x, y;
point(long double x = 0, long double y = 0) : x(x), y(y) {}
void operator-=(point p) { x -= p.x, y -= p.y; }
void operator+=(point p) { x += p.x, y += p.y; }
void operator*=(long double p) { x *= p, y *= p; }
point operator-() { return point(-x, -y); }
point operator+(point p) { return point(x + p.x, y + p.y); }
point operator-(point p) { return point(x - p.x, y - p.y); }
point operator*(long double p) { return point(x * p, y * p); }
point operator/(long double p) { return point(x / p, y / p); }
long double operator*(point p) { return x * p.x + y * p.y; }
long double operator%(point p) { return x * p.y - y * p.x; }
long double operator!() { return sqrt(1.0L * x * x + 1.0L * y * y); }
long double operator+() { return x * x + y * y; }
point rotate(long double sin, long double cos) {
return point(cos * x - sin * y, sin * x + cos * y);
}
point rotate(long double a) { return rotate(sin(a), cos(a)); }
};
vector<point> circles_intersection(point c1, long double r1, point c2,
long double r2) {
vector<point> vec;
long double d = !(c1 - c2);
if (ge(d, r1 + r2) or le(d + min(r1, r2), max(r1, r2))) return vec;
long double x = (r1 * r1 - r2 * r2 + d * d) / (2 * d),
y = sqrt(r1 * r1 - x * x);
point v = (c2 - c1) / d;
if (ge(x, 0))
vec.push_back(c1 + v * x - v.rotate(PI / 2) * y);
else
vec.push_back(c1 + v * x + v.rotate(PI / 2) * y);
if (ge(y, 0) && ge(x, 0))
vec.push_back(c1 + v * x + v.rotate(PI / 2) * y);
else if (ge(y, 0))
vec.push_back(c1 + v * x - v.rotate(PI / 2) * y);
return vec;
}
vector<point> point_circle_tg(point a, point c, long double r) {
vector<point> vec;
long double d = !(c - a), r2 = sqrt(d * d - r * r);
long double x = (r2 * r2 - r * r + d * d) / (2 * d),
y = sqrt(r2 * r2 - x * x);
point v = (c - a) / d;
vec.push_back(a + v * x - v.rotate(PI / 2) * y),
vec.push_back(a + v * x + v.rotate(PI / 2) * y);
return vec;
}
long double xc, yc, v, T, r, ang;
int n, cont;
bool ok1, ok2;
vector<pair<point, long double>> Circle;
vector<pair<long double, long double>> resp;
vector<pair<long double, int>> tetas;
int main() {
scanf("%Lf%Lf%Lf%Lf%d", &xc, &yc, &v, &T, &n);
point s(xc, yc);
long double raio = v * T;
for (int i = 0; i < n; i++) {
scanf("%Lf%Lf%Lf", &xc, &yc, &r);
Circle.push_back({point(xc, yc), r});
}
for (int i = 0; i < n; i++) {
auto vec = circles_intersection(s, raio, Circle[i].first, Circle[i].second);
auto ret = point_circle_tg(s, Circle[i].first, Circle[i].second);
pair<long double, long double> aux;
point p1, p2;
if (le(+(s - Circle[i].first), Circle[i].second * Circle[i].second)) {
resp.push_back({0, 2 * PI});
break;
}
if (le(!(s - ret[0]), raio))
p1 = ret[0], p2 = ret[1];
else if (vec.size() == 2)
p1 = vec[0], p2 = vec[1];
else
continue;
if (ge(p1.y, s.y))
aux.first = acos((p1 - s) * point(1, 0) / (!(p1 - s)));
else if (le(p1.y, s.y))
aux.first = 2 * PI - acos((p1 - s) * point(1, 0) / (!(p1 - s)));
if (ge(p2.y, s.y))
aux.second = acos((p2 - s) * point(1, 0) / (!(p2 - s)));
else if (le(p2.y, s.y))
aux.second = 2 * PI - acos((p2 - s) * point(1, 0) / (!(p2 - s)));
if (eq(aux.first, aux.second)) continue;
if (eq(aux.first, 0)) ok1 = true;
if (eq(aux.second, 0)) ok2 = true, aux.second = 2 * PI;
resp.push_back({aux});
}
for (int i = 0; i < resp.size(); i++)
if (!ge(resp[i].second, resp[i].first))
tetas.push_back({0, 0}), tetas.push_back({2 * PI, 1});
for (int i = 0; i < resp.size(); i++)
tetas.push_back({resp[i].first, 0}), tetas.push_back({resp[i].second, 1});
sort(tetas.begin(), tetas.end());
long double aux;
for (int i = 0; i < tetas.size(); i++) {
if (tetas[i].second) {
cont--;
if (cont == 0) ang += tetas[i].first - aux;
} else {
if (cont == 0) aux = tetas[i].first;
cont++;
}
}
printf("%Lf\n", ang / (2 * PI));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = (long long)5e18;
const long double eps = 1e-12;
const long long N = 1000005;
const long long LOGN = 19;
const long double PI = 3.14159265358979323846;
long long mul(long long a, long long b, long long m = mod) {
return (long long)(a * b) % m;
}
long long add(long long a, long long b, long long m = mod) {
a += b;
if (a >= m) a -= m;
if (a < 0) a += m;
return a;
}
long long power(long long a, long long b, long long m = mod) {
if (b == 0) return 1;
if (b == 1) return (a % m);
long long x = power(a, b / 2, m);
x = mul(x, x, m);
if (b % 2) x = mul(x, a, m);
return x;
}
long long n, m, a[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
long long mi = inf;
for (int i = 0; i < m; i++) {
long long l, r;
cin >> l >> r;
l--, r--;
mi = min(mi, r - l + 1);
}
cout << mi << "\n";
for (int i = 0; i < n; i++) cout << i % mi << " ";
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000001], c[1000001], b[1000001], x, y, z, sum, ans, n, m, k, l, o,
p, q, u, mx, mn;
string s, second[1000001];
map<long long, long long> e;
vector<int> v;
vector<int>::iterator it;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
cin >> b[i];
for (int j = 1; j <= n; j++)
if (a[j] == b[i]) c[j] = 1;
}
for (int i = 1; i <= n; i++) {
if (c[i] == 1) cout << a[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int mod = 1000000007;
const int inf = 1000000009;
const long long INF = 1000000000000000009;
const long long big = 1000000000000000;
const long double eps = 0.0000000001;
using namespace std;
bool cmp(int a, int b) { return a > b; }
int k;
long long int DP[500005][3];
vector<pair<int, int> > P[500005];
vector<long long int> W;
void dfs(int n, int p) {
for (auto v : P[n])
if (v.first != p) dfs(v.first, n);
long long int wynik = 0;
for (auto v : P[n]) {
if (v.first != p) {
wynik += DP[v.first][2];
W.push_back(DP[v.first][1] + v.second - DP[v.first][2]);
}
}
sort(W.begin(), W.end(), cmp);
DP[n][1] = wynik, DP[n][2] = wynik;
for (int i = 0; i < min(k, (int)W.size()); i++) {
if (W[i] <= 0) break;
if (i != k - 1) DP[n][1] += W[i];
DP[n][2] += W[i];
}
W.clear();
}
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
int q;
cin >> q;
for (int j = 1; j <= q; j++) {
int n;
cin >> n >> k;
for (int i = 1; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
P[a].push_back(make_pair(b, c));
P[b].push_back(make_pair(a, c));
}
dfs(1, 0);
cout << max(DP[1][1], DP[1][2]) << "\n";
for (int i = 1; i <= n; i++) P[i].clear();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
int f[15][15][15][15];
char s[N];
void Prepare() {
memset(f, 60, sizeof(f));
for (register int i = 0; i <= 9; i++) {
for (register int j = 0; j <= 9; j++) {
for (register int k = 0; k <= 9; k++) {
f[i][j][k][(k + i) % 10] = 1;
f[i][j][k][(k + j) % 10] = 1;
}
for (register int k = 0; k <= 9; k++) {
for (register int i1 = 0; i1 <= 9; i1++) {
for (register int j1 = 0; j1 <= 9; j1++) {
f[i][j][i1][j1] =
min(f[i][j][i1][j1], f[i][j][i1][k] + f[i][j][k][j1]);
}
}
}
}
}
}
int main() {
Prepare();
scanf("%s", s + 1);
int len = strlen(s + 1), ans;
for (register int i = 0; i <= 9; i++) {
for (register int j = 0; j <= 9; j++) {
ans = 0;
for (register int k = 1; k < len; k++) {
if (f[i][j][s[k] - '0'][s[k + 1] - '0'] > 100) {
ans = -1;
break;
} else {
ans += f[i][j][s[k] - '0'][s[k + 1] - '0'] - 1;
}
}
printf("%d ", ans);
}
putchar('\n');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct segment {
int left, right;
bool operator<(const segment a) const {
if (left < a.left) {
return true;
}
if (left == a.left && right > a.right) {
return true;
}
return false;
}
} s[1001];
int n;
int a[1001];
void deal() {
sort(s, s + n);
int ans = 0, i = 0, j, l, r;
while (i < n) {
l = s[i].left;
r = s[i].right;
for (j = i + 1; j < n; j++) {
if (s[j].left > r) {
break;
}
if (s[j].left == r) {
l = r;
} else {
l = s[j].left;
}
if (s[j].right < r) {
r = s[j].right;
}
}
a[ans++] = r;
i = j;
}
printf("%d\n", ans);
for (i = 0; i < ans - 1; i++) {
printf("%d ", a[i]);
}
printf("%d\n", a[i]);
}
int main() {
int i, t;
while (scanf("%d", &n) == 1) {
for (i = 0; i < n; i++) {
scanf("%d%d", &s[i].left, &s[i].right);
if (s[i].left > s[i].right) {
t = s[i].left;
s[i].left = s[i].right;
s[i].right = t;
}
}
deal();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
int a[N], cmp, ans;
vector<int> adj[N];
queue<int> q;
int visited[N];
void dfs(int u, int par = -1) {
visited[u] = cmp;
for (int v : adj[u]) {
if (!visited[v]) {
dfs(v, u);
} else if (visited[v] == cmp) {
q.push(v);
}
}
}
int main() {
int n, x, root = -1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
a[i] = x;
adj[i].push_back(x);
if (x == i) {
root = i;
}
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
++cmp;
dfs(i);
}
}
if (root == -1) {
root = q.front();
q.pop();
a[root] = root;
++ans;
}
while (!q.empty()) {
a[q.front()] = root;
if (q.front() != root) ans++;
q.pop();
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct factor {
int p[25], q[25], sz;
inline void clear() {
memset(p, 0, sizeof(p));
memset(q, 0, sizeof(q));
sz = 0;
}
inline void sort() {
pair<int, int> arr[25];
for (int i = 0; i < sz; i++) arr[i] = make_pair(p[i], q[i]);
::sort(arr, arr + sz);
for (int i = 0; i < sz; i++) {
p[i] = arr[i].first;
q[i] = arr[i].second;
}
}
} a, b, c;
long long n, m, s, ans;
int mn[2000005], p[2000005], tot, idx[2000005];
inline void init() {
for (int i = 2; i < 2000005; i++) {
if (!mn[i]) {
mn[i] = i;
p[tot++] = i;
}
for (int j = 0; j < tot && i * p[j] < 2000005; j++) {
mn[i * p[j]] = p[j];
if (!(i % p[j])) break;
}
}
}
inline void fac(factor &a, int num) {
while (mn[num]) {
if (-1 == idx[mn[num]]) {
a.p[a.sz] = mn[num];
idx[mn[num]] = a.sz++;
}
a.q[idx[mn[num]]]++;
num /= mn[num];
}
}
void dfs(int pos, long long cur) {
if (cur > n) return;
if (pos >= c.sz) {
ans++;
return;
}
for (int i = 0; i <= c.q[pos]; i++) {
dfs(pos + 1, cur);
cur *= c.p[pos];
}
}
void upd(int pos, long long cur, int off) {
if (!cur) return;
if (pos >= b.sz) {
ans += cur * off;
return;
}
upd(pos + 1, cur, off);
for (int i = 0; i <= b.q[pos]; i++) cur /= b.p[pos];
upd(pos + 1, cur, -off);
}
int main() {
init();
int t;
scanf("%d", &t);
while (t--) {
ans = 0;
a.clear();
b.clear();
c.clear();
int n1, n2, n3, m1, m2, m3, s1, s2, s3;
scanf("%d%d%d%d%d%d%d%d%d", &n1, &n2, &n3, &m1, &m2, &m3, &s1, &s2, &s3);
memset(idx, -1, sizeof(idx));
fac(a, n1);
fac(a, n2);
fac(a, n3);
a.sort();
memset(idx, -1, sizeof(idx));
fac(c, 2 * s1);
fac(c, s2);
fac(c, s3);
c.sort();
n = (long long)n1 * n2 * n3;
m = (long long)m1 * m2 * m3;
s = (long long)s1 * s2 * s3;
dfs(0, 1);
int i = 0, j = 0;
while (i < a.sz && j < c.sz) {
if (a.p[i] == c.p[j]) {
if (a.q[i] > c.q[j]) {
b.p[b.sz] = a.p[i];
b.q[b.sz++] = c.q[j];
}
i++;
j++;
} else if (a.p[i] < c.p[j]) {
b.p[b.sz++] = a.p[i];
i++;
} else
j++;
}
while (i < a.sz) {
b.p[b.sz++] = a.p[i];
i++;
}
upd(0, m, 1);
printf("%lld\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct one {
int i;
int end;
bool operator<(const one &e) const { return i < e.i; }
};
struct zero {
int i, j;
};
const int inf = 1e9;
class segment {
public:
vector<int> n, t;
segment() { ; }
segment(vector<int> &a) : n(a), t(4 * a.size(), 0) { build(0, 0, a.size()); }
int build(int v, int i, int j) {
if (j - i <= 0) {
return inf;
} else if (j - i == 1) {
return t[v] = n[i];
} else {
int mid = (i + j) / 2;
build(2 * v + 1, i, mid);
build(2 * v + 2, mid, j);
t[v] = min(t[2 * v + 1], t[2 * v + 2]);
}
}
int rmq(int v, int l, int r, int i, int j) {
if (j - i <= 0) {
return inf;
} else if (l == i && r == j) {
return t[v];
} else {
int mid = (l + r) / 2;
return min(rmq(2 * v + 1, l, mid, i, min(j, mid)),
rmq(2 * v + 2, mid, r, max(mid, i), j));
}
}
int rmq(int i, int j) { return rmq(0, 0, n.size(), i, j); }
};
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<one> o[32];
vector<zero> z[32];
for (int i = 0; i < m; i++) {
int l, r, q;
scanf("%d %d %d", &l, &r, &q);
for (int j = 0; j < 31; j++) {
if (q & (1 << j)) {
o[j].push_back({l - 1, -1});
o[j].push_back({r, 1});
} else {
z[j].push_back({l - 1, r});
}
}
}
for (int i = 0; i < 32; i++) sort(o[i].begin(), o[i].end());
vector<int> bits[32];
vector<int> def(n, 0);
for (int i = 0; i < 32; i++) bits[i] = def;
for (int i = 0; i < 32; i++) {
int cnt = 0;
for (int j = 0, p = 0; j < o[i].size() && p < n;) {
while (p < o[i][j].i) {
bits[i][p] = cnt > 0;
p++;
}
while (j < o[i].size() && o[i][j].i == p) {
cnt -= o[i][j].end;
j++;
}
if (p < n) {
bits[i][p] = cnt > 0;
}
}
}
segment seg[32];
for (int i = 0; i < 32; i++) seg[i] = segment(bits[i]);
for (int i = 0; i < 32; i++) {
for (int j = 0; j < z[i].size(); j++) {
if (seg[i].rmq(z[i][j].i, z[i][j].j) != 0) {
cout << "NO" << endl;
return 0;
}
}
}
vector<int> out(n, 0);
for (int i = 0; i < 32; i++) {
for (int j = 0; j < bits[i].size(); j++) {
if (bits[i][j] >= 1) out[j] |= (1 << i);
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << out[i] << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 9, mod = 1e9 + 7, inf = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
long long n, m;
cin >> n >> m;
long long rem[n + 3], cost[n + 5];
for (int i = 1; i <= n; i++) cin >> rem[i];
for (int i = 1; i <= n; i++) {
cin >> cost[i];
pq.push({cost[i], i});
}
while (m--) {
long long tj, lj;
cin >> tj >> lj;
if (rem[tj] >= lj) {
cout << (lj * cost[tj]) << "\n";
rem[tj] -= lj;
} else {
long long r = rem[tj] * cost[tj];
lj -= rem[tj];
rem[tj] = 0;
while (!pq.empty() && lj > 0) {
if (rem[pq.top().second] > lj) {
r += (lj * cost[pq.top().second]);
rem[pq.top().second] -= lj;
lj = 0;
} else {
r += (rem[pq.top().second] * cost[pq.top().second]);
lj -= rem[pq.top().second];
rem[pq.top().second] = 0;
pq.pop();
}
}
if (lj > 0) r = 0;
cout << r << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, l, n, m, it = 0, ar[26], flag = -1, cnt = 0;
cin >> n;
int ans = 0;
char c;
string second;
for (i = 0; i < 26; i++) ar[i] = 1;
for (i = 0; i < n; i++) {
cin >> c >> second;
if (i == n - 1) break;
if (flag == 1) {
if (c != '.') ans++;
continue;
}
if (c == '.')
for (j = 0; j < second.size(); j++) ar[second[j] - 'a'] = 0;
else if (c == '!') {
map<int, bool> mapp;
for (j = 0; j < second.size(); j++) mapp[second[j] - 'a'] = 1;
for (j = 0; j < 26; j++)
if (ar[j] == 1 && mapp[j])
;
else
ar[j] = 0;
} else
ar[second[0] - 'a'] = 0;
int cnt = 0;
for (j = 0; j < 26; j++) cnt += ar[j];
if (cnt == 1) flag = 1;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100011], arr[100011];
long long sum[100011], tot[100011];
int main() {
int n, i, j;
cin >> n;
long long ans = 0;
for (i = 1; i <= n; i++) scanf("%d", a + i), sum[i] = sum[i - 1] + a[i];
for (i = 1; i <= n; i++) scanf("%1d", arr + i), ans += arr[i] * a[i];
for (i = n; i >= 1; i--) {
tot[i] = tot[i + 1];
if (arr[i] == 1) tot[i] += a[i];
}
for (i = 1; i <= n; i++) {
if (arr[i] == 0) continue;
ans = max(ans, sum[i - 1] + tot[i + 1]);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string str;
long long getans(int x) {
int l = x - 1;
long long cnt1 = 0;
while (l >= 0) {
if (isalpha(str[l])) cnt1++;
if (str[l] == '@' || str[l] == '.') break;
l--;
}
int flag1 = 0;
int flag2 = 0;
long long cnt2 = 0;
int r = x + 1;
while (r < str.length()) {
if (str[r] == '@' || str[r] == '_') break;
if (isalnum(str[r])) {
flag1 = 1;
if (flag2) {
if (isdigit(str[r]))
break;
else
cnt2++;
}
}
if (str[r] == '.') {
if (flag2 || !flag1) break;
flag2 = 1;
}
r++;
}
return cnt1 * cnt2;
}
int main() {
cin >> str;
int l = str.length();
long long ans = 0;
for (int i = 0; i < str.length(); i++) {
if (str[i] == '@') ans += getans(i);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
int h[1000000], axis[2000000], maxv[1 << 22], cover[1 << 22];
pair<int, int> seg[1000000], order[1000000];
int transformX(int x, int y, int vx, int vy) { return x * vx + y * vy; }
int transformY(int x, int y, int vx, int vy) { return y * vx - x * vy; }
int getMax(int i, int l, int r, int l0, int r0) {
if (l0 <= l && r <= r0) return maxv[i];
int mid = (l + r) / 2, res = inf;
if (l0 < mid) res = min(res, getMax(i * 2, l, mid, l0, r0));
if (r0 > mid) res = min(res, getMax(i * 2 + 1, mid, r, l0, r0));
return max(res, cover[i]);
}
void update(int i, int l, int r, int l0, int r0, int x) {
if (l0 <= l && r <= r0) {
cover[i] = max(cover[i], x);
maxv[i] = max(maxv[i], x);
return;
}
int mid = (l + r) / 2;
if (l0 < mid) update(i * 2, l, mid, l0, r0, x);
if (r0 > mid) update(i * 2 + 1, mid, r, l0, r0, x);
maxv[i] = max(cover[i], min(maxv[i * 2], maxv[i * 2 + 1]));
}
int main() {
int n, vx, vy;
scanf("%d%d%d", &n, &vx, &vy);
int tot = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%d", &h[i * n + j]);
int l = inf, r = -inf, t = inf;
for (int d1 = 0; d1 < 2; d1++)
for (int d2 = 0; d2 < 2; d2++) {
int x = transformX(i + d1, j + d2, vx, vy);
int y = transformY(i + d1, j + d2, vx, vy);
l = min(l, y);
r = max(r, y);
t = min(t, x);
}
seg[i * n + j] = make_pair(l, r);
axis[tot++] = l;
axis[tot++] = r;
order[i * n + j] = make_pair(t, i * n + j);
}
sort(axis, axis + tot);
tot = unique(axis, axis + tot) - axis;
sort(order, order + n * n);
memset(maxv, 0, sizeof(maxv));
long long ans = 0;
for (int i = 0; i < n * n; i++) {
int cur = order[i].second;
int t1 = lower_bound(axis, axis + tot, seg[cur].first) - axis;
int t2 = lower_bound(axis, axis + tot, seg[cur].second) - axis;
int t = getMax(1, 0, tot, t1, t2);
if (h[cur] > t) {
ans += h[cur] - t;
update(1, 0, tot, t1, t2, h[cur]);
}
}
printf("%I64d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 100000 + 10;
const int M = 200000 + 10;
int val[M], idx = 0;
int sum[M << 2], l[N], r[N];
vector<int> g[M];
void update(int pos, int v, int l, int r, int rt) {
if (l == r) {
sum[rt] = (sum[rt] + v) % mod;
} else {
int mid = (l + r) >> 1;
if (pos <= mid)
update(pos, v, l, mid, rt << 1);
else
update(pos, v, mid + 1, r, rt << 1 | 1);
sum[rt] = (sum[rt << 1] + sum[rt << 1 | 1]) % mod;
}
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return sum[rt];
} else {
int mid = (l + r) >> 1;
if (L > mid)
return query(L, R, mid + 1, r, rt << 1 | 1);
else if (R <= mid)
return query(L, R, l, mid, rt << 1);
else
return (query(L, mid, l, mid, rt << 1) +
query(mid + 1, R, mid + 1, r, rt << 1 | 1)) %
mod;
}
}
int main() {
memset(sum, 0, sizeof sum);
int n, m, v;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &l[i], &r[i]);
val[idx++] = l[i];
val[idx++] = r[i];
}
val[idx++] = 0;
val[idx++] = n;
sort(val, val + idx);
idx = unique(val, val + idx) - val;
for (int i = 0; i < m; ++i) {
l[i] = lower_bound(val, val + idx, l[i]) - val;
r[i] = lower_bound(val, val + idx, r[i]) - val;
g[r[i]].push_back(l[i]);
}
update(0, 1, 0, idx - 1, 1);
for (int i = 1; i < idx; ++i)
for (int j = 0; j < g[i].size(); ++j) {
v = query(g[i][j], i - 1, 0, idx - 1, 1);
update(i, v, 0, idx - 1, 1);
}
printf("%d\n", query(idx - 1, idx - 1, 0, idx - 1, 1));
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long min(long long a, long long b) {
if (a < 0 || b < 0) return 0;
return a < b ? a : b;
}
int main() {
long long n, k;
scanf("%lld %lld", &n, &k);
if (k % 2)
printf("%lld", min(k / 2, n - k / 2));
else
printf("%lld", min(k / 2 - 1, n - k / 2));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long id[10005];
long long root(long long x) {
while (id[x] != x) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void unio(long long x, long long y) { id[root(y)] = root(x); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n + 5; i++) {
id[i] = i;
}
vector<pair<long long, pair<long long, long long>>> v;
for (long long i = 0; i < m; i++) {
long long t, x, y;
cin >> t >> x >> y;
v.push_back(make_pair(1 - t, make_pair(x, y)));
}
sort(v.begin(), v.end());
long long arr[n + 1];
for (long long i = 0; i < n; i++) {
arr[i + 1] = 1;
}
long long flag = 0, val = 10000;
for (long long i = 0; i < m; i++) {
if (v[i].first == 0) {
long long temp = v[i].second.first;
for (long long j = v[i].second.first; j < v[i].second.second + 1; j++) {
unio(temp, j);
}
} else {
long long x = v[i].second.first, y = v[i].second.second;
if (root(x) != root(y)) {
if (arr[root(x)] == 1) {
arr[root(x)] = val;
}
arr[root(y)] = arr[root(x)] - 1;
val -= 2;
} else {
flag = 1;
break;
}
}
}
if (flag == 1) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (long long i = 0; i < n; i++) {
arr[i + 1] = arr[root(i + 1)];
cout << arr[i + 1] << " ";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void slv() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
if (s == t) {
cout << "Yes\n";
return;
}
vector<int> v;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
v.push_back(i);
}
}
if (v.size() == 2) swap(s[v[0]], t[v[1]]);
if (s != t)
cout << "No\n";
else
cout << "Yes\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
slv();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000")
bool ascending(int i, int j) { return (i < j); }
bool descending(int i, int j) { return (i > j); }
using namespace std;
bool G[1000 + 10][1000 + 10];
int n, m;
bool check(int x, int y) {
if (x <= 0 || x >= n - 1) return 0;
if (y <= 0 || y >= n - 1) return 0;
bool flag = true;
if (!G[x - 1][y - 1]) flag = false;
if (!G[x - 1][y]) flag = false;
if (!G[x - 1][y + 1]) flag = false;
if (!G[x][y - 1]) flag = false;
if (!G[x][y]) flag = false;
if (!G[x][y + 1]) flag = false;
if (!G[x + 1][y - 1]) flag = false;
if (!G[x + 1][y]) flag = false;
if (!G[x + 1][y + 1]) flag = false;
return flag;
}
int main() {
memset((G), (0), sizeof(G));
cin >> n >> m;
int X[100 * 1000 + 100], Y[100 * 1000 + 100];
for (int(i) = 0; (i) < (m); (i)++) {
cin >> X[i] >> Y[i];
X[i]--;
Y[i]--;
}
for (int(i) = 0; (i) < (m); (i)++) {
G[X[i]][Y[i]] = true;
if (check(X[i] - 1, Y[i] - 1) || check(X[i] - 1, Y[i]) ||
check(X[i] - 1, Y[i] + 1) || check(X[i], Y[i] - 1) ||
check(X[i], Y[i]) || check(X[i], Y[i] + 1) ||
check(X[i] + 1, Y[i] - 1) || check(X[i] + 1, Y[i]) ||
check(X[i] + 1, Y[i] + 1)) {
cout << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:200000000")
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
const int C = 100;
const string DELIMS = ",.?!\"\\/|#“”@*";
const string cat[3 * C] = {
"dealers 0.0038157536113382394",
"customer 0.0010902153175252113",
"dealer 9.539384028345599E-4",
"of 0.034750613246116106",
"given 0.0012264922322158627",
"futures 8.176614881439084E-4",
"among 0.0012264922322158627",
"says 0.0014990460615971655",
"bought 0.001635322976287817",
"central 0.0035431997819569366",
"exchange 0.006677568819841918",
"option 0.0017715998909784683",
"sold 9.539384028345599E-4",
"these 0.0014990460615971655",
"serve 9.539384028345599E-4",
"liquidity 0.0028618152085036794",
"compares 8.176614881439084E-4",
"fecs 8.176614881439084E-4",
"hours 0.0012264922322158627",
"lebanese 9.539384028345599E-4",
"he 0.009539384028345598",
"system 0.003679476696647588",
"funds 0.0023167075497410737",
"london 0.0021804306350504225",
"session 8.176614881439084E-4",
"herstatt 8.176614881439084E-4",
"low 0.001362769146906514",
"bills 0.0046334150994821474",
"offered 8.176614881439084E-4",
"arab 0.002044153720359771",
"assistance 0.002725538293813028",
"bahrain 0.0012264922322158627",
"estimate 0.0010902153175252113",
"currency 0.006541291905151268",
"paris 0.0017715998909784683",
"life 8.176614881439084E-4",
"intervention 0.002044153720359771",
"bundesbank 0.001635322976287817",
"dollar 0.006268738075769964",
"contracts 8.176614881439084E-4",
"gold 8.176614881439084E-4",
"trading 0.002725538293813028",
"100 8.176614881439084E-4",
"options 0.0012264922322158627",
"shortage 0.0019078768056691197",
"dollars 0.0017715998909784683",
"foster 8.176614881439084E-4",
"rates 0.0028618152085036794",
"philadelphia 9.539384028345599E-4",
"morning 0.0010902153175252113",
"bangemann 9.539384028345599E-4",
"yen 0.0019078768056691197",
"hedging 9.539384028345599E-4",
"banks 0.004088307440719542",
"transactions 9.539384028345599E-4",
"investors 0.0010902153175252113",
"marks 0.0014990460615971655",
"horner 8.176614881439084E-4",
"though 8.176614881439084E-4",
"appropriations 8.176614881439084E-4",
"band 0.001362769146906514",
"giordano 0.0012264922322158627",
"survey 8.176614881439084E-4",
"bank 0.011447260834014717",
"fund 9.539384028345599E-4",
"had 0.006268738075769964",
"stg 0.008176614881439084",
"repurchase 0.0012264922322158627",
"far 0.001635322976287817",
"market 0.009266830198964295",
"monetary 0.003134369037884982",
"treasury 0.004905968928863451",
"foreign 0.004497138184791497",
"early 0.0024529844644317253",
"currencies 0.003270645952575634",
"carefully 9.539384028345599E-4",
"have 0.00585990733169801",
"stability 0.0012264922322158627",
"today 0.0042245843554101934",
"purchase 9.539384028345599E-4",
"bond 0.0017715998909784683",
"phlx 0.0012264922322158627",
"controls 0.001362769146906514",
"england 0.0023167075497410737",
"traded 0.0012264922322158627",
"baker 0.0021804306350504225",
"houses 9.539384028345599E-4",
"forecast 0.0014990460615971655",
"148 8.176614881439084E-4",
"agency 9.539384028345599E-4",
"the 0.07849550286181521",
"000 8.176614881439084E-4",
"needed 0.0012264922322158627",
"around 0.003270645952575634",
"commodity 0.0019078768056691197",
"continue 0.001362769146906514",
"prices 0.0023167075497410737",
"provided 0.001362769146906514",
"sumita 0.0012264922322158627",
"their 0.003679476696647588",
"fell 0.007989347536617843",
"deposit 0.0018157608037767826",
"aggregates 8.473550417624985E-4",
"deposits 0.0039946737683089215",
"float 8.473550417624985E-4",
"compared 0.0037525723278053506",
"m-1 0.0070209417746035585",
"m-2 0.0037525723278053506",
"year 0.007141992494855344",
"m-3 0.002905217286042852",
"seasonally 0.002178912964532139",
"plus 0.00242101440503571",
"defined 8.473550417624985E-4",
"loan 0.0013315579227696406",
"excluding 8.473550417624985E-4",
"3 0.007141992494855344",
"rose 0.013315579227696404",
"2 0.005689383851833919",
"1 0.010168260501149981",
"fed 0.003873623048057136",
"0 0.004720978089819634",
"acceptances 0.0013315579227696406",
"7 0.004599927369567849",
"february 0.008715651858128556",
"6 0.005568333131582133",
"feb 0.001452608643021426",
"738 9.68405762014284E-4",
"5 0.0059314852923374895",
"4 0.007505144655610701",
"1985 0.0025420651252874953",
"canadian 0.0018157608037767826",
"reserve 0.00484202881007142",
"9 0.004115724488560707",
"8 0.004720978089819634",
"adjusted 0.002905217286042852",
"chartered 0.001694710083524997",
"broad 9.68405762014284E-4",
"19 0.0013315579227696406",
"data 0.0020578622442803535",
"18 0.0015736593632732115",
"16 0.00242101440503571",
"savings 0.001452608643021426",
"13 0.0022999636847839244",
"net 0.0015736593632732115",
"11 0.0015736593632732115",
"12 0.0018157608037767826",
"grew 0.001694710083524997",
"money 0.011499818423919622",
"rises 0.0020578622442803535",
"year-on-year 0.0022999636847839244",
"end 0.003147318726546423",
"previous 0.0025420651252874953",
"loans 0.003147318726546423",
"10 0.0022999636847839244",
"reserves 0.0020578622442803535",
"notes 0.0010894564822660695",
"week 0.005810434572085704",
"sector 0.0015736593632732115",
"unadjusted 8.473550417624985E-4",
"ended 0.002905217286042852",
"mln 0.011136666263164266",
"pct 0.026752209175644595",
"january 0.009320905459387484",
"bank 0.010894564822660695",
"november 0.0027841665657910666",
"canada 0.001452608643021426",
"billion 0.03462050599201065",
"m-1-a 0.0010894564822660695",
"m1 9.68405762014284E-4",
"m2 0.0010894564822660695",
"unchanged 9.68405762014284E-4",
"m3 0.0013315579227696406",
"dlrs 0.02747851349715531",
"statement 0.0020578622442803535",
"december 0.008957753298632127",
"assets 0.002178912964532139",
"revised 0.0022999636847839244",
"cash 0.0013315579227696406",
"74 0.0010894564822660695",
"provisional 0.0027841665657910666",
"measure 0.001694710083524997",
"pesos 0.001210507202517855",
"from 0.012468224185933907",
"singapore 0.0015736593632732115",
"federal 0.003147318726546423",
"non-personal 0.0010894564822660695",
"circulation 0.001452608643021426",
"rise 0.00484202881007142",
"borrowings 0.0013315579227696406",
"64 8.473550417624985E-4",
"supply 0.008473550417624985",
"york 0.0020578622442803535",
"outstanding 0.0013315579227696406",
"economists 0.0020578622442803535",
"in 0.039462534802082075",
"balances 0.0022999636847839244",
"fomc 0.001210507202517855",
"wednesday 0.0013315579227696406",
"average 0.002178912964532139",
"growth 0.005568333131582133",
"tariffs 0.0037952133839361784",
"president 0.0021686933622492447",
"they 0.004492293393230579",
"nakasone 0.003562853380838045",
"visit 0.0015490666873208892",
"impose 0.0013941600185888002",
"house 0.002401053365347378",
"countries 0.0022461466966152894",
"production 0.0015490666873208892",
"miti 9.294400123925335E-4",
"washington 0.004647200061962667",
"over 0.0027883200371776004",
"china's 7.745333436604446E-4",
"are 0.004492293393230579",
"report 8.51986678026489E-4",
"industry 0.0021686933622492447",
"bilateral 0.001006893346758578",
"exports 0.0026334133684455118",
"services 9.294400123925335E-4",
"minister 0.0021686933622492447",
"sanctions 0.0022461466966152894",
"row 0.001006893346758578",
"include 8.51986678026489E-4",
"prime 0.0014716133529548447",
"european 0.0013941600185888002",
"dumping 0.0011618000154906669",
"reagan 0.0036403067152040894",
"semiconductors 0.0020912400278832004",
"will 0.005421733405623112",
"boost 0.0010843466811246223",
"try 9.294400123925335E-4",
"we 0.0031755867090078227",
"computer 0.0013167066842227559",
"plans 0.0017814266904190225",
"analysts 0.001703973356052978",
"europe 7.745333436604446E-4",
"next 0.001703973356052978",
"nakasone's 7.745333436604446E-4",
"states 0.004182480055766401",
"alleged 0.0010843466811246223",
"ec 0.0021686933622492447",
"de 0.0011618000154906669",
"american 0.0016265200216869337",
"do 0.0019363333591511116",
"products 0.0013941600185888002",
"microchip 8.51986678026489E-4",
"chips 0.001858880024785067",
"united 0.004182480055766401",
"signed 8.51986678026489E-4",
"officials 0.004337386724498489",
"come 0.0011618000154906669",
"electronic 0.0013941600185888002",
"imports 0.003872666718302223",
"u 0.01510340020137867",
"s 0.014871040198280536",
"world 0.0026334133684455118",
"to 0.049182867322438234",
"congress 0.001703973356052978",
"countertrade 7.745333436604446E-4",
"has 0.004569746727596623",
"semiconductor 0.002555960034079467",
"-japan 9.294400123925335E-4",
"his 0.0023236000309813337",
"would 0.007435520099140268",
"microchips 9.294400123925335E-4",
"action 0.002401053365347378",
"tokyo 0.002710866702811556",
"official 0.0034854000464720008",
"live 8.51986678026489E-4",
"300 0.0011618000154906669",
"dispute 0.002401053365347378",
"white 0.0012392533498567114",
"japanese 0.009139493455193246",
"that 0.011695453489272712",
"retaliation 0.001703973356052978",
"failure 0.0011618000154906669",
"pact 0.0020912400278832004",
"japan's 0.002710866702811556",
"makers 0.0010843466811246223",
"talks 0.0015490666873208892",
"output 7.745333436604446E-4",
"administration 7.745333436604446E-4",
"gatt 0.0010843466811246223",
"stop 0.0010843466811246223",
"trade 0.019595693594609248",
"issue 9.294400123925335E-4",
"goods 0.002710866702811556",
"baldrige 0.001006893346758578",
"chirac 8.51986678026489E-4",
"war 0.0027883200371776004",
"japan 0.009914026798853691",
"chip 0.002865773371543645",
"is 0.008364960111532802",
"export 8.51986678026489E-4",
"agreement 0.0033304933777399117",
"expected 0.0014716133529548447",
"yeutter 0.0010843466811246223",
"democratic 9.294400123925335E-4",
"act 8.51986678026489E-4",
"yasuhiro 0.001006893346758578",
};
char buf[1100000];
map<string, double> ma[3];
double p[10];
int sel;
int main() {
for (int i = 0; i < (int)(3 * C); i++) {
double x;
sscanf(cat[i].c_str(), "%s%lf", buf, &x);
ma[i / C][buf] = x;
}
gets(buf);
string text;
while (gets(buf)) {
text += buf;
text += ' ';
}
for (int i = 0; i < (int)(text.size()); i++)
if (DELIMS.find(text[i]) != string::npos) text[i] = ' ';
stringstream ss;
ss << text;
string tok;
while (ss >> tok) {
for (int i = 0; i < (int)(tok.size()); i++) tok[i] = tolower(tok[i]);
for (int i = 0; i < (int)(3); i++)
if (ma[i].count(tok))
p[i] += log(ma[i][tok]);
else
p[i] += log(1E-6);
}
sel = 1;
for (int i = (int)(3) - 1; i >= 0; i--)
if (p[i] > p[sel] + EPS) sel = i;
cout << sel + 1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int minute, minute_cnt;
long long int cal(long long int n, long long int k) {
vector<long long int> a;
for (; n; n /= 10) a.push_back(n % 10);
reverse((a).begin(), (a).end());
long long int res = 0, base = 0;
for (long long int i = 0; i < ((long long int)(((long long int)(a).size())));
++i) {
if (k <= ((long long int)(a).size()) - i) res += 9 * base;
if (k <= ((long long int)(a).size()) - i) res += a[i];
base = base * 10 + a[i];
}
return res;
}
pair<long long int, long long int> p[2];
int main() {
long long int n, m, k, res0 = 0, res1 = 0, res2 = 0;
cin >> n >> m >> k;
minute = cal(--m, k);
res0 += minute * n;
for (; m; m /= 10)
if (m % 10) minute_cnt++;
res0 += cal(--n, k - minute_cnt);
long long int cnt = minute_cnt;
for (; n; n /= 10)
if (n % 10) cnt++;
if (k <= cnt) res0++;
cin >> n >> m;
p[0] = make_pair(n, m);
res1 += minute * n;
res1 += cal(m, k);
res1 += cal(n, k - minute_cnt);
cin >> n >> m;
p[1] = make_pair(n, m);
res2 += minute * n;
res2 += cal(m, k);
res2 += cal(n, k - minute_cnt);
if (p[0] <= p[1])
cout << res2 - res1 << endl;
else
cout << (res0 - res1) + res2 << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cnt = 0, len = 0, ans = 0, i;
char xx[3][111];
while (gets(xx[0]) != NULL) {
if (xx[0][0] == '+')
cnt++;
else if (xx[0][0] == '-')
cnt--;
else {
for (i = 0; xx[0][i]; i++)
if (xx[0][i] == ':') break;
ans = ans + (strlen(xx[0]) - i - 1) * cnt;
}
}
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e6 + 3;
const int MAXN = 10 + 5;
inline long long pw(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
inline void answer(int x) {
printf("! %d\n", x);
fflush(stdout);
exit(0);
}
inline int ask(int x) {
printf("? %d\n", x);
fflush(stdout);
int res;
scanf("%d", &res);
if (!res) answer(x);
if (res == -1) exit(0);
return res;
}
vector<int> mat[MAXN];
int main(void) {
int n = 10;
for (int i = 0; i <= n; ++i) {
mat[i].resize(n + 2);
mat[i][0] = 1;
for (int j = 1; j <= n; ++j) mat[i][j] = (long long)mat[i][j - 1] * i % mod;
mat[i].back() = ask(i);
}
for (int i = 0; i <= n; ++i) {
int now = -1;
for (int j = i; j <= n; ++j)
if (mat[j][i]) {
now = j;
break;
}
if (now == -1) {
continue;
}
swap(mat[i], mat[now]);
long long inv = pw(mat[i][i], mod - 2);
for (int j = i; j < (int)mat[i].size(); ++j)
mat[i][j] = mat[i][j] * inv % mod;
for (int j = 0; j <= n; ++j)
if (j != i) {
long long tmp = mat[j][i];
for (int k = i; k < (int)mat[j].size(); ++k)
mat[j][k] = (mat[j][k] - mat[i][k] * tmp % mod + mod) % mod;
}
}
for (int i = 0; i < mod; ++i) {
int res = 0;
long long tmp = 1;
for (int j = 0; j <= n; ++j) {
res = (res + mat[j].back() * tmp) % mod;
tmp = tmp * i % mod;
}
if (!res) answer(i);
}
answer(-1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n, i, j, l, k, a[105];
while (~scanf("%d", &n)) {
l = 0;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < n; k++) {
if (i != j && i != k && j != k && a[i] == a[j] + a[k]) {
printf("%d %d %d\n", i + 1, k + 1, j + 1);
l = 1;
break;
}
}
if (l == 1) break;
}
if (l == 1) break;
}
if (l == 0) printf("-1\n");
}
return 0;
}
| 2 |
/* https://codeforces.com/blog/entry/90236 (segment tree beats) */
#include <stdio.h>
#include <stdlib.h>
#define N 200000
#define Q 100000
#define N_ ((N + Q * 2) * (LG + 1))
#define LG 20
#define B (1 << LG)
int ll[1 + N_], rr[1 + N_], sz[1 + N_], msk0[1 + N_], msk1[1 + N_], lz[1 + N_], _ = 1;
void put(int u, int lg, int x) {
int tmp, x0, x1;
if (u == 0)
return;
if ((x & 1 << lg - 1) != 0)
tmp = ll[u], ll[u] = rr[u], rr[u] = tmp;
x0 = msk0[u] & ~x | msk1[u] & x, x1 = msk1[u] & ~x | msk0[u] & x;
msk0[u] = x0, msk1[u] = x1;
lz[u] ^= x;
}
void pus(int u, int lg) {
if (lz[u])
put(ll[u], lg - 1, lz[u]), put(rr[u], lg - 1, lz[u]), lz[u] = 0;
}
void pul(int u) {
int l = ll[u], r = rr[u];
sz[u] = sz[l] + sz[r], msk0[u] = msk0[l] | msk0[r], msk1[u] = msk1[l] | msk1[r];
}
int add(int u, int lg, int a) {
if (u == 0)
u = _++;
if (lg == 0)
sz[u] = 1, msk0[u] = a ^ B - 1, msk1[u] = a;
else {
if ((a & 1 << lg - 1) == 0)
ll[u] = add(ll[u], lg - 1, a);
else
rr[u] = add(rr[u], lg - 1, a);
pul(u);
}
return u;
}
void split(int *u, int *v, int lg, int l, int r, int ql, int qr) {
int m;
if (qr <= l || r <= ql || *u == 0) {
*v = 0;
return;
}
if (ql <= l && r <= qr) {
*v = *u, *u = 0;
return;
}
pus(*u, lg), *v = _++;
m = (l + r) / 2;
split(&ll[*u], &ll[*v], lg - 1, l, m, ql, qr), split(&rr[*u], &rr[*v], lg - 1, m, r, ql, qr);
pul(*u), pul(*v);
}
void merge(int *u, int *v, int lg) {
if (*u == 0) {
*u = *v;
return;
}
if (*v == 0 || lg == 0)
return;
pus(*u, lg), pus(*v, lg);
merge(&ll[*u], &ll[*v], lg - 1), merge(&rr[*u], &rr[*v], lg - 1);
pul(*u);
}
void update_or(int u, int lg, int x) {
if (u == 0)
return;
if ((x & msk0[u] & msk1[u]) == 0) {
put(u, lg, x & msk0[u]);
return;
}
pus(u, lg);
if ((x & 1 << lg - 1) != 0)
put(ll[u], lg - 1, 1 << lg - 1), merge(&rr[u], &ll[u], lg - 1), ll[u] = 0;
update_or(ll[u], lg - 1, x), update_or(rr[u], lg - 1, x);
pul(u);
}
int query(int u, int lg, int l, int r, int ql, int qr) {
int m;
if (qr <= l || r <= ql || u == 0)
return 0;
if (ql <= l && r <= qr)
return sz[u];
pus(u, lg);
m = (l + r) / 2;
return query(ll[u], lg - 1, l, m, ql, qr) + query(rr[u], lg - 1, m, r, ql, qr);
}
int main() {
int n, q, i, u;
scanf("%d%d", &n, &q);
u = 0;
for (i = 0; i < n; i++) {
int a;
scanf("%d", &a);
u = add(u, LG, a);
}
while (q--) {
int type, l, r;
scanf("%d%d%d", &type, &l, &r), r++;
if (type != 4) {
int x, v;
scanf("%d", &x);
split(&u, &v, LG, 0, B, l, r);
if (type == 1)
put(v, LG, B - 1), update_or(v, LG, x ^ B - 1), put(v, LG, B - 1);
else if (type == 2)
update_or(v, LG, x);
else
put(v, LG, x);
merge(&u, &v, LG);
} else
printf("%d\n", query(u, LG, 0, B, l, r));
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int p = 0;
int a[100100];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int s = n + n - 1;
for (int i = 0; i < n; i++) {
s += fabs(a[i] - p);
p = a[i];
}
printf("%d\n", s);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef struct point {
int x, y;
};
int n;
point A[5][5], v[10];
inline bool cmp(point a, point b) {
return (a.y > b.y) || (a.y == b.y && a.x < b.x);
}
inline int min(int a, int b) {
if (a < b) return a;
return b;
}
inline int max(int a, int b) {
if (a > b) return a;
return b;
}
int main() {
for (int i = 1; i <= 8; ++i) scanf("%d %d", &v[i].x, &v[i].y);
sort(v + 1, v + 9, cmp);
for (int i = 1, k = 0; i <= 3; ++i)
for (int j = 1; j <= 3; ++j)
if (i != 2 || j != 2) A[i][j] = v[++k];
int ok = 1;
int y = A[1][1].y;
for (int j = 2; j <= 3; ++j)
if (A[1][j].y != y) ok = 0;
if (A[2][1].y != A[2][3].y) ok = 0;
y = A[3][1].y;
for (int j = 2; j <= 3; ++j)
if (A[3][j].y != y) ok = 0;
int x = A[1][1].x;
for (int i = 2; i <= 3; ++i)
if (A[i][1].x != x) ok = 0;
if (A[1][2].x != A[3][2].x) ok = 0;
x = A[1][3].x;
for (int i = 2; i <= 3; ++i)
if (A[i][3].x != x) ok = 0;
for (int i = 1; i < 8; ++i)
for (int j = i + 1; j <= 8; ++j)
if (v[i].x == v[j].x && v[i].y == v[j].y) ok = 0;
if (ok)
printf("respectable\n");
else
printf("ugly\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const int inf = (signed)(~0u >> 1);
typedef class Event {
public:
int p, op, id;
Event(int p, int op, int id) : p(p), op(op), id(id) {}
bool operator<(Event b) const { return p < b.p; }
} Event;
typedef class pii {
public:
int x, y;
pii(int x, int y) : x(x), y(y) { (x > y) && (x = y); }
bool operator<(pii b) const { return (x ^ b.x) ? (x < b.x) : (y < b.y); }
} pii;
typedef class SegTreeNode {
public:
int v;
SegTreeNode *l, *r;
SegTreeNode() {}
void push_up() { v = max(l->v, r->v); }
} SegTreeNode;
SegTreeNode pool[N << 1];
SegTreeNode *_top = pool;
typedef class SegmentTree {
public:
int n;
SegTreeNode *rt;
SegmentTree() {}
SegmentTree(int n) : n(n) { build(rt, 1, n); }
void build(SegTreeNode *&p, int l, int r) {
p = _top++;
if (l == r) {
return;
}
int mid = (l + r) >> 1;
build(p->l, l, mid);
build(p->r, mid + 1, r);
}
void modify(SegTreeNode *p, int l, int r, int idx, int v) {
if (l == r) {
p->v += v;
return;
}
int mid = (l + r) >> 1;
if (idx <= mid) {
modify(p->l, l, mid, idx, v);
} else {
modify(p->r, mid + 1, r, idx, v);
}
p->push_up();
}
int query(SegTreeNode *p, int l, int r, int ql, int qr) {
if (l == ql && r == qr) {
return p->v;
}
int mid = (l + r) >> 1;
if (qr <= mid) {
return query(p->l, l, mid, ql, qr);
} else if (ql > mid) {
return query(p->r, mid + 1, r, mid + 1, qr);
}
int a = query(p->l, l, mid, ql, mid);
int b = query(p->r, mid + 1, r, mid + 1, qr);
return max(a, b);
}
void modify(int idx, int v) { modify(rt, 1, n, idx, v); }
int query(int l, int r) {
if (l > r) {
return 0;
}
return query(rt, 1, n, l, r);
}
} SegmentTree;
int n, C, m;
set<int> cur;
int f[N], g[N];
map<pii, int> G;
vector<Event> E;
vector<int> st, fr;
int L[N], R[N], c[N];
pair<int, int> ps[N];
int id[N];
SegmentTree seg;
int get_position(int cost) {
int l = 1, r = n, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (ps[mid].first <= cost) {
l = mid + 1;
} else {
r = mid - 1;
}
}
return l - 1;
}
int main() {
scanf("%d%d", &n, &C);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", L + i, R + i, c + i);
E.emplace_back(L[i], 1, i);
E.emplace_back(R[i], -1, i);
ps[i] = pair<int, int>(c[i], i);
}
E.emplace_back(0, 0, 0);
sort(E.begin(), E.end());
sort(ps + 1, ps + n + 1);
for (int i = 1; i <= n; i++) {
id[ps[i].second] = i;
}
if (n) {
seg = SegmentTree(n);
}
int freelen = 0, blank = 0;
for (int i = 0, j = 0; i < (signed)E.size(); i = j) {
for (; j < (signed)E.size() && E[j].p == E[i].p; j++) {
if (E[j].op == 1) {
cur.insert(E[j].id);
} else if (E[j].op == -1) {
cur.erase(cur.find(E[j].id));
}
}
int len = ((j == (signed)E.size()) ? (inf >> 1) : (E[j].p - E[i].p));
if (!cur.size()) {
st.push_back(E[i].p + len);
fr.push_back(freelen + (blank += len));
} else if (cur.size() == 1) {
int x = *cur.begin();
if (c[x] > C) {
continue;
}
int px = id[x];
seg.modify(px, -f[x]);
f[x] += len, g[x] += len;
int _ = get_position(C - c[x]);
_ = seg.query(1, _) + f[x];
g[x] = max(g[x], _);
seg.modify(px, f[x]);
int old = freelen;
freelen = max(f[x], freelen);
freelen = max(g[x], freelen);
if (old ^ freelen) {
st.push_back(E[j].p);
fr.push_back(freelen + blank);
}
} else if (cur.size() == 2) {
int x = *cur.begin(), y = *--cur.end();
if (c[x] + c[y] <= C) {
int com = (G[pii(x, y)] += len);
int old = freelen;
g[x] = max(g[x], f[x] + f[y] + com);
g[y] = max(g[y], f[x] + f[y] + com);
freelen = max(g[x], freelen);
freelen = max(g[y], freelen);
if (old ^ freelen) {
st.push_back(E[j].p);
fr.push_back(freelen + blank);
}
}
}
}
scanf("%d", &m);
int x;
while (m--) {
scanf("%d", &x);
int l = 0, r = (signed)fr.size() - 1, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (fr[mid] >= x) {
r = mid - 1;
} else {
l = mid + 1;
}
}
++r;
printf("%d\n", st[r] - (fr[r] - x));
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
bool works(long long n, long long N) { return (n >= (N * (3 * N + 1) / 2)); }
int bsearch(long long n, int low, int high) {
if (low == high) return low;
if ((low + 1) == high) {
if (works(n, high)) return high;
return low;
}
int mid = (low + high) / 2;
if (!works(n, mid))
return bsearch(n, low, mid);
else
return bsearch(n, mid, high);
}
int main() {
long long n;
cin >> n;
long long N = bsearch(n, 0, 1000000);
int first = 1;
while ((n + first) % 3) first++;
if (first > N)
cout << 0 << endl;
else
cout << ((N - first) / 3) + 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
int main() {
long long int n, y = 1;
scanf("%lld", &n);
while (n > y) {
n -= y;
y++;
}
printf("%lld", n);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, m, i, j;
scanf("%d %d", &n, &m);
if (n == 1 && m > 2) {
puts("1");
printf("1 %d 1 1\n", m);
for (i = 0; i < m; i++) printf("1 %d\n", i + 1);
puts("1 1");
} else if (m == 1 && n > 2) {
puts("1");
printf("%d 1 1 1\n", n);
for (i = 0; i < n; i++) printf("%d 1\n", i + 1);
puts("1 1");
} else if (n % 2 == 0) {
puts("0");
puts("1 1");
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
for (j = 1; j < m; j++) {
printf("%d %d\n", i + 1, j + 1);
}
} else {
for (j = m - 1; j >= 1; j--) {
printf("%d %d\n", i + 1, j + 1);
}
}
}
for (i = n; i > 0; i--) printf("%d 1\n", i);
} else {
if (m % 2 == 0) {
puts("0");
puts("1 1");
for (i = 0; i < m; i++) {
if (i % 2 == 0) {
for (j = 1; j < n; j++) {
printf("%d %d\n", j + 1, i + 1);
}
} else {
for (j = n - 1; j >= 1; j--) {
printf("%d %d\n", j + 1, i + 1);
}
}
}
for (i = m; i > 0; i--) printf("1 %d\n", i);
} else {
puts("1");
printf("%d %d 1 1\n", n, m);
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
for (j = 0; j < m; j++) {
printf("%d %d\n", i + 1, j + 1);
}
} else {
for (j = m - 1; j >= 0; j--) {
printf("%d %d\n", i + 1, j + 1);
}
}
}
puts("1 1");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, x;
scanf("%d%d", &n, &x);
int f[105] = {false};
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
f[a] = true;
}
int ans = 0;
for (int i = 0; i < x; i++) {
if (!f[i]) ans++;
}
if (f[x]) ans++;
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int get(int i) {
printf("? %d\n", (i - 1) % n + 1);
fflush(stdout);
int x;
scanf("%d", &x);
return x;
}
void respond(int i) {
if (i == -1)
printf("! -1\n");
else
printf("! %d\n", (i - 1) % n + 1);
fflush(stdout);
}
int intersection(int a, int va, int b, int vb, int c, int vc, int d, int vd) {
if (a == b) {
if (va == vc) return a;
return -1;
}
if (b == a + 1) {
if (va == vc) return a;
if (vb == vd) return d;
return -1;
}
int mid1 = (a + b) / 2;
int vmid1 = get(mid1);
int mid2 = (c + d) / 2;
int vmid2 = get(mid2);
if (vmid1 == vmid2) return mid1;
if ((va > vc && vmid1 > vmid2) || (va < vc && vmid1 < vmid2))
return intersection(mid1, vmid1, b, vb, mid2, vmid2, d, vd);
return intersection(a, va, mid1, vmid1, c, vc, mid2, vmid2);
}
int main() {
scanf("%d", &n);
int a = get(n / 2);
int b = get(n);
if (a == b) {
respond(n);
return 0;
}
int x = intersection(n / 2, a, n, b, n, b, n + n / 2, a);
respond(x);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 500 + 5;
const int MAXN = 500 + 5;
const int MAXQ = 300 + 5;
const int MAXK = 800 + 5;
const int P = 5;
const int MOD = 1e9 + 7;
int n, m, q, a[MAXN][MAXK];
int inv[P], ans = 1;
char buf[MAXM];
int main() {
for (int i = 0; i < P; i++) inv[i] = i * i * i % P;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", buf + 1);
for (int j = 1; j <= m; j++) a[j][i] = buf[j] - 'a';
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%s", buf + 1);
for (int j = 1; j <= m; j++) a[j][i + n] = buf[j] - 'a';
}
int cur = 1, r = 0;
for (int i = 1; i <= m && cur <= n; i++) {
while (cur <= n) {
int t = i;
for (int j = i + 1; j <= m; j++)
if (a[j][cur]) t = j;
for (int j = 1; j <= n + q; j++) swap(a[i][j], a[t][j]);
if (a[i][cur]) break;
cur++;
}
if (cur == n + 1) break;
for (int j = cur + 1; j <= n + q; j++)
a[i][j] = a[i][j] * inv[a[i][cur]] % P;
a[i][cur] = 1;
for (int j = i + 1; j <= m; j++) {
for (int k = cur + 1; k <= n + q; k++) {
a[j][k] -= a[j][cur] * a[i][k] % P;
if (a[j][k] < 0) a[j][k] += P;
}
a[j][cur] = 0;
}
r++;
}
for (int i = 1; i <= n - r; i++) ans = ans * 5ll % MOD;
for (int i = 1; i <= q; i++) {
int x = ans;
for (int j = 1; j <= m; j++) {
bool flg = 1;
for (int k = 1; k <= n; k++) flg &= (a[j][k] == 0);
flg &= (a[j][n + i] > 0);
if (flg) x = 0;
}
printf("%d\n", x);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int TestMillerRabin[5] = {2, 3, 5, 7, 11};
long long mulmod(long long a, long long b, long long p) {
long long x = 0, y = a % p;
while (b > 0) {
if (b % 2 == 1) x = (x + y) % p;
y = (1LL * y * 2) % p;
b = b / 2;
}
return x % p;
}
long long fastexp(long long x, long long y, long long p) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (1LL * ans * x) % p;
y = y >> 1;
x = (1LL * x * x) % p;
}
return ans % p;
}
long long fastexpp(long long x, long long y, long long p) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = mulmod(ans, x, p);
y = y >> 1;
x = mulmod(x, x, p);
}
return ans % p;
}
long long invmod(long long x, long long p) { return fastexp(x, p - 2, p) % p; }
bool check_composite(long long n, long long a, long long d, int s) {
long long x = fastexp(a, d, n);
if (x == 1 || x == n - 1) return false;
for (int r = 1; r < s; r++) {
x = (1LL * x * x) % n;
if (x == n - 1) return false;
}
return true;
}
bool isPrime(long long p) {
if (p <= 1) return false;
int r = 0;
long long d = p - 1;
while ((d & 1) == 0) {
d >>= 1;
r++;
}
for (int i = 0; i < 5; i++) {
int value = TestMillerRabin[i];
if (p == value) return true;
if (check_composite(p, value, d, r)) return false;
}
return true;
}
vector<long long> prefhash(string p) {
int pi = 31;
vector<long long> pref;
for (int i = 0; i < p.size(); i++) {
if (i > 0) {
long long aux = pref[i - 1];
pref.push_back(
(aux + ((p[i] - 'a' + 1) * fastexp(pi, i, 1000000009)) % 1000000009) %
1000000009);
} else
pref.push_back(p[i] - 'a' + 1);
}
return pref;
}
long long hashsubs(string p, int i, int j, vector<long long> pp) {
int pi = 31;
int sz = j - i + 1;
long long fp = (pp[i + sz - 1] - pp[i - 1] + 1000000009) % 1000000009;
long long sp = invmod(fastexp(pi, i, 1000000009), 1000000009);
return (1LL * fp * sp) % 1000000009;
}
int main() {
int n;
cin >> n;
if (n <= 2) {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << i << '\n';
return 0;
}
if (n == 4) {
cout << "YES\n";
cout << "1\n3\n2\n4";
return 0;
}
if (isPrime(n)) {
cout << "YES\n";
cout << "1\n2\n";
int cp = 2;
for (int i = 2; i < n - 1; i++) {
int gg = invmod(cp, n);
int m = (1LL * (cp + 1) * gg) % n;
cp = (1LL * cp * m) % n;
cout << m << '\n';
}
cout << n << '\n';
} else
cout << "NO";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int M = 1000000007;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res % p;
}
long long int modinver(long long int a, long long int b) {
return (power(a, 1, M) * power(b, M - 2, M)) % M;
}
void SieveOfEratosthenes(int n) {
bool prime[10005];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
long long int count1[100002];
std::vector<long long int> index1[100002];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k;
cin >> n >> k;
for (int i = 0; i < k; ++i) {
long long int a;
cin >> a;
count1[a]++;
index1[a].push_back(i);
}
long long int ans = 0;
for (int i = 1; i <= n; ++i) {
if (count1[i] == 0) {
ans++;
if (i > 1 && count1[i - 1]) {
ans += 2;
}
if (i < n) ans += 2;
} else if (i < n && count1[i + 1]) {
if (index1[i + 1][index1[i + 1].size() - 1] < index1[i][0] ||
index1[i][index1[i].size() - 1] < index1[i + 1][0]) {
ans += 1;
}
}
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int boobs(string s) {
int n = s.length();
int i = 0;
int total = 0;
for (i = 0; i < n; i++) {
if (s[i] == '.' && s[i + 1] == '.') total++;
}
return total;
}
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
int a;
char c;
int i = 0;
int j = 0;
int x = boobs(s);
for (i = 1; i <= m; i++) {
cin >> a >> c;
if (s[a - 1] != '.' && c != '.')
cout << x << endl;
else if (s[a - 1] != '.' && c == '.') {
s[a - 1] = c;
if (s[a - 2] == '.' && s[a] == '.')
x = x + 2;
else if (s[a - 2] != '.' && s[a] != '.')
x = x;
else
x++;
cout << x << endl;
} else if (s[a - 1] == '.' && c == '.')
cout << x << endl;
else {
s[a - 1] = c;
if (s[a - 2] == '.' && s[a] == '.')
x = x - 2;
else if (s[a - 2] != '.' && s[a] != '.')
x = x;
else
x--;
cout << x << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
if (n == 2) {
cout << 1;
return 0;
}
int c = 0;
for (int i = 2; i < n; ++i) {
bool f = true;
int arr[2005] = {0};
for (long long j = i, s = 1; s <= n - 2; j = (j * i) % n, s++) {
if (arr[j] != 0) {
f = false;
break;
}
arr[j] = j;
}
cout << endl;
if (f) c++;
}
cout << c;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int main() {
ios::sync_with_stdio(false);
int n, k, i;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
}
if (n == 1) {
cout << "0\n";
cout << a[0];
return 0;
}
int sum = 0, x;
for (i = 0; i < n - 2; i++) {
if (a[i] + a[i + 1] < k) {
x = k - (a[i] + a[i + 1]);
sum += x;
a[i + 1] += x;
}
}
if (a[n - 2] + a[n - 1] < k) {
x = k - (a[n - 2] + a[n - 1]);
sum += x;
a[n - 2] += x;
}
cout << sum << "\n";
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ways[105][25][25] = {0};
vector<int> G[100];
int n, k, visited[100] = {0};
void DFS(int v) {
visited[v] = 1;
long long w[25][25] = {0};
w[1][0] = 1;
w[k + 1][1] = 1;
for (auto x : G[v]) {
if (!visited[x]) {
DFS(x);
long long comb[25][25] = {0};
for (int b1 = 0; b1 <= k + 1; b1++) {
for (int w1 = 0; w1 <= k + 1; w1++) {
for (int b2 = 0; b2 <= k + 1; b2++) {
for (int w2 = 0; w2 <= k + 1; w2++) {
int lw1, lw2;
if (w1 == 0 || w1 - 1 + b2 <= k)
lw1 = 0;
else
lw1 = w1;
if (w2 == 0 || w2 - 1 + b1 <= k)
lw2 = 0;
else
lw2 = w2 + 1;
if (lw2 <= k + 1 && lw1 <= k + 1)
comb[min(b1, b2 + 1)][max(lw2, lw1)] +=
((ways[x][b2][w2]) * (w[b1][w1]) % 1000000007);
}
}
}
}
for (int i = 0; i < 25; i++)
for (int j = 0; j < 25; j++) w[i][j] = comb[i][j] % 1000000007;
}
}
for (int i = 0; i < 25; i++)
for (int j = 0; j < 25; j++) ways[v][i][j] = w[i][j];
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
DFS(0);
long long ans = 0;
for (int i = 0; i <= k + 1; i++) ans += ways[0][i][0];
ans %= 1000000007;
cout << ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
int a = 0, ac = 0, b = 0, bc = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (a == 0 || a == x) {
a = x;
ac++;
} else if (b == 0 || b == x) {
b = x;
bc++;
} else {
cout << "NO" << endl;
return 0;
}
}
if (ac == bc)
cout << "YES\n" << a << " " << b << endl;
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k = 1999;
cin >> n >> m;
for (int i = 0; i < k; i++)
if (~i % 2)
cout << 9;
else
cout << 0;
cout << endl;
for (int i = 0; i < k - 2; i++)
if (~i % 2)
cout << 9;
else
cout << 0;
cout << 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 7;
const long long Mod = 152076289;
char seq[MAXN], s[MAXN];
int T = 1;
int main(void) {
scanf("%s", seq);
int L = strlen(seq);
if (L % 2 == 1) {
printf("No\n");
return 0;
}
s[1] = seq[0];
for (int i = 1; i < L; i++) {
if (s[T] == seq[i] && T > 0) {
T--;
continue;
} else {
T++;
s[T] = seq[i];
}
}
if (T == 0)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 809;
struct E {
int u, v, w;
bool operator<(E a) const { return w < a.w; }
} e[300009];
int id[200009];
long long d[N][N], a[1000009];
int main() {
int n, m, o, i, j, k, t = 0;
scanf("%d%d%d", &n, &m, &o), memset(d, 63, sizeof d);
for (i = 1; i <= m; ++i) scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
sort(e + 1, e + m + 1);
for (i = 1; i <= o; ++i) {
if (!id[e[i].u]) id[e[i].u] = ++t;
if (!id[e[i].v]) id[e[i].v] = ++t;
j = id[e[i].u], k = id[e[i].v], d[j][k] = d[k][j] = e[i].w;
}
for (i = 1; i <= t; ++i)
for (j = 1; j <= t; ++j)
for (k = 1; k < j; ++k)
d[j][k] = d[k][j] = min(d[j][k], d[j][i] + d[i][k]);
k = 0;
for (i = 1; i <= t; ++i)
for (j = 1; j < i; ++j) a[++k] = d[i][j];
sort(a + 1, a + k + 1), printf("%lld", a[o]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> swap1, swap2;
int move(int arr[], int from, int to) {
int count = 0, temp, copyFrom = from, fromValue = arr[from];
while (true) {
if (arr[to] == fromValue) break;
swap1.push_back(copyFrom - 1);
swap2.push_back(copyFrom);
swap(arr[copyFrom], arr[copyFrom - 1]);
copyFrom--;
count++;
}
return count;
}
int main() {
int n, moves = 0;
cin >> n;
int *a = new int[n + 1];
int *b = new int[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) {
if (a[i] == b[i]) continue;
moves += move(b, distance(b, find(b + i, b + n + 1, a[i])), i);
}
cout << moves << endl;
if (swap1.size() > 0) {
int k = 0;
for (k; k < swap1.size() - 1; k++)
cout << swap1[k] << " " << swap2[k] << endl;
cout << swap1[k] << " " << swap2[k];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, g[150], zbr;
string s;
char p[5];
int main() {
scanf("%d", &n);
scanf("%s", p);
vector<pair<string, string> > v;
set<string> l;
for (int i = (0); i < int(n); i++) {
cin >> s;
v.push_back(make_pair(s.substr(0, 3), s.substr(5, 3)));
l.insert(s.substr(0, 3));
l.insert(s.substr(5, 3));
}
vector<pair<int, int> >::iterator it;
for (int i = (0); i < int(v.size()); i++) {
for (int j = (0); j < int(v.size()); j++) {
if (v[i].first == v[j].second && i != j) {
if (i > j) {
v.erase(j + v.begin());
v.erase(i + v.begin() - 1);
}
if (i < j) {
v.erase(i + v.begin());
v.erase(j + v.begin() - 1);
}
i = 0;
j = 0;
}
}
}
if (v.size() > 0)
printf("contest\n");
else
printf("home\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans, u, v, i, root_u, root_v, arr[100001], len[100001], c[100001],
k;
vector<pair<long long, long long> > in;
long long find(long long x) {
if (arr[x] == x) return x;
return arr[x] = find(arr[x]);
}
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) arr[i] = i, len[i] = 1;
for (i = 0; i < k; i++) {
cin >> u >> v;
root_u = find(u);
root_v = find(v);
if (root_u != root_v) arr[root_u] = root_v, len[root_v] += len[root_u];
c[u]++;
}
for (i = 1; i <= n; i++)
if (arr[i] != i) c[find(i)] += c[i];
for (i = 1; i <= n; i++)
if (arr[i] == i) ans += (c[i] - len[i] + 1);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, city = 1;
bool count;
cin >> n;
int* time;
time = new int[n];
for (i = 0; i < n; i++) cin >> time[i];
int t = time[0];
for (i = 0; i < n; i++) {
if (time[i] == t && i > 0) count = true;
if (time[i] < t) {
t = time[i];
city = i + 1;
count = false;
}
}
if (count)
cout << "Still Rozdil";
else
cout << city;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > vd(n);
multiset<pair<int, pair<int, int> > > ds;
int td, ts;
for (int i = 0; i < n; i++) {
cin >> td >> ts;
if (td == 0) continue;
vd[i] = make_pair(td, ts);
ds.insert(make_pair(td, make_pair(ts, i)));
}
vector<pair<int, int> > edges;
while (ds.size() > 1) {
pair<int, pair<int, int> > leaf = *(ds.begin());
edges.push_back(make_pair(leaf.second.second, leaf.second.first));
ds.erase(ds.begin());
if (leaf.first != 1) cout << "SHIT!!!" << endl;
pair<int, int> parent = vd[leaf.second.first];
ds.erase(
make_pair(parent.first, make_pair(parent.second, leaf.second.first)));
parent.first--;
parent.second ^= leaf.second.second;
if (parent.first >= 1)
ds.insert(
make_pair(parent.first, make_pair(parent.second, leaf.second.first)));
vd[leaf.second.first] = parent;
}
cout << edges.size() << endl;
for (int i = 0; i < edges.size(); i++) {
cout << edges[i].first << " " << edges[i].second << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
const double eps = 1e-8;
int t;
long long n;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%lld", &n);
long long ans = 0;
int cnt = 0;
while (n) {
if (n % 2 == 0) {
if (n % 4 == 0 && n != 4) {
if (cnt % 2 == 0) ans++;
n--, cnt++;
} else {
if (cnt % 2 == 0) ans += n / 2;
n /= 2, cnt++;
}
} else {
if (cnt % 2 == 0) ans++;
n--, cnt++;
}
}
printf("%lld\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[(1 << 23)];
int main() {
int i, j, k, n, m, t, x;
cin >> t;
while (t--) {
cin >> n >> m;
int a[n], b[m];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
string s[n];
for (i = 0; i < n; i++) {
cin >> s[i];
for (j = 0; j < m; j++) {
if (s[i][j] == '*') {
a[i]++;
b[j]++;
}
}
}
int ans = 999999999;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (s[i][j] == '*')
ans = min(ans, (n + m - a[i] - b[j]));
else
ans = min(ans, (n + m - 1 - a[i] - b[j]));
}
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[1007];
int t, k, f[1007][1007][2], a[1007], l;
int dfs(int pos, int d, int q, int m) {
if (!pos) return q;
if (!m && f[pos][d][q] != -1) return f[pos][d][q];
int ans = 0, MAX = m ? a[pos] : 9;
for (int i = 0; i <= MAX; i++) {
if (i != 4 && i != 7)
ans = (ans + dfs(pos - 1, max(d - 1, 0), q, m && i == MAX)) % 1000000007;
else
ans = (ans + dfs(pos - 1, k, q || d, m && i == MAX)) % 1000000007;
}
if (!m) f[pos][d][q] = ans;
return ans;
}
int check() {
int LAST = 2007;
for (int i = l; i; i--) {
if (a[i] == 4 || a[i] == 7) {
if (LAST - i <= k) return 1;
LAST = i;
}
}
return 0;
}
int main() {
scanf("%d%d", &t, &k);
memset(f, -1, sizeof(f));
while (t--) {
scanf("%s", s);
l = strlen(s);
for (int i = l - 1; i >= 0; i--) a[l - i] = s[i] - '0';
int ans = (dfs(l, 0, 0, 1) - check() + 1000000007) % 1000000007;
scanf("%s", s);
l = strlen(s);
for (int i = l - 1; i >= 0; i--) a[l - i] = s[i] - '0';
ans = (dfs(l, 0, 0, 1) + 1000000007 - ans) % 1000000007;
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
template <class K>
inline bool umax(K& a, K b) {
return a < b ? a = b, true : false;
}
template <class K>
inline bool umin(K& a, K b) {
return a > b ? a = b, true : false;
}
template <class K>
inline void read(K& first) {
char c = getchar();
K f = +1;
for (first = 0; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; c = getchar()) first = first * 10 + c - '0';
first = first * f;
}
template <class K>
inline void write(K first) {
static int fout[20], top;
if (first < 0) putchar('-'), first = -first;
do fout[top++] = first % 10, first /= 10;
while (first);
while (top) putchar(fout[--top] + '0');
}
const int maxN = 1e5 + 5, SIZE = 800, oo = 0x3f3f3f3f;
struct node {
int r, c;
node() {}
node(int _r, int _c) : r(_r), c(_c) {}
bool operator<(const node& rhs) const {
return c < rhs.c || (c == rhs.c && r < rhs.r);
}
};
node S[maxN];
int N, K;
void input() {
read(N), read(K);
for (int i = 1; i <= K; ++i) {
read(S[i].r), read(S[i].c);
}
}
bool flag[maxN][SIZE + 5];
int f[SIZE + 5], cnt[SIZE + 5];
void exec() {
int ans = 0;
for (int i = 1; i <= K; ++i) {
int first = S[i].r, second = S[i].c;
if (N - first + 1 < SIZE)
flag[second][N - first + 1] = true;
else
ans += 3;
}
for (int i = 1; i <= SIZE + 1; ++i) f[i] = oo;
for (int i = 1; i <= N; ++i) {
cnt[1 + SIZE] = 0;
int mc = oo;
for (int j = SIZE; ~j; --j) cnt[j] = cnt[j + 1] + flag[i][j];
for (int j = 0; j <= SIZE; ++j) {
umin(mc, f[j]);
f[j] = std::min(f[j + 1], mc + (j ? j * (j + 1) / 2 + 2 : 0)) +
cnt[j + 1] * 3;
}
}
write(*std::min_element(f, f + SIZE + 1) + ans), putchar('\n');
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
input();
exec();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int ninf = 0xc0c0c0c0;
const long long linf = 0x3f3f3f3f3f3f3f3fll;
const long long lninf = 0xc0c0c0c0c0c0c0c0ll;
int fa[1005], d[1005];
vector<int> a[1005], son[1005];
void dfs(int i, int f, int num) {
fa[i] = f;
d[i] = d[f] + 1;
son[num].emplace_back(i);
for (auto j : a[i])
if (j != f) dfs(j, i, num + 1);
}
pair<int, int> query(vector<int> a) {
int x, y;
cout << "? " << int(a.size());
for (auto i : a) cout << " " << i;
cout << endl;
cin >> x >> y;
if (x == -1 && y == -1) exit(0);
return {x, y};
}
int main() {
ios::sync_with_stdio(false);
int T;
cin >> T;
for (int I = 1; I <= T; I++) {
memset(fa, 0, sizeof(fa));
memset(d, 0, sizeof(d));
int n, x, dis, k = 0, mx = 0, ans1, ans2;
string s;
cin >> n;
for (int i = 0; i <= n; i++) {
a[i].clear();
son[i].clear();
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
a[x].emplace_back(y);
a[y].emplace_back(x);
}
cout << "? " << n;
for (int i = 1; i <= n; i++) cout << " " << i;
cout << endl;
cin >> x >> dis;
dfs(x, 0, 0);
while (1 << mx + 1 <= n) mx++;
ans1 = x;
for (int i = mx; i >= 0; i--)
if (k + (1 << i) <= n && !son[k + (1 << i)].empty()) {
pair<int, int> p = query(son[k + (1 << i)]);
if (p.second == dis) {
k += 1 << i;
ans1 = p.first;
}
}
x = ans1;
while (d[x] - 1 > dis - k) x = fa[x];
if (dis - k == 0)
ans2 = x;
else {
for (int i = 0; i < int(son[dis - k].size()); i++)
if (son[dis - k][i] == x) {
son[dis - k].erase(son[dis - k].begin() + i);
break;
}
ans2 = query(son[dis - k]).first;
}
cout << "! " << ans1 << ' ' << ans2 << endl;
cin >> s;
if (s != "Correct") break;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, res, nt, b, f;
long long p[300007], pp[300007], a[300007];
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + 1 + n);
p[1] = 2;
pp[1] = 0;
for (int i = 2; i <= n; i++) {
pp[i] = (2 * pp[i - 1] + 1) % 1000000007;
}
res = 0;
for (int i = 1; i <= n; i++) {
res += (a[i] * pp[i]) % 1000000007;
res -= (a[i] * pp[n + 1 - i]) % 1000000007;
while (res < 0) res += 1000000007;
res %= 1000000007;
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
vector<long long> v(n + 1);
for (long long i = 1; i <= n; i++) {
cin >> v[i];
}
long long left = 0;
long long right = 0;
for (long long i = 1; i <= n; i++) {
if (v[i])
right = i;
else {
left = i;
}
}
cout << min(left, right);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct road {
int start, end, len, id;
} rd[500005];
int fa[2005];
bool cmp(road x, road y) { return x.len > y.len; }
inline int getf(int x) {
if (fa[x] == x) return fa[x];
return fa[x] = getf(fa[x]);
}
inline void con(int x, int y) {
int f1, f2;
f1 = getf(x), f2 = getf(y);
if (f1 != f2) fa[f1] = f2;
}
int main() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
cin >> rd[i].start >> rd[i].end >> rd[i].len;
rd[i].id = i;
}
sort(rd + 1, rd + 1 + m, cmp);
while (q--) {
int ans = -1, l, r;
cin >> l >> r;
for (int i = 1; i <= n * 2; i++) {
fa[i] = i;
}
for (int i = 1; i <= m; i++) {
if (rd[i].id >= l && rd[i].id <= r) {
if (getf(rd[i].start) == getf(rd[i].end)) {
ans = rd[i].len;
break;
} else {
con(rd[i].start + n, rd[i].end);
con(rd[i].start, rd[i].end + n);
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long k, ans, idx, pwr, hs;
bool A[500005], B[500005], l;
string s, s1, s2, s3;
map<string, bool> mp;
unordered_set<long long> st;
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> s >> s1 >> s2;
for (long long i = 0; i + s1.size() - 1 < s.size(); i++) {
idx = i;
l = true;
for (long long j = i; j <= i + s1.size() - 1; j++) {
if (s[j] != s1[j - i]) {
l = false;
break;
}
}
A[i] = l;
}
for (long long i = 0; i + s2.size() - 1 < s.size(); i++) {
idx = i;
l = true;
for (long long j = i; j <= i + s2.size() - 1; j++) {
if (s[j] != s2[j - i]) {
l = false;
break;
}
}
B[i] = l;
}
for (long long i = 0; i + s1.size() - 1 < s.size(); i++) {
if (i + s2.size() - 1 == s.size()) break;
if (A[i] == false) continue;
pwr = 1;
hs = 0;
for (long long j = i; j < s.size(); j++) {
if (s.size() - j < s2.size()) break;
hs = (hs + (s[j] - 'a' + 1) * pwr);
if (hs >= 1000000007) hs -= 1000000007;
pwr *= 31;
if (pwr >= 1000000007) pwr -= 1000000007;
if (B[j] == true && i + s1.size() - 1 <= j + s2.size() - 1) {
st.insert(hs);
}
}
}
cout << st.size();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y, k, n, i, ok = 0;
scanf("%d%d%d", &y, &k, &n);
for (i = 1; i <= n / k; i++)
if (i * k - y >= 1) {
printf("%d ", i * k - y);
ok = 1;
}
if (ok == 0) printf("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int MAXR = 1e5 + 5;
int ok[MAXR];
int main() {
ios::sync_with_stdio(false);
long long n, m, i, l, r, a;
long long minl = INF, maxr = -1;
long long sum = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
sum += a;
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> l >> r;
ok[l]++;
ok[r + 1]--;
}
for (i = 0; i < MAXR; i++) {
ok[i] += ok[i - 1];
}
for (i = sum; i < MAXR; i++) {
if (ok[i]) break;
}
if (i < MAXR)
cout << i << endl;
else
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long S, X, N, i, j;
bool A[40], B[40];
void masuk(bool A[], long long X) {
int i;
long long S = X, P = pow(2, 39);
for (i = 0; i < 40; i++) {
A[i] = (S >= P);
S = S % P;
P /= 2;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> S >> X;
if (S < X) {
cout << 0 << '\n';
return 0;
}
masuk(A, X);
masuk(B, S - X);
if (B[39]) {
cout << 0 << '\n';
return 0;
}
N = A[39];
for (i = 0; i < 39; i++) {
if (B[i] && A[i + 1]) {
cout << 0 << '\n';
return 0;
}
N += A[i];
}
cout << (long long)pow(2, N) - 2 * (S == X) << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
std::vector<int> adj[200000];
std::vector<int> d(n, INT_MAX);
std::vector<int> d2(n, INT_MAX);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u - 1].push_back(v - 1);
adj[v - 1].push_back(u - 1);
}
std::vector<int> colour(n, 0);
queue<int> q;
std::vector<int> bfs;
q.push(0);
colour[0] = 1;
d[0] = 0;
d2[0] = 0;
while (!q.empty()) {
int poped = q.front();
q.pop();
bfs.push_back(poped);
for (auto v : adj[poped]) {
if (!colour[v]) {
q.push(v);
colour[v] = 1;
if (d[v] > d[poped] + 1) d2[v] = d[v] = d[poped] + 1;
}
}
}
int answer = 0;
for (int i = n - 1; i >= 0; i--) {
int v = bfs[i];
if (d2[v] > 2) {
for (auto j : adj[v]) {
if (d[j] == d[v] - 1) {
d2[j] = 1;
for (auto k : adj[j]) {
d2[k] = 2;
}
answer++;
break;
}
}
}
}
cout << answer << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int t, len;
cin >> t;
while (t--) {
int a = 0, element;
cin >> len;
for (int i = 1; i <= len; i++) {
cin >> element;
if (element % 2 == 0) a = i;
}
if (a) {
cout << 1 << "\n";
cout << a << "\n";
} else {
if (len == 1) {
cout << -1 << "\n";
} else {
cout << 2 << "\n";
cout << 1 << " " << 2 << "\n";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int bit[11][11][5][N];
char s[N], e[11];
int get(char z) {
if (z == 'A') return 0;
if (z == 'T') return 1;
if (z == 'G') return 2;
if (z == 'C') return 3;
}
void update(int step, int start, int let, int pos, int x) {
while (pos < N) {
bit[step][start][let][pos] += x;
pos += (pos & -pos);
}
}
int query(int step, int start, int let, int pos) {
int ans = 0;
while (pos > 0) {
ans += bit[step][start][let][pos];
pos -= (pos & -pos);
}
return ans;
}
int main() {
int n, q, t, l, r, x, y, aux;
char c;
scanf(" %s", s);
n = strlen(s);
aux = min(n, 10);
for (int i = 1; i <= aux; i++) {
for (int j = 0; j < aux; j++) {
for (int k = j; k < n; k += i) {
y = get(s[k]);
update(i, j, y, k + 1, 1);
}
}
}
scanf("%d", &q);
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d %c", &x, &c);
y = get(s[x - 1]);
for (int i = 1; i <= aux; i++) {
for (int j = 0; j < aux; j++) {
if ((x - 1) % i == j % i) update(i, j, y, x, -1);
}
}
y = get(c);
s[x - 1] = c;
for (int i = 1; i <= aux; i++) {
for (int j = 0; j < aux; j++) {
if ((x - 1) % i == j % i) update(i, j, y, x, 1);
}
}
} else {
scanf("%d %d %s", &l, &r, e);
int len = strlen(e);
int ans = 0;
for (int i = 0; i < min(len, n); i++) {
y = get(e[i]);
x = query(min(len, n), (l - 1 + i) % len, y, r) -
query(min(len, n), (l - 1 + i) % len, y, l - 1);
ans += x;
}
printf("%d\n", ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
vector<int> a(n, 0);
for (i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
double ans, pi = 3.1415926536;
if (n % 2 != 0) {
ans = pi * a[0] * a[0];
for (i = 2; i < n; i = i + 2) ans += pi * (pow(a[i], 2) - pow(a[i - 1], 2));
} else {
ans = 0.0;
for (i = 1; i < n; i = i + 2) ans += pi * (pow(a[i], 2) - pow(a[i - 1], 2));
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 10;
const double eps = 1e-5;
const int maxN = 2 * 1000 + 100;
const int inf = 1e9 + 100;
int n;
char c[maxN];
inline void init() {
scanf("%d", &n);
scanf("%s", c);
}
inline void solve() {
int m = strlen(c);
int ans = 0;
for (int i = 0; i < m; i++) {
if (i > 2 && i % n == 0 && c[i - 1] == c[i - 2] && c[i - 2] == c[i - 3])
ans++;
}
printf("%d", ans);
}
int main() {
ios_base::sync_with_stdio(0);
init();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int d[102];
for (int i = 1; i <= n - 1; i++) {
cin >> d[i];
}
int a, b;
cin >> a >> b;
int count = 0;
for (int i = a; i < b; i++) {
count += d[i];
}
cout << count;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.