solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int sum1(vector<int> v) {
int l = v.size();
int i;
int val = 0;
for (i = 0; i < l; i++) {
val += v[i];
}
return val;
}
int main() {
int n, i, a[1001];
vector<int> even;
vector<int> odd;
int e = 0;
int o = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
if (a[i] % 2 == 0) {
e++;
even.push_back(a[i]);
} else {
o++;
odd.push_back(a[i]);
}
}
if (o % 2 != 0) {
cout << sum1(odd) + sum1(even) << endl;
} else if (odd.size() == 0)
cout << "0" << endl;
else {
cout << sum1(odd) + sum1(even) - odd[odd.size() - 1] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long fact[100005], sum_fact = 1, MOD = 1e9 + 7, dp[100005], tep[100005],
ans[52][52], W;
int len, a[52];
string S;
int change(char c) {
if ('a' <= c && c <= 'z')
return c - 'a';
else
return c - 'A' + 26;
}
long long mu(long long u, int v) {
if (v == 0) return 1ll;
if (v == 1) return u;
long long m = mu(u, v / 2);
if (v % 2 == 0)
return (m * m) % MOD;
else
return (((m * m) % MOD) * u) % MOD;
}
void init() {
for (int i = 0; i < len; i++) ++a[change(S[i])];
dp[0] = 1;
fact[0] = 1;
for (int i = 1; i <= len / 2; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 0; i < 52; i++) {
if (a[i] == 0) continue;
for (int j = len / 2; j >= a[i]; j--) {
dp[j] = (dp[j] + dp[j - a[i]]) % MOD;
}
sum_fact = (sum_fact * fact[a[i]]) % MOD;
}
for (int i = 0; i < 52; i++) ans[i][i] = dp[len / 2];
for (int i = 0; i < 52; i++) {
if (a[i] == 0) continue;
for (int j = len / 2; j >= 0; j--) tep[j] = dp[j];
for (int j = a[i]; j <= len / 2; j++)
tep[j] = (tep[j] - tep[j - a[i]] + MOD) % MOD;
for (int j = i + 1; j < 52; j++) {
if (a[j] == 0) continue;
for (int k = a[j]; k <= len / 2; k++) {
tep[k] = (tep[k] - tep[k - a[j]] + MOD) % MOD;
}
ans[i][j] = (2ll * tep[len / 2]) % MOD;
for (int k = len / 2; k >= a[j]; k--) {
tep[k] = (tep[k] + tep[k - a[j]] + MOD) % MOD;
}
}
}
}
int main() {
cin >> S;
len = S.length();
init();
W = (mu(fact[len / 2], 2) * mu(sum_fact, MOD - 2)) % MOD;
int q;
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
--x, --y;
x = change(S[x]);
y = change(S[y]);
if (x > y) swap(x, y);
cout << (W * ans[x][y]) % MOD << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, MOD = 1e9 + 7;
int n, f[N], t, s[N], ans, id[N], g[N];
int vis[N << 1];
struct Node {
int l, r;
} p[N];
struct BIT {
int c[N << 1];
void add(int x, int v) {
for (; x; x &= x - 1) (c[x] += v) %= MOD;
}
int ask(int x) {
int res = 0;
for (; x <= n * 2; x += x & -x) (res += c[x]) %= MOD;
return res;
}
} t1, t2;
int c[N << 1];
void add(int x, int v) {
for (; x; x &= x - 1) c[x] = max(c[x], v);
}
int ask(int x) {
int res = 0;
for (; x <= n * 2; x += x & -x) res = max(res, c[x]);
return res;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) scanf("%d%d", &p[i].l, &p[i].r), id[i] = i;
scanf("%d", &t);
int mx = 0;
for (int i = (1); i <= (t); ++i) {
scanf("%d", s + i);
vis[p[s[i]].r] = 1;
mx = max(mx, p[s[i]].r);
}
sort(p + 1, p + n + 1,
[](const Node &a, const Node &b) { return a.r < b.r; });
for (int i = (1); i <= (n); ++i) {
f[i] = (t2.ask(p[i].l) + t1.ask(p[i].l)) % MOD;
g[i] = ask(p[i].l);
t1.add(p[i].l, 1);
t2.add(p[i].l, f[i]);
if (vis[p[i].r]) add(p[i].l, p[i].r);
}
sort(id + 1, id + n + 1,
[](const int &i, const int &j) { return p[i].l < p[j].l; });
for (int i = (1); i <= (n); ++i) {
if (p[id[i]].r > mx) continue;
if (p[id[i]].r < mx)
(ans += f[id[i]] + 1) %= MOD;
else {
(ans += f[id[i]] + 1) %= MOD;
mx = g[id[i]];
}
}
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, sm = 0;
cin >> n;
vector<long long> v[3];
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
v[x % 3].push_back(x);
sm += x;
sm %= 3;
}
for (long long i = 0; i < 3; i++) sort(v[i].rbegin(), v[i].rend());
if (sm) {
if (v[sm].size())
v[sm].pop_back();
else
v[3 - sm].pop_back(), v[3 - sm].pop_back();
}
string ans;
for (long long i = 0; i < 3; i++) {
for (auto it : v[i]) ans += (it + '0');
}
sort(ans.rbegin(), ans.rend());
if (ans.back() != '0')
cout << -1 << "\n";
else {
if (ans[0] == '0')
cout << 0;
else
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char get(int i) {
if (i % 3 == 0) {
return 'R';
}
if (i % 3 == 1) {
return 'G';
}
if (i % 3 == 2) {
return 'B';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int counter1 = 0;
int counter2 = 0;
int counter3 = 0;
int myMin = k;
for (int l = 0; l < k; l++) {
if (s[l] != get(l)) {
counter1++;
}
if (s[l] != get(l + 1)) {
counter2++;
}
if (s[l] != get(l + 2)) {
counter3++;
}
}
myMin = min(myMin, min(counter1, min(counter2, counter3)));
for (int j = 0; j < n - k; j++) {
if (get(j) != s[j]) {
counter1--;
}
if (get(k + j) != s[j + k]) {
counter1++;
}
if (get(j + 1) != s[j]) {
counter2--;
}
if (get(k + j + 1) != s[j + k]) {
counter2++;
}
if (get(j + 2) != s[j]) {
counter3--;
}
if (get(k + j + 2) != s[j + k]) {
counter3++;
}
myMin = min(myMin, min(counter1, min(counter2, counter3)));
}
cout << myMin << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int tt, n, i, js, jt, a[200200], cc, c[200200], fi[200200], cnt[5];
char s[200200], t[200200];
int main() {
scanf("%d", &tt);
while (tt--) {
scanf("%d", &n);
if (n == -1) return 0;
a[1] = cc = 1;
fi[1] = 1;
if (n > 1) {
printf("Q %d", n / 2);
for (i = 2; i <= n; i += 2) printf(" %d %d", i - 1, i);
puts("");
fflush(stdout);
scanf("%s", s);
if (s[0] == '-') return 0;
if (n > 2) {
printf("Q %d", (n - 1) / 2);
for (i = 3; i <= n; i += 2) printf(" %d %d", i - 1, i);
puts("");
fflush(stdout);
scanf("%s", t);
if (t[0] == '-') return 0;
}
for (js = jt = 0, i = 2; i <= n; i++)
if ((i & 1) == 0) {
if (s[js] == '0') {
a[i] = ++cc;
fi[cc] = i;
} else
a[i] = a[i - 1];
js++;
} else {
if (t[jt] == '0') {
a[i] = ++cc;
fi[cc] = i;
} else
a[i] = a[i - 1];
jt++;
}
}
c[1] = 1;
c[2] = 2;
if (cc > 2) {
printf("Q %d", cc / 4 + (cc + 1) / 4);
for (i = 3; i <= cc; i += 4) {
printf(" %d %d", fi[i - 2], fi[i]);
if (i + 1 <= cc) printf(" %d %d", fi[i - 1], fi[i + 1]);
}
puts("");
fflush(stdout);
scanf("%s", s);
if (s[0] == '-') return 0;
if (cc > 4) {
printf("Q %d", (cc - 1) / 4 + (cc - 2) / 4);
for (i = 5; i <= cc; i += 4) {
printf(" %d %d", fi[i - 2], fi[i]);
if (i + 1 <= cc) printf(" %d %d", fi[i - 1], fi[i + 1]);
}
puts("");
fflush(stdout);
scanf("%s", t);
if (t[0] == '-') return 0;
}
for (jt = js = 0, i = 3; i <= cc; i++)
if (i % 4 == 0 || i % 4 == 3) {
if (s[js] == '1')
c[i] = c[i - 2];
else
c[i] = 1 + 2 + 3 - c[i - 2] - c[i - 1];
js++;
} else {
if (t[jt] == '1')
c[i] = c[i - 2];
else
c[i] = 1 + 2 + 3 - c[i - 2] - c[i - 1];
jt++;
}
}
for (i = 1; i <= 3; i++) cnt[i] = 0;
for (i = 1; i <= n; i++) cnt[c[a[i]]]++;
printf("A %d %d %d\n", cnt[1], cnt[2], cnt[3]);
for (i = 1; i <= n; i++)
if (c[a[i]] == 1) printf("%d ", i);
puts("");
for (i = 1; i <= n; i++)
if (c[a[i]] == 2) printf("%d ", i);
puts("");
for (i = 1; i <= n; i++)
if (c[a[i]] == 3) printf("%d ", i);
puts("");
fflush(stdout);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, ar[100005];
vector<int> A;
template <typename T>
inline void SI(T &n) {
char c = getchar();
n = 0;
for (; (c > 47 && c < 58); c = getchar()) n = 10 * n + c - 48;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
SI(n);
for (int i = 0; i < n; i++) {
SI(ar[i]);
if (!i || ar[i] > A.back())
A.push_back(ar[i]);
else if (ar[i] < A[0])
A[0] = ar[i];
else
A[lower_bound(A.begin(), A.end(), ar[i]) - A.begin()] = ar[i];
}
cout << A.size();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
string s;
vector<long long> v;
vector<long long> h;
long long cnt[26];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> k;
cin >> s;
for (long long(i) = (0); (i) < (26); (i)++) cnt[i] = 0;
for (long long(i) = (0); (i) < (((long long)s.size())); (i)++)
cnt[s[i] - 'A']++;
v.clear();
for (long long(i) = (0); (i) < (26); (i)++)
if (cnt[i]) v.push_back(cnt[i]);
sort((v).begin(), (v).end());
reverse((v).begin(), (v).end());
long long u = 0;
h.clear();
while (k) {
if (k >= v[u]) {
h.push_back(v[u]);
k -= v[u];
} else {
h.push_back(k);
k = 0;
}
u++;
}
long long ans = 0;
for (long long(i) = (0); (i) < (((long long)h.size())); (i)++)
ans += h[i] * h[i];
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string A, B;
int ans;
int main() {
cin >> A >> B;
ans = ((int)(B).size());
for (int i = -((int)(B).size()); i < ((int)(A).size()); ++i) {
int dif = 0;
for (int j = 0; j < ((int)(B).size()); ++j) {
if (i + j >= 0 && i + j < ((int)(A).size())) {
if (A[i + j] != B[j]) dif++;
} else
dif++;
}
ans = min(ans, dif);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 100;
vector<pair<int, int> > s;
vector<int> ans[200005];
bool flag[200005] = {0};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a;
s.push_back(make_pair(a, i));
}
sort(s.begin(), s.end());
int now = 0;
int the_end = 0;
for (int i = s.size() - 1; i >= 0; --i) {
ans[now].push_back(2 * s[i].second);
if (s[i].first == 1) {
flag[2 * s[i].second] = 1;
the_end = max(the_end, now);
++now;
continue;
}
ans[now + s[i].first].push_back(2 * s[i].second - 1);
if (ans[now + s[i].first].size() == 1)
the_end = max(now + s[i].first, the_end);
++now;
}
for (int i = 0; i <= the_end; ++i) {
if (i != the_end) cout << ans[i][0] << " " << ans[i + 1][0] << endl;
if (flag[ans[i][0]]) {
if (ans[i][0] & 1)
cout << ans[i][0] << " " << ans[i][0] + 1 << endl;
else
cout << ans[i][0] << " " << ans[i][0] - 1 << endl;
}
for (int j = 1; j < ans[i].size(); ++j) {
if (ans[i][j] & 1)
cout << ans[i][j] << " " << ans[i - 1][0] << endl;
else if (i == the_end)
cout << ans[i][j] << " " << ans[i][0] << endl;
else
cout << ans[i][j] << " " << ans[i + 1][0] << endl;
if (flag[ans[i][j]]) {
if (ans[i][j] & 1)
cout << ans[i][j] << " " << ans[i][j] + 1 << endl;
else
cout << ans[i][j] << " " << ans[i][j] - 1 << endl;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long res = m - n;
if (res == 0) {
cout << 1 << endl;
} else {
long long ans = min(k - 1, n - k) + 1;
long long len = 2 * ans - 1;
long long need = ans * ans;
if (need > res) {
ans = int(sqrt(res));
} else if (need < res) {
while (need < res) {
ans++;
if (len < n) {
len++;
} else {
long long t = (res - need) / n;
ans += t;
need += (t + 1) * n;
break;
}
need += len;
}
if (need > res) {
ans--;
}
}
cout << ans + 1 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<string> v(n);
long long ans = 0;
for (long long i = 0; i < n; i++) cin >> v[i];
for (long long C = 0; C < 5; C++) {
char c = C + 'a';
vector<long long> freq(n, 0);
for (long long i = 0; i < n; i++) {
for (char x : v[i]) {
if (x == c)
freq[i]++;
else
freq[i]--;
}
}
sort(freq.rbegin(), freq.rend());
long long sum = 0;
for (long long i = 0; i < n; i++) {
sum += freq[i];
if (sum <= 0) {
ans = max(ans, i);
break;
}
}
if (sum > 0) ans = max(ans, n);
}
cout << ans << endl;
}
int32_t main() {
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
int queries[N];
int l[N];
int r[N];
long long v[N];
long long st[4 * N];
int qt[4 * N];
int lazy1[4 * N];
long long arr[N];
long long lazy[4 * N];
int n, m, k;
void build2(int p = 1, int l = 1, int r = n) {
if (l == r) {
st[p] = arr[l];
return;
}
int mid = (l + r) >> 1;
build2(p << 1, l, mid);
build2(p << 1 | 1, mid + 1, r);
st[p] = st[p << 1] + st[p << 1 | 1];
}
void push1(int p, int l, int r) {
if (lazy1[p]) {
qt[p] += lazy1[p] * (r - l + 1);
if (r != l) {
lazy1[p << 1] += lazy1[p];
lazy1[p << 1 | 1] += lazy1[p];
}
lazy1[p] = 0;
}
}
void push(int p, int l, int r) {
if (lazy[p]) {
st[p] += lazy[p] * (r - l + 1);
if (r != l) {
lazy[p << 1] += lazy[p];
lazy[p << 1 | 1] += lazy[p];
}
lazy[p] = 0;
}
}
void update1(int i, int j, int p = 1, int l = 1, int r = m) {
push1(p, l, r);
if (i > r || l > j) {
return;
}
if (i <= l && r <= j) {
lazy1[p] += 1;
push1(p, l, r);
return;
}
int mid = (l + r) >> 1;
update1(i, j, p << 1, l, mid);
update1(i, j, p << 1 | 1, mid + 1, r);
qt[p] = qt[p << 1] + qt[p << 1 | 1];
}
void update(int i, int j, long long val, int p = 1, int l = 1, int r = n) {
push(p, l, r);
if (i > r || l > j) {
return;
}
if (i <= l && r <= j) {
lazy[p] += val;
push(p, l, r);
return;
}
int mid = (l + r) >> 1;
update(i, j, val, p << 1, l, mid);
update(i, j, val, p << 1 | 1, mid + 1, r);
st[p] = st[p << 1] + st[p << 1 | 1];
}
long long query1(int i, int j, int p = 1, int l = 1, int r = m) {
push1(p, l, r);
if (i > r || l > j) {
return 0;
}
if (i <= l && r <= j) {
return qt[p];
}
int mid = (l + r) >> 1;
return query1(i, j, p << 1, l, mid) + query1(i, j, p << 1 | 1, mid + 1, r);
}
long long query(int i, int j, int p = 1, int l = 1, int r = n) {
push(p, l, r);
if (i > r || l > j) {
return 0;
}
if (i <= l && r <= j) {
return st[p];
}
int mid = (l + r) >> 1;
return query(i, j, p << 1, l, mid) + query(i, j, p << 1 | 1, mid + 1, r);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
build2();
for (int i = 1; i <= m; ++i) {
cin >> l[i] >> r[i] >> v[i];
}
for (int i = 1; i <= k; ++i) {
int l, r;
cin >> l >> r;
update1(l, r);
}
for (int i = 1; i <= m; ++i) {
update(l[i], r[i], v[i] * query1(i, i));
}
for (int i = 1; i <= n; ++i) {
cout << query(i, i) << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, ans[105];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> a >> b;
if (a + b == 0) {
for (int i = n; i >= 1; --i) printf("%d ", i);
puts("");
return 0;
}
int ind = 0;
if (b > 0) {
int sum = 0;
ind = 2;
ans[0] = 1;
ans[1] = 2;
sum = 4;
b--;
while (b > 0) {
ans[ind] = sum + 1;
sum += ans[ind++];
--b;
}
while (a > 0) {
ans[ind] = ans[ind - 1] + 1;
ind++;
--a;
}
while (ind < n) {
ans[ind] = ans[ind - 1];
ind++;
}
} else {
ind = 2;
ans[0] = 1;
ans[1] = 1;
while (a > 0) {
ans[ind] = ans[ind - 1] + 1;
ind++;
--a;
}
while (ind < n) {
ans[ind] = ans[ind - 1];
ind++;
}
}
if (b != 0 || a != 0 || ind != n) return puts("-1");
for (int i = 0; i < n; ++i) printf("%d ", ans[i]);
puts("");
}
| 4 |
#include <bits/stdc++.h>
using std::max;
using std::min;
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
std::mt19937 rnd(std::chrono::steady_clock::now().time_since_epoch().count());
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
inline _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
inline void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
inline void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
inline void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (!isdigit(ch)) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
f && (x = -x);
}
template <typename _Tp, typename... Args>
inline void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
inline int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 52;
struct mat {
double a[N][N];
mat() { memset(a, 0, sizeof(a)); }
mat operator*(const mat &o) const {
mat c;
for (int i = 1; i < N; ++i)
for (int k = 1; k < N; ++k)
for (int j = 1; j < N; ++j) c.a[i][j] += a[i][k] * o.a[k][j];
return c;
}
} M, orig;
double a[N][N], b[N][N], f[N][N], A[N][N], B[N][N];
mat ksm(mat a, int b) {
mat res;
for (int i = 1; i < N; ++i) res.a[i][i] = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a, b >>= 1;
}
return res;
}
int main() {
int n, _p;
read(n, _p);
double p = _p / 1e9;
for (int i = 1; i <= 50; ++i) {
a[i][1] = p, a[i][2] = 1 - p + (i > 1 ? p * p : 0), b[i][1] = 0,
b[i][2] = 1 - p;
for (int j = 3; j <= 50; ++j)
a[i][j] = a[i][j - 1] * a[i - 1][j - 1],
b[i][j] = b[i][j - 1] * a[i - 1][j - 1];
}
for (int i = 1; i <= 50; ++i)
for (int j = 1; j <= 50; ++j)
A[i][j] = a[i][j] * (1.0 - a[i - 1][j]),
B[i][j] = b[i][j] * (1.0 - a[i - 1][j]);
f[1][1] = 1, f[1][2] = 2;
for (int i = 2; i <= 50; ++i) {
for (int k = 2; k <= 50; ++k) f[i][1] += f[i - 1][k] * B[i - 1][k];
f[i][1] = f[i][1] / std::accumulate(B[i - 1] + 2, B[i - 1] + 51, 0.0) + 1.0;
for (int j = 2; j <= 50; ++j) {
for (int k = 1; k < j; ++k) f[i][j] += f[i - 1][k] * A[i - 1][k];
f[i][j] = f[i][j] / std::accumulate(A[i - 1] + 1, A[i - 1] + j, 0.0) + j;
}
}
if (n <= 50) {
double ans = 0;
for (int i = 1; i <= 50; ++i) ans += f[n][i] * A[n][i];
printf("%.12lf\n", ans);
} else {
double sum = A[50][1];
for (int i = 2; i <= 50; ++i) {
for (int j = 1; j < i; ++j) M.a[j][i] = A[50][j] / sum;
sum += A[50][i];
}
sum = std::accumulate(B[50] + 2, B[50] + 51, 0.0);
for (int i = 2; i <= 50; ++i) M.a[i][1] = B[50][i] / sum;
for (int i = 1; i <= 50; ++i) M.a[51][i] = i, orig.a[1][i] = f[50][i];
orig.a[1][51] = 1, M.a[51][51] = 1;
M = orig * ksm(M, n - 50);
double ans = 0;
for (int i = 1; i <= 50; ++i) ans += M.a[1][i] * A[50][i];
printf("%.12lf\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> items;
bool check(int counter, int i, int j) {
int sizeI = items[i].size();
for (int counter2 = 0; counter2 < sizeI; counter2++) {
if (items[i][counter2] == j) return true;
}
return false;
}
int main() {
int N, M;
cin >> N >> M;
int prices[N + 1];
for (int counter = 1; counter <= N; counter++) {
cin >> prices[counter];
}
for (int counter = 0; counter < N + 2; counter++) {
vector<int> emptyV;
items.push_back(emptyV);
}
for (int counter = 0; counter < M; counter++) {
int x, y;
cin >> x >> y;
items[x].push_back(y);
items[y].push_back(x);
}
int minP = INT_MAX;
bool found = false;
for (int counter = 1; counter <= N; counter++) {
int dVsize = items[counter].size();
if (dVsize >= 2) {
for (int i = 0; i < dVsize; i++) {
for (int j = i + 1; j < dVsize; j++) {
int sum = prices[counter] + prices[(int)items[counter][j]] +
prices[(int)items[counter][i]];
if (sum < minP) {
if (check(counter, items[counter][i], items[counter][j])) {
found = true;
minP = sum;
}
}
}
}
}
}
if (found) {
cout << minP << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
const int N = 1e3 + 10;
double EPS = 1e-12;
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(double c) const { return PT(x * c, y * c); }
PT operator/(double c) const { return PT(x / c, y / c); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
ostream &operator<<(ostream &os, const PT &p) {
os << "(" << p.x << "," << p.y << ")";
}
PT ProjectPointSegment(PT a, PT b, PT c) {
double r = dot(b - a, b - a);
if (fabs(r) < EPS) return a;
r = dot(c - a, b - a) / r;
if (r < 0) return a;
if (r > 1) return b;
return a + (b - a) * r;
}
double DistancePointSegment(PT a, PT b, PT c) {
return (sqrt(dist2(c, ProjectPointSegment(a, b, c)))) / 2;
}
double x[N], y[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
cout << setprecision(12);
cout << fixed;
for (int i = 1; i <= n; ++i) cin >> x[i] >> y[i];
double ans = 1e17;
for (int i = 1; i <= n; ++i) {
int frst = i;
int scnd = ((i + 1) > n ? i + 1 - n : i + 1);
int thrd = ((i + 2) > n ? i + 2 - n : i + 2);
ans = min(ans,
DistancePointSegment(PT(x[frst], y[frst]), PT(x[thrd], y[thrd]),
PT(x[scnd], y[scnd])));
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
set<string> words;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
words.insert(s);
}
int common = 0;
for (int i = 0; i < m; i++) {
string s;
cin >> s;
common += words.count(s);
}
int player = 0;
n -= common;
m -= common;
while (common > 0) {
common--;
player = (player + 1) % 2;
}
if (n > m)
player = 0;
else if (m > n)
player = 1;
else
player = (player + 1) % 2;
(player) ? cout << "NO" : cout << "YES";
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define in_txt freopen("input.txt", "r", stdin)
#define out_txt freopen("output.txt", "w", stdout)
#define FastRead ios_base::sync_with_stdio(false);cin.tie(NULL);
#define pi acos(-1)
#define ef emplace_front
#define eb emplace_back
#define pf push_front
#define pb push_back
#define ppf pop_front
#define ppb pop_back
#define FI first
#define SE second
#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))
#define mem(a,b) memset(a,b,sizeof(a))
#define for0(i, n) for(int i=0; i<n; i++)
#define for1(i, n) for(int i=1; i<=n; i++)
#define fr(i,start, till) for(int i=start; i<=till; i++)
#define cin0(n, ara) for(int i=0; i<n; i++) {cin>>ara[i];}
#define cin1(n, ara) for(int i=1; i<=n; i++) {cin>>ara[i];}
#define si(n) scanf("%d", &n)
#define sii(n, m) scanf("%d %d", &n, &m)
#define siii(n, m, k) scanf("%d %d %d", &n, &m, &k)
#define siiii(n, m, k, o) scanf("%d %d %d %d", &n, &m, &k, &o)
#define sl(n) scanf("%lld", &n)
#define sll(n, m) scanf("%lld %lld", &n, &m)
#define slll(n, m, k) scanf("%lld %lld %lld", &n, &m, &k)
#define sllll(n, m, k, o) scanf("%lld %lld %lld %lld", &n, &m, &k, &o)
#define sd(n) scanf("%lf", &n)
#define sdd(n, m) scanf("%lf %lf", &n, &m)
#define sddd(n, m, k) scanf("%lf %lf %lf", &n, &m, &k)
#define sdddd(n, m, k, o) scanf("%lf %lf %lf %lf", &n, &m, &k, &o)
#define scs(s) scanf("%s",s)
#define scss(s, s1) scanf("%s %s",s, s1)
#define scsp(s) scanf(" %[^\n]",s)
const int Max = 1e5+5;
ll a[Max];
set<ll> st;
void cal(int l, int r)
{
ll sum=0;
fr(i,l,r)
sum+=a[i];
st.emplace(sum);
ll mid= (a[l]+a[r])/2;
int idx = upper_bound(a+1, a+r+1, mid) - (a+1);
if(idx>=r || idx<l)
return;
cal(l, idx);
cal(idx+1, r);
}
int main()
{
ll T,n,q,sum;
sl(T);
while(T--)
{
sll(n,q);
for1(i,n)
sl(a[i]);
sort(a+1, a+n+1);
cal(1,n);
while(q--)
{
sl(sum);
if(st.count(sum))
printf("Yes\n");
else
printf("No\n");
}
st.clear();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, l, r;
cin >> n >> l >> r;
long long po[25], su[25];
po[0] = 1;
su[0] = 0;
for (long long int i = 1; i < 25; i++) {
po[i] = po[i - 1] * 2;
su[i] = su[i - 1] + po[i];
}
long long ans1 = n - (l - 1) + su[l - 1];
long long ans2 = 1 + su[r - 1] + po[r - 1] * (n - r);
cout << ans1 << " " << ans2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int Aqua_Fortis, Aqua_Regia, Amalgama, Minium, Vitriol, Philosopher_stone;
int main() {
cin >> Aqua_Fortis >> Aqua_Regia >> Amalgama >> Minium >> Vitriol;
while ((Aqua_Fortis >= 1) && (Aqua_Regia >= 1) && (Amalgama >= 2) &&
(Minium >= 7) && (Vitriol >= 4)) {
Aqua_Fortis -= 1;
Aqua_Regia -= 1;
Amalgama -= 2;
Minium -= 7;
Vitriol -= 4;
Philosopher_stone++;
}
cout << Philosopher_stone;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 5;
set<std::pair<int, int> > st;
set<std::pair<int, int> >::iterator it;
int n, m, x[M], y[M];
char str[2];
int main() {
scanf("%d %d", &n, &m);
st.insert(make_pair(0, 0));
st.insert(make_pair(n + 1, m + 1));
for (int i = 1; i <= m; i++) {
scanf("%d%d%s", x + i, y + i, str);
bool ok = *str == 'U';
if (ok)
it = st.lower_bound(make_pair(x[i], 0));
else
it = st.upper_bound(make_pair(x[i], m + 1)), it--;
if (x[i] == it->first) {
puts("0");
continue;
}
st.insert(make_pair(x[i], i));
int j = it->second;
if (ok) {
printf("%d\n", y[i] - y[j]);
y[i] = y[j];
} else {
printf("%d\n", x[i] - x[j]);
x[i] = x[j];
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void input(vector<long long>& v, long n) {
for (long long i = 0; i < n; i++) {
long long in;
cin >> in;
v.push_back(in);
}
}
void output(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
}
long long max_of_three(long long a, long long b, long long c) {
if (a >= b && a >= c)
return a;
else if (b >= a && b >= c)
return b;
else
return c;
}
long long max_of_4(long long a, long long b, long long c, long long d) {
if (a >= b && a >= c && a >= d)
return a;
else if (b >= a && b >= c && b >= d)
return b;
else if (c >= a && c >= d && c >= b)
return c;
else
return d;
}
map<long long, long long> frequency(vector<long long> v) {
map<long long, long long> m;
for (long long i = 0; i < v.size(); i++) {
if (m.find(v[i]) != m.end())
m[v[i]]++;
else {
m.insert({v[i], 1});
}
}
return m;
}
long long max_occuring_int(std::map<long long, long long> m) {
long long max_x = 0;
long long i = 0, n = m.size();
std::map<long long, long long>::iterator it = m.begin();
for (i = 0; i < n; i++) {
if (it->second > max_x) max_x = it->second;
it++;
}
return max_x;
}
vector<long long> give_unique_in_vector(vector<long long> v) {
sort((v).begin(), (v).end());
auto it = unique((v).begin(), (v).end());
v.resize(std::distance(v.begin(), it));
vector<long long> x = v;
return x;
}
bool isVowel(char c) {
return (c == 'a' | c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y' ||
c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U' || c == 'Y');
}
string removeWord(string str, string word) {
if (str.find(word) != string::npos) {
size_t p = -1;
string tempWord = word + " ";
while ((p = str.find(word)) != string::npos)
str.replace(p, tempWord.length(), "");
tempWord = " " + word;
while ((p = str.find(word)) != string::npos)
str.replace(p, tempWord.length(), "");
}
return str;
}
long long calc(long long i, long long j, long long n) {
return (i + 1 - 1) * n + j + 1;
}
bool compare_descending(long long a, long long b) { return a > b; }
void solve() {
long long n;
cin >> n;
vector<long long> v;
input(v, n - 1);
long long c = n - 2;
vector<long long> ans;
ans.push_back(n);
if (c == 0) {
ans.push_back(v[0]);
} else {
while (c > 0) {
ans.push_back(v[c]);
c = v[c] - 2;
if (c == 0) {
ans.push_back(v[0]);
break;
}
}
}
reverse((ans).begin(), (ans).end());
output(ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
template <class T>
inline T fast(T a, T b, T mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <class T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return a;
}
const long long INF = 1e9 + 7;
const long long mod = 998244353;
const long long BIG_INF = 1e18 + 7;
const long long T = 1 << 20;
const long double inf = 1e18;
const long double eps = 1e-12;
long long n, m, q;
vector<vector<long long>> operator*(vector<vector<long long>> a,
vector<vector<long long>> b) {
vector<vector<long long>> ret(n, vector<long long>(n, BIG_INF));
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++)
for (int k = 0; k < (n); k++)
ret[i][j] = min(ret[i][j], a[i][k] + b[k][j]);
return ret;
}
vector<vector<long long>> id(int x) {
vector<vector<long long>> ret(x, vector<long long>(x, BIG_INF));
for (int i = 0; i < (x); i++) ret[i][i] = 0;
return ret;
}
vector<vector<long long>> operator^(vector<vector<long long>> a,
long long pot) {
vector<vector<long long>> ret = id((int)(a).size());
while (pot) {
if (pot & 1) ret = ret * a;
a = a * a;
pot /= 2;
}
return ret;
}
long long skok[10];
int cnt;
int mapa[300], mapa_rev[300];
vector<pair<long long, long long>> spec;
int X, K, N, Q;
void wypisz(vector<vector<long long>> xd) {
for (auto &u : xd) {
for (auto &v : u) {
cout << (v != BIG_INF ? v : -1) << ' ';
}
cout << endl;
}
}
int special(long long poz) {
auto x = lower_bound((spec).begin(), (spec).end(), make_pair(poz, -INF));
if (x != spec.end() and x->first == poz) return x->second;
return 0;
}
vector<vector<long long>> macierz_przejscia;
void big_jump(vector<long long> &dp, int &poz, int kroki) {
vector<vector<long long>> pom = macierz_przejscia ^ kroki;
vector<vector<long long>> sjema(n, vector<long long>(n, BIG_INF));
sjema[0] = dp;
sjema = sjema * pom;
dp = sjema[0];
poz = poz + kroki;
}
void jump(vector<long long> &dp, int &poz) {
vector<long long> nowe((int)(dp).size(), BIG_INF);
for (int i = 0; i < cnt; i++) {
int maska = mapa_rev[i];
if (maska & 1) {
for (int j = 1; j <= K; j++) {
int bit = (1 << j);
if (!(maska & bit)) {
int new_poz = poz + j;
int nowa_maska = (maska >> 1) + (bit >> 1);
int id = mapa[nowa_maska];
nowe[id] = min(nowe[id], dp[i] + skok[j] + special(new_poz));
}
}
} else {
int nowa_maska = (maska >> 1);
int id = mapa[nowa_maska];
nowe[id] = min(nowe[id], dp[i]);
}
}
dp = nowe;
poz++;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> X >> K >> N >> Q;
spec.resize(Q);
for (int i = 1; i <= K; i++) cin >> skok[i];
for (int i = 0; i < (1 << K); i++) {
if (__builtin_popcount(i) == X) {
mapa[i] = cnt;
mapa_rev[cnt] = i;
cnt++;
}
}
n = cnt;
macierz_przejscia =
vector<vector<long long>>(n, vector<long long>(n, BIG_INF));
for (int i = 0; i < n; i++) {
int maska = mapa_rev[i];
if (maska & 1) {
for (int j = 1; j <= K; j++) {
int bit = (1 << j);
if (!(maska & bit)) {
int nowa_maska = (maska >> 1) + (bit >> 1);
int id = mapa[nowa_maska];
macierz_przejscia[i][id] = skok[j];
}
}
} else {
int nowa_maska = (maska >> 1);
int id = mapa[nowa_maska];
macierz_przejscia[i][id] = 0;
}
}
vector<long long> dp(n);
fill((dp).begin(), (dp).end(), BIG_INF);
dp[0] = 0;
for (int i = 0; i < (Q); i++) cin >> spec[i].first >> spec[i].second;
spec.push_back({INF, -1337});
sort((spec).begin(), (spec).end());
int poz = 1, nast = 0;
while (poz < N - X + 1) {
if (spec[nast].first - poz > K) {
int ile = min(spec[nast].first - poz - K, (long long)N - X + 1 - poz);
big_jump(dp, poz, ile);
} else {
int xd = spec[nast].first - poz;
for (int j = 0; j < (xd); j++) {
jump(dp, poz);
if ((long long)N - X + 1 == poz) {
break;
}
}
nast++;
}
}
cout << dp[0] << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count() *
((uint64_t) new char | 1));
long long N, K;
bool query(long long L, long long R) {
cout << L << ' ' << R << endl;
string answer;
cin >> answer;
if (answer == "Bad") exit(0);
if (L == R && answer == "Yes") exit(0);
return answer == "Yes";
}
int main() {
cin >> N >> K;
long long low = 1, high = N;
while (true) {
bool go_for_it = high - low <= 5 * K + 1;
if (go_for_it) {
long long location = uniform_int_distribution<long long>(low, high)(rng);
query(location, location);
} else {
long long mid = (low + high) / 2;
if (query(low, mid))
high = mid;
else
low = mid + 1;
}
low = max(low - K, 1LL);
high = min(high + K, N);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > V[2020];
string encode[] = {"1110111", "0010010", "1011101", "1011011", "0111010",
"1101011", "1101111", "1010010", "1111111", "1111011"};
bool dp[2020][2020];
pair<int, int> from[2020][2020];
int main() {
int N, K;
scanf("%d%d", &N, &K);
for (int i = 0; i < N; ++i) {
char buf[255];
scanf("%s", buf);
string s = buf;
for (int d = 0; d <= 9; ++d) {
bool flag = true;
int cnt = 0;
for (int j = 0; j < 7 && flag; ++j) {
if (s[j] == encode[d][j])
continue;
else if (s[j] == '1')
flag = false;
else
++cnt;
}
if (flag) V[i].emplace_back(d, cnt);
}
sort(V[i].rbegin(), V[i].rend());
}
dp[N][K] = true;
for (int i = N - 1; i >= 0; --i)
for (int j = 0; j <= K; ++j)
for (auto [n, d] : V[i]) {
if (j + d <= K && dp[i + 1][j + d]) {
dp[i][j] = true;
from[i][j] = make_pair(n, d);
break;
}
}
if (!dp[0][0])
puts("-1");
else {
int curK = 0;
for (int i = 0; i < N; ++i) {
auto [n, d] = from[i][curK];
printf("%d", n);
curK += d;
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
string s;
cin >> s;
int n = s.size();
int h = ceil(1.0 * n / 20), l = ceil(1.0 * n / ceil(1.0 * n / 20));
cout << h << " " << l << "\n";
int cnt = 0;
for (int i = 0; i < h; i++) {
if (n % h == 0) {
for (int j = 0; j < l; j++) cout << s[cnt++];
} else {
for (int j = 0; j < l - 1; j++) cout << s[cnt++];
if (i < h - n % h)
cout << "*";
else
cout << s[cnt++];
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
namespace std {
template <class S, class T>
struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T>
struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v) h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
for (int i = 0; i < (int)v.size(); i++)
os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v) os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v) os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int dp[1 << 16][16], way[1 << 16][16];
vector<int> tsp(vector<vector<int>> d) {
int n = d.size();
for (int i = 0; i < (int)1 << n; i++)
for (int j = 0; j < (int)n; j++) dp[i][j] = inf;
for (int i = 0; i < (int)n; i++) dp[0][i] = 0;
for (int i = 0; i < (int)1 << n; i++)
for (int j = 0; j < (int)n; j++)
if (dp[i][j] < inf)
for (int k = 0; k < (int)n; k++)
if (j != k && !(i & 1 << k)) {
if (dp[i | 1 << k][k] <= dp[i][j] + d[j][k]) continue;
dp[i | 1 << k][k] = dp[i][j] + d[j][k];
way[i | 1 << k][k] = j;
}
int ans = inf, ansi, mask = (1 << n) - 1;
for (int i = 0; i < (int)n; i++)
if (ans > dp[mask][i]) ans = dp[mask][ansi = i];
vector<int> res;
for (int i = 0; i < (int)n; i++) {
res.push_back(ansi);
if (i == n - 1) break;
int p = way[mask][ansi];
mask ^= 1 << ansi;
ansi = p;
}
reverse((res).begin(), (res).end());
return res;
}
int dist(const vector<vector<int>> &v, int x, int y) {
double res = 0;
for (int j = 0; j < (int)5; j++) {
double fac = pow(3.0, -j);
for (int i = 0; i < (int)v[0].size(); i++)
res += (v[x - j][i] - v[y][i]) * (v[x - j][i] - v[y][i]) * fac;
for (int i = 0; i < (int)v[0].size(); i++)
res += (v[x][i] - v[y + j][i]) * (v[x][i] - v[y + j][i]) * fac;
}
return (int)(res / 1000);
}
void filter(vector<vector<int>> &v, int y, int Y) {
const int X = 3;
int w = v[0].size();
vector<vector<int>> u(Y - y, vector<int>(w));
for (int i = y; i < Y; i++)
for (int j = 0; j < (int)w; j++) {
int s = 0, c = 0;
for (int k = i - X; k <= i + X; k++)
if (y <= k && k < Y)
for (int l = j - X; l <= j + X; l++)
if (0 <= l && l < w) {
s += v[k][l], c++;
}
u[i - y][j] = s / c;
}
for (int i = 0; i < (int)Y - y; i++)
for (int j = 0; j < (int)w; j++) v[i + y][j] = u[i][j];
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int q;
cin >> q;
vector<int> res;
for (int it = 0; it < (int)q; it++) {
int h, w, n;
cin >> h >> w >> n;
vector<vector<int>> v(h, vector<int>(w));
for (int i = 0; i < (int)h; i++)
for (int j = 0; j < (int)w; j++) cin >> v[i][j];
for (int i = 0; i < (int)n; i++) filter(v, h / n * i, h / n * (i + 1));
vector<vector<int>> ds(n, vector<int>(n));
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)n; j++)
if (i != j) {
int x = (h / n) * (i + 1) - 1;
int y = (h / n) * j;
ds[i][j] = dist(v, x, y);
}
vector<int> res = tsp(ds);
vector<int> inv(n);
for (int i = 0; i < (int)n; i++) inv[res[i]] = i + 1;
for (int i = 0; i < (int)n; i++)
printf("%d%c", inv[i], i == n - 1 ? '\n' : ' ');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[1234567];
set<int> s;
int pre, ne;
int posl = -1, posr = -1;
int rp[1234567];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int l = 0, r = 0;
int maxm = 0;
s.insert(a[0]);
r = 0;
rp[a[0]] = 0;
for (int i = 1; i < n; i++) {
r++;
pre = s.size();
if (s.find(a[i]) == s.end()) s.insert(a[i]);
ne = s.size();
rp[a[i]] = i;
if (ne <= k) {
if ((r - l + 1) >= maxm) {
maxm = r - l + 1;
posl = l;
posr = r;
}
} else {
l++;
if (rp[a[l - 1]] < l && s.find(a[l - 1]) != s.end()) s.erase(a[l - 1]);
}
}
int sz = s.size();
if (sz == k) {
if ((r - l + 1) >= maxm) {
maxm = r - l + 1;
posl = l;
posr = r;
}
}
printf("%d %d", posl + 1, posr + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[109000], book[109000];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
book[a[i]] = 1;
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (i != 1 && a[i] != a[i - 1])
printf("%d ", a[i - 1]);
else {
while (book[cnt] == 1) cnt++;
printf("%d ", cnt++);
}
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ask1(long long a, long long b) {
cout << "and " << a << " " << b << "\n";
long long n;
cin >> n;
return n;
}
long long ask2(long long a, long long b) {
cout << "or " << a << " " << b << "\n";
long long n;
cin >> n;
return n;
}
int32_t main() {
long long T = 1;
while (T--) {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
long long a12 = ask1(1, 2);
long long o12 = ask2(1, 2);
long long a23 = ask1(2, 3);
long long o23 = ask2(2, 3);
long long a13 = ask1(1, 3);
long long o13 = ask2(1, 3);
long long o123 = o12 | o23;
long long a123 = a12 & a23;
long long a = (o123 - o23 + a12 + a13 - a123);
long long b = o12 - (a - a12);
long long c = o13 - (a - a13);
v[0] = a;
v[1] = b;
v[2] = c;
for (long long i = 3; i < n; i++) {
long long ba = ask1(1, i + 1);
long long bo = ask2(1, i + 1);
v[i] = bo - (a - ba);
}
sort(v.begin(), v.end());
cout << "finish " << v[k - 1] << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2034;
long long n, m, x, y, xx, yy, kol;
char s[N][N];
bool u[N][N];
queue<pair<long long, long long> > q;
int cnt(int y, int x) {
return (s[y - 1][x] == '.') + (s[y + 1][x] == '.') + (s[y][x - 1] == '.') +
(s[y][x + 1] == '.');
}
void fail() {
printf("Not unique\n");
exit(0);
}
int main() {
scanf("%d%d ", &n, &m);
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) s[i][j] = '*';
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%c ", &s[i + 1][j + 1]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '.') {
kol--;
if (cnt(i, j) == 1) q.push(make_pair(i, j));
}
while (!q.empty()) {
y = q.front().first;
x = q.front().second;
q.pop();
if (u[y][x]) continue;
u[y][x] = true;
kol += 2;
if (cnt(y, x) == 0) fail();
if (s[y - 1][x] == '.') {
u[y - 1][x] = true;
s[y][x] = 'v';
s[y - 1][x] = '^';
xx = x;
yy = y - 1;
} else if (s[y + 1][x] == '.') {
u[y + 1][x] = true;
s[y][x] = '^';
s[y + 1][x] = 'v';
xx = x;
yy = y + 1;
} else if (s[y][x + 1] == '.') {
u[y][x + 1] = true;
s[y][x] = '<';
s[y][x + 1] = '>';
xx = x + 1;
yy = y;
} else if (s[y][x - 1] == '.') {
u[y][x - 1] = true;
s[y][x] = '>';
s[y][x - 1] = '<';
xx = x - 1;
yy = y;
} else
fail();
if (s[yy][xx - 1] == '.')
if (cnt(yy, xx - 1) == 1) q.push(make_pair(yy, xx - 1));
if (s[yy][xx + 1] == '.')
if (cnt(yy, xx + 1) == 1) q.push(make_pair(yy, xx + 1));
if (s[yy - 1][xx] == '.')
if (cnt(yy - 1, xx) == 1) q.push(make_pair(yy - 1, xx));
if (s[yy + 1][xx] == '.')
if (cnt(yy + 1, xx) == 1) q.push(make_pair(yy + 1, xx));
}
if (kol < 0) fail();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", s[i][j]);
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class BDominoForYoung {
public:
void solve(std::istream &in, std::ostream &out) {
int n;
in >> n;
long long answer = 0;
int total = 0;
for (int i = 0; i < n; ++i) {
int u;
in >> u;
answer += u / 2;
if (u & 1) {
if (i & 1) {
total++;
if (total <= 0) answer++;
} else {
total--;
if (total >= 0) answer++;
}
}
}
out << answer << endl;
}
};
int main() {
BDominoForYoung solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long b[n];
vector<long long> vc[n + 2];
for (long long i = 0; i < n; i++) {
cin >> b[i];
vc[a[i]].push_back(b[i]);
}
vector<long long> vd;
long long cnt = 0;
long long sum = 0;
for (long long i = 1; i <= k; i++) {
long long siz = vc[i].size();
if (siz >= 1) cnt++;
long long mx = -1;
for (long long j = 0; j < siz; j++) {
if (vc[i][j] > mx) mx = vc[i][j];
}
long long ck = 0;
for (long long j = 0; j < siz; j++) {
if (vc[i][j] == mx && ck == 0) {
ck = 1;
continue;
}
vd.push_back(vc[i][j]);
}
}
sort(vd.begin(), vd.end());
for (long long i = 0; i < vd.size(); i++) {
if (cnt == k) break;
sum += vd[i];
cnt++;
}
cout << sum << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long wsh[4];
long long bsht1[4];
long long bsht2[4];
long long maxminx1[4];
long long maxminy1[4];
long long maxminx2[4];
long long maxminy2[4];
for (long long i = 0; i < 4; i++) {
cin >> wsh[i];
}
maxminx1[0] = wsh[0];
maxminx1[1] = wsh[2];
maxminy1[0] = wsh[1];
maxminy1[1] = wsh[3];
maxminx2[0] = wsh[0];
maxminx2[1] = wsh[2];
maxminy2[0] = wsh[1];
maxminy2[1] = wsh[3];
for (long long i = 0; i < 4; i++) {
cin >> bsht1[i];
}
maxminx1[2] = bsht1[0];
maxminx1[3] = bsht1[2];
maxminy1[2] = bsht1[1];
maxminy1[3] = bsht1[3];
for (long long i = 0; i < 4; i++) {
cin >> bsht2[i];
}
maxminx2[2] = bsht2[0];
maxminx2[3] = bsht2[2];
maxminy2[2] = bsht2[1];
maxminy2[3] = bsht2[3];
long long maxminful[3];
maxminful[0] = wsh[0];
maxminful[1] = bsht1[0];
maxminful[2] = bsht2[0];
long long shper, fullsh, sh, swsh, fullsper, sper1;
swsh = (wsh[2] - wsh[0]) * (wsh[3] - wsh[1]);
if (wsh[2] < bsht1[0] || bsht1[2] < wsh[0]) {
shper = 0;
} else {
fullsh = wsh[2] - wsh[0] + bsht1[2] - bsht1[0];
sh = *max_element(maxminx1, maxminx1 + 4) -
*min_element(maxminx1, maxminx1 + 4);
shper = fullsh - sh;
}
long long fulldl, dlper, dl;
if (wsh[3] < bsht1[1] || bsht1[3] < wsh[1]) {
dlper = 0;
} else {
fulldl = wsh[3] - wsh[1] + bsht1[3] - bsht1[1];
dl = *max_element(maxminy1, maxminy1 + 4) -
*min_element(maxminy1, maxminy1 + 4);
dlper = fulldl - dl;
}
sper1 = shper * dlper;
if (sper1 == swsh) {
cout << "NO";
} else {
long long shper2, fullsh2, sh2, sper2;
if (wsh[2] < bsht2[0] || bsht2[2] < wsh[0]) {
shper2 = 0;
} else {
fullsh2 = wsh[2] - wsh[0] + bsht2[2] - bsht2[0];
sh2 = *max_element(maxminx2, maxminx2 + 4) -
*min_element(maxminx2, maxminx2 + 4);
shper2 = fullsh2 - sh2;
}
long long fulldl2, dlper2, dl2;
if (wsh[3] < bsht2[1] || bsht2[3] < wsh[1]) {
dlper2 = 0;
} else {
fulldl2 = wsh[3] - wsh[1] + bsht2[3] - bsht2[1];
dl2 = *max_element(maxminy2, maxminy2 + 4) -
*min_element(maxminy2, maxminy2 + 4);
dlper2 = fulldl2 - dl2;
}
sper2 = shper2 * dlper2;
if (sper2 == swsh) {
cout << "NO";
} else if ((sper1 < swsh && sper2 == 0) || (sper1 == 0 && sper2 < swsh)) {
cout << "YES";
} else {
fullsper = sper1 + sper2;
if ((bsht1[2] <= bsht2[0] || bsht2[2] <= bsht1[0]) ||
(bsht1[3] <= bsht2[1] || bsht2[3] <= bsht1[1])) {
if (fullsper < swsh) {
cout << "YES";
} else if (fullsper == swsh) {
cout << "NO";
}
} else {
long long shper3, dlper3, sper3;
if ((bsht1[2] < wsh[0] && bsht2[2] < wsh[0]) ||
(wsh[2] < bsht2[0] && wsh[2] < bsht1[0])) {
shper3 = 0;
sper3 = 0;
fullsper = fullsper - sper3;
} else {
long long a, b, c, d;
a = *max_element(maxminful, maxminful + 3);
maxminful[0] = wsh[2];
maxminful[1] = bsht1[2];
maxminful[2] = bsht2[2];
b = *min_element(maxminful, maxminful + 3);
shper3 = b - a;
maxminful[0] = wsh[1];
maxminful[1] = bsht1[1];
maxminful[2] = bsht2[1];
c = *max_element(maxminful, maxminful + 3);
maxminful[0] = wsh[3];
maxminful[1] = bsht1[3];
maxminful[2] = bsht2[3];
d = *min_element(maxminful, maxminful + 3);
dlper3 = d - c;
sper3 = dlper3 * shper3;
fullsper = fullsper - sper3;
}
if (fullsper < swsh) {
cout << "YES";
} else if (fullsper == swsh) {
cout << "NO";
}
}
}
}
}
| 4 |
#include <bits/stdc++.h>
void solve(int a) {
while (a--) {
int h, n, m;
std::cin >> h >> n >> m;
while (h > 19 && n) {
h /= 2;
h += 10;
n--;
}
while (m-- && h) {
h -= 10;
}
if (h > 0)
std::cout << "NO" << std::endl;
else
std::cout << "YES" << std::endl;
}
}
int main() {
int n;
std::cin >> n;
solve(n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
inline int getint() {
int x;
scanf("%d", &x);
return x;
}
inline long long getlng() {
long long x;
scanf("%lld", &x);
return x;
}
int dx4[] = {-1, 0, 1, 0};
int dy4[] = {0, 1, 0, -1};
int dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
const double eps = (double)1e-9;
const int N = 2e5 + 5;
long long arr[N], f[N];
int n;
bool issq(long long x) {
long long s = sqrt(x * 1.0);
return s * s == x;
}
long long need(long long x) {
if (issq(x)) return 0;
long long s = sqrt(x * 1.0);
long long a = s * s;
long long b = (s + 1) * (s + 1);
return min(x - a, b - x);
}
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
int main() {
n = getint();
vector<pair<long long, long long> > vp;
for (int i = 0; i < n; ++i) {
long long x;
scanf("%lld", &x);
vp.push_back(make_pair(x, need(x)));
}
sort((vp).begin(), (vp).end(), cmp);
long long ans = 0;
for (int i = 0; i < (n >> 1); ++i) {
ans += vp[i].second;
}
for (int i = (n >> 1); i < n; ++i) {
if (vp[i].first == 0)
ans += 2;
else if (issq(vp[i].first))
++ans;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int bit[2][2100];
void add(int t, int k, int x) {
k++;
while (k < 2100) {
bit[t][k] += x;
k += k & -k;
}
}
int sum(int t, int k) {
k++;
int res = 0;
while (k) {
res += bit[t][k];
k -= k & -k;
}
return res;
}
long long a[4000], f[4000];
long long po[4000];
long long dp[4000][4000];
int d[4000][4000];
int main() {
int n;
cin >> n;
a[1] = 0;
a[2] = 1;
f[1] = 1;
f[2] = 2;
for (int i = 3; i <= n; i++) {
a[i] = (i - 1) * (a[i - 1] + a[i - 2]) % MOD;
f[i] = i * f[i - 1] % MOD;
}
for (int i = 1; i <= n; i++) {
dp[i][0] = f[i];
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= i; j++) {
dp[i][j] = (dp[i][j - 1] + MOD - dp[i - 1][j - 1]) % MOD;
}
}
po[0] = 1;
for (int i = 1; i <= n; i++) {
po[i] = po[i - 1] * a[n] % MOD;
}
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) scanf("%d", &d[i][j]);
long long ans = 0;
for (int i = 0; i < (n); i++) {
memset(bit, 0, sizeof(bit));
map<int, int> mp;
for (int j = n - 1; j >= 0; j--) {
int c = sum(1, n);
int c1 = sum(0, d[i][j] - 1), c2 = sum(1, d[i][j] - 1);
if (i && d[i - 1][j] < d[i][j] && mp[d[i - 1][j]]) c1--;
if (mp[d[i][j]]) c++;
if (c1) {
(ans += c1 * dp[n - j - 1][c] % MOD * po[n - i - 1]) %= MOD;
}
if (c2) {
(ans += c2 * dp[n - j - 1][c - 1] % MOD * po[n - i - 1]) %= MOD;
}
if (i) {
if (mp[d[i - 1][j]]) {
add(0, d[i - 1][j], -1);
add(1, d[i - 1][j], 1);
}
mp[d[i - 1][j]]++;
}
if (mp[d[i][j]]) {
add(1, d[i][j], 1);
} else
add(0, d[i][j], 1);
mp[d[i][j]]++;
}
}
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void use_cio() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
template <typename... Args>
void dbg(Args... args) {
((cout << args << " "), ...);
cout << "\n";
}
int cnt[1010][1010];
int tot;
long long ans;
int main() {
use_cio();
long long n, m;
cin >> n >> m;
for (int i = (1); i < (m + 1); i++)
for (int j = (1); j < (m + 1); j++) {
if ((i * i + j * j) % m == 0) {
tot++;
cnt[i][j] = 1;
}
}
int d = n / m, r = n % m;
ans = 1LL * d * d * tot;
int tmp1 = 0, tmp2 = 0;
for (int i = (1); i < (m + 1); i++)
for (int j = (1); j < (r + 1); j++) {
tmp1 += cnt[i][j];
if (i <= r) tmp2 += cnt[i][j];
}
ans += 1LL * 2 * d * tmp1 + tmp2;
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace ::std;
const int SUML = 200000 * 31;
const int N = 200000 + 5;
const int L = 30;
const int E = 2;
int n;
int a[N];
int par[N];
bool vis[N];
int sizes[N];
int nodes = 1;
int frec[SUML];
int pats[SUML];
vector<int> C[N];
int trie[SUML][E];
pair<int, int> edges[N];
void insert(int x, int id) {
int pos = 0;
for (int i = L - 1; i >= 0; i--) {
int nxt = (x >> i) & 1;
if (trie[pos][nxt] == 0) {
trie[pos][nxt] = nodes++;
}
frec[pos] += 1;
pos = trie[pos][nxt];
}
frec[pos] += 1;
pats[pos] = id;
}
void erase(int x, int id) {
int pos = 0;
for (int i = L - 1; i >= 0; i--) {
int nxt = (x >> i) & 1;
frec[pos] -= 1;
pos = trie[pos][nxt];
}
frec[pos] -= 1;
pats[pos] = 0;
}
int getMinimizer(int val) {
int pos = 0;
for (int i = L - 1; i >= 0; i--) {
int have = (val >> i) & 1;
if (trie[pos][have] == 0 or frec[trie[pos][have]] == 0) have ^= 1;
pos = trie[pos][have];
}
return pats[pos];
}
int get(int x) { return par[x] == x ? x : par[x] = get(par[x]); }
int join(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return 0;
if (sizes[a] > sizes[b]) swap(a, b);
sizes[b] += sizes[a];
par[a] = b;
return 1;
}
pair<int, int> getBest(int pos) {
for (auto x : C[pos]) {
erase(a[x], x);
}
int best = INT_MAX;
int i1, i2;
for (auto x : C[pos]) {
int y = getMinimizer(a[x]);
int e = (a[x] ^ a[y]);
if (e < best) {
i1 = x;
i2 = y;
best = e;
}
}
for (auto x : C[pos]) {
insert(a[x], x);
}
return make_pair(i1, i2);
}
long long solve() {
for (int i = 1; i <= n; i++) {
par[i] = i;
sizes[i] = 1;
}
long long ans = 0LL;
int nc = n;
int len = 0;
vector<bool> vis(n + 1, false);
vector<int> CCs;
while (nc > 1) {
int cnt = 0;
len = 0;
for (int i = 1; i <= n; i++) {
int x = get(i);
C[x].emplace_back(i);
if (!vis[x]) {
vis[x] = true;
CCs.emplace_back(x);
}
}
for (int x : CCs) {
edges[len++] = getBest(x);
}
for (int i = 0; i < len; i++) {
int x = edges[i].first;
int y = edges[i].second;
if (join(x, y)) {
ans += a[x] ^ a[y];
nc -= 1;
}
}
if (nc == 1) break;
while (!CCs.empty()) {
int x = CCs.back();
CCs.pop_back();
vis[x] = false;
C[x].clear();
}
}
return ans;
}
int main() {
scanf("%d", &n);
vector<int> v;
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
v.emplace_back(x);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 0; i < v.size(); i++) {
a[i + 1] = v[i];
insert(a[i + 1], i + 1);
}
n = v.size();
cout << solve() << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long T;
cin >> T;
while (T--) {
long long n;
cin >> n;
long long m = 2 * n;
long long a[m];
for (long long i = 0; i < m; i++) cin >> a[i];
sort(a, a + m);
cout << a[n] - a[n - 1] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int k = 1;
int colour[5005];
int from[5005];
int seen[5005];
pair<int, int> edges[5005];
vector<pair<int, int> > graph[5005];
bool isAncestor(int curr, int prev) {
if (curr == prev) return true;
if (from[curr] == curr) return false;
return isAncestor(from[curr], prev);
}
void dfs(int root, int prev) {
if (seen[root]) return;
seen[root] = 1;
from[root] = prev;
for (pair<int, int> i : graph[root]) {
if (seen[i.first]) {
if (isAncestor(root, i.first)) {
k = 2;
colour[i.second] = 2;
} else {
from[i.first] = root;
colour[i.second] = 1;
}
} else {
colour[i.second] = 1;
dfs(i.first, root);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
edges[i] = {u, v};
graph[u].push_back({v, i});
}
for (int i = 1; i <= n; i++) from[i] = i;
for (int i = 1; i <= n; i++) {
if (!seen[i]) dfs(i, i);
}
cout << k << '\n';
for (int i = 0; i < m; i++) cout << colour[i] << ' ';
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long sa[300005], sb[300005];
set<long long> s;
int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int main() {
sa[0] = 0, sb[0] = 0;
int n = read();
for (int i = 1; i <= n; i++) {
int a = read();
sa[i] = sa[i - 1] + a;
}
int m = read();
for (int i = 1; i <= m; i++) {
int b = read();
sb[i] = sb[i - 1] + b;
s.insert(sb[i]);
}
if (sa[n] == sb[m]) {
int ans = 0;
for (int i = 1; i <= n; i++) {
if (s.find(sa[i]) != s.end()) {
++ans;
}
}
printf("%d\n", ans);
} else
printf("-1\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T inline sqr(T x) {
return x * x;
}
const long double pi = 3.1415926535897932384626433832795;
const long double eps = 1e-8;
int nxt() {
int x;
scanf("%d", &x);
return x;
}
const int N = 1002;
typedef bitset<N * 2> T;
vector<vector<int> > g, gt;
vector<bool> used;
vector<int> order, comp;
void dfs1(int v) {
used[v] = true;
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to]) dfs1(to);
}
order.push_back(v);
}
void dfs2(int v, int cl) {
comp[v] = cl;
for (size_t i = 0; i < gt[v].size(); ++i) {
int to = gt[v][i];
if (comp[to] == -1) dfs2(to, cl);
}
}
vector<int> sol(int n, const vector<T>& a) {
n *= 2;
g.assign(n, vector<int>());
gt.assign(n, vector<int>());
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(n); ++j)
if (a[i][j]) g[i].push_back(j), gt[j].push_back(i);
order.clear();
used.assign(n, false);
for (int i = 0; i < n; ++i)
if (!used[i]) dfs1(i);
comp.assign(n, -1);
for (int i = 0, j = 0; i < n; ++i) {
int v = order[n - i - 1];
if (comp[v] == -1) dfs2(v, j++);
}
for (int i = 0; i < n; ++i)
if (comp[i] == comp[i ^ 1]) {
return vector<int>();
}
vector<int> ans(n / 2);
for (int i = 0; i < n / 2; i++) {
ans[i] = comp[i * 2] > comp[i * 2 + 1] ? 1 : 0;
}
return ans;
}
vector<T> f(int n, int m) {
vector<T> a(n * 2);
for (int i = 0; i < (int)(m); ++i) {
int u = nxt(), v = nxt();
int x = (abs(u) - 1) * 2 + (u < 0);
int y = (abs(v) - 1) * 2 + (v < 0);
a[x ^ 1][y] = 1;
a[y ^ 1][x] = 1;
}
for (int k = 0; k < (int)(2 * n); ++k)
for (int i = 0; i < (int)(2 * n); ++i)
if (a[i][k]) a[i] |= a[k];
return a;
}
bool check(const vector<int>& a, const vector<T>& b) {
for (int i = 0; i < (int)(2 * a.size()); ++i)
for (int j = 0; j < (int)(2 * a.size()); ++j)
if (a[i / 2] != i % 2 && a[j / 2] == j % 2 && b[i][j]) return false;
return true;
}
vector<int> broad(const vector<T>& a, const vector<int>& vals) {
vector<int> res = vals;
queue<int> q;
int n = vals.size();
for (int i = 0; i < (int)(n); ++i)
if (vals[i] != -1) q.push(i);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < (int)(n * 2); ++i) {
if (a[v * 2 + (res[v] ^ 1)][i] && res[i / 2] == -1) {
res[i / 2] = (i % 2) ^ 1;
q.push(i / 2);
}
}
}
return res;
}
vector<int> extend(const vector<int>& to_extend, const vector<int>& sol) {
vector<int> res = to_extend;
for (int i = 0; i < (int)(sol.size()); ++i)
if (res[i] == -1) res[i] = sol[i];
return res;
}
void print(const vector<int>& sol) {
for (int x : sol) cout << x << " ";
cout << "\n";
exit(0);
}
int main() {
int n = nxt(), m1 = nxt(), m2 = nxt();
vector<T> a = f(n, m1);
vector<T> b = f(n, m2);
if (a == b) {
puts("SIMILAR");
return 0;
}
vector<int> sa = sol(n, a);
if (!sa.empty()) assert(check(sa, a));
vector<int> sb = sol(n, b);
if (!sb.empty()) assert(check(sb, b));
if (sa.empty() != sb.empty()) {
vector<int> x = sa;
if (x.empty()) x = sb;
for (int i = 0; i < (int)(n); ++i) cout << x[i] << " ";
return 0;
}
if (sa.empty()) {
puts("SIMILAR");
return 0;
}
vector<int> dta(n, -1);
for (int i = 0; i < (int)(n); ++i) {
if (a[i * 2][i * 2 + 1]) dta[i] = 0;
if (a[i * 2 + 1][i * 2]) dta[i] = 1;
}
dta = broad(a, dta);
vector<int> dtb(n, -1);
for (int i = 0; i < (int)(n); ++i) {
if (b[i * 2][i * 2 + 1]) dtb[i] = 0;
if (b[i * 2 + 1][i * 2]) dtb[i] = 1;
}
dtb = broad(b, dtb);
for (int i = 0; i < (int)(n * 2); ++i)
for (int j = 0; j < (int)(n * 2); ++j)
if (a[i][j] != b[i][j]) {
for (int di = 0; di < (int)(2); ++di)
for (int dj = 0; dj < (int)(2); ++dj) {
vector<int> vals = dta;
vals[i / 2] = di;
vals[j / 2] = dj;
vector<int> w = broad(a, vals);
for (int i = 0; i < (int)(n); ++i)
if (w[i] == -1) w[i] = sa[i];
if (check(w, a) != check(w, b)) {
for (int i = 0; i < (int)(n); ++i) cout << w[i] << " ";
return 0;
}
vals = dtb;
vals[i / 2] = di;
vals[j / 2] = dj;
w = broad(b, vals);
for (int i = 0; i < (int)(n); ++i)
if (w[i] == -1) w[i] = sb[i];
if (check(w, a) != check(w, b)) {
for (int i = 0; i < (int)(n); ++i) cout << w[i] << " ";
return 0;
}
}
if (clock() > CLOCKS_PER_SEC * 2.8) {
puts("SIMILAR");
return 0;
}
}
puts("SIMILAR");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long INV2 = 500000004;
long long INV6 = 166666668;
long long power(long long a, long long b, long long c) {
long long x = 1, y = a;
while (b > 0) {
if (b & 1) x = (x * y) % c;
y = (y * y) % c;
b /= 2;
}
return x % c;
}
int dx[] = {0, -1, 0, 1};
int dy[] = {-1, 0, 1, 0};
vector<long long> le, ri;
long long solve(long long val) {
long long lo = 0, hi = ri.size();
long long ans = -1;
while (lo < hi) {
long long mid = (lo + hi) / 2;
if (ri[mid] < val) {
ans = ri[mid];
lo = mid + 1;
} else {
hi = mid;
}
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
string s;
cin >> s;
long long num;
for (int i = 0; i < n; ++i) {
scanf("%lld", &num);
if (s[i] == 'L')
le.push_back(num);
else
ri.push_back(num);
}
long long ans = 1e16;
for (int i = 0; i < le.size(); ++i) {
long long ele = le[i];
long long val = solve(ele);
if (val != -1) {
long long dekh = (ele - val) / 2;
ans = min(ans, 1LL * dekh);
}
}
if (ans < 1e16)
printf("%lld\n", ans);
else {
printf("-1\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t;
long long n, a;
scanf("%d", &t);
while (t--) {
scanf("%lld", &n);
a = (long long)pow(n, 0.5);
n = n - a * a;
if (n == 0)
printf("%lld 1\n", a);
else if (n <= a + 1)
printf("%lld %lld\n", n, a + 1);
else
printf("%lld %lld\n", a + 1, 2 * a - n + 2);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b;
bool flag;
};
int main() {
long long a, b, i, j, k, m, t, n, p, q, x, y;
string s;
p = 0;
while (cin >> p >> q) {
a = 1;
b = 1 + q;
while (a < b) cout << a++ << " " << b-- << " ";
if (a == b) cout << a << " ";
for (i = 2 + q; i <= p; i++) cout << i << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
int remainder, mi = 1000000, a, b, s, sub;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
s = n / i;
sub = s - i;
if (sub < mi) {
mi = sub;
a = i;
b = s;
}
}
}
cout << a << " " << b << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct ptime {
int card;
int time;
};
int main() {
string th, ta;
cin >> th >> ta;
int n;
cin >> n;
ptime fh[100], fa[100];
ptime t;
t.card = -1;
t.time = -1;
fill(fh, fh + 100, t);
fill(fa, fa + 100, t);
int ti, pno;
char ha, card;
for (int i = 0; i < n; ++i) {
cin >> ti >> ha >> pno >> card;
if (card == 'y') {
if (ha == 'h') {
if (fh[pno].card == -1) {
fh[pno].card = 1;
} else if (fh[pno].card == 1) {
fh[pno].card = 2;
fh[pno].time = ti;
cout << th << " " << pno << " " << fh[pno].time << endl;
}
} else if (ha == 'a') {
if (fa[pno].card == -1) {
fa[pno].card = 1;
} else if (fa[pno].card == 1) {
fa[pno].card = 2;
fa[pno].time = ti;
cout << ta << " " << pno << " " << fa[pno].time << endl;
}
}
} else if (card == 'r') {
if (ha == 'h') {
if (fh[pno].card != 2) {
fh[pno].card = 2;
fh[pno].time = ti;
cout << th << " " << pno << " " << fh[pno].time << endl;
}
} else if (ha == 'a') {
if (fa[pno].card != 2) {
fa[pno].card = 2;
fa[pno].time = ti;
cout << ta << " " << pno << " " << fa[pno].time << endl;
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const int inf = 0x3f3f3f3f;
const double tiaohe = 0.57721566490153286060651209;
long long oula(long long x) {
long long res = x;
for (register int i = 2; i <= x / i; ++i) {
if (x % i == 0) {
res = res / i * (i - 1);
while (x % i == 0) x /= i;
}
}
if (x > 1) res = res / x * (x - 1);
return res;
}
long long quickmod(long long a, long long n, long long m) {
long long s = 1;
while (n) {
if (n & 1) {
s = s * a % m;
}
a = (a * a) % m;
n = n / 2;
}
return s;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void ex_gcd(long long a, long long b, long long &x, long long &y,
long long &d) {
if (!b) {
d = a, x = 1, y = 0;
} else {
ex_gcd(b, a % b, y, x, d);
y -= x * (a / b);
}
}
long long inv(long long t, long long p) {
long long d, x, y;
ex_gcd(t, p, x, y, d);
return d == 1 ? (x % p + p) % p : -1;
}
bool isPrime(long long x) {
if (x == 2) return true;
if (x % 2 == 0) return false;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
inline int in() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
double eqa = (1 + sqrt(5.0)) / 2.0;
const int N = 1e5 + 5;
struct Suffix_Automata {
int maxlen[N << 1], trans[N << 1][28], link[N << 1], A[N << 1], tmp[N << 1],
num[N << 1], Size, Last;
void init() {
Size = Last = 1;
memset(trans, 0, sizeof trans);
memset(tmp, 0, sizeof tmp);
memset(num, 0, sizeof num);
}
void Qsort() {
for (int i = 1; i <= Size; i++) tmp[maxlen[i]]++;
for (int i = 1; i <= Size; i++) tmp[i] += tmp[i - 1];
for (int i = 1; i <= Size; i++) A[tmp[maxlen[i]]--] = i;
for (int i = Size; i >= 1; i--) num[link[A[i]]] += num[A[i]];
}
inline void Extend(int id) {
int cur = (++Size), p;
num[cur] = 1;
maxlen[cur] = maxlen[Last] + 1;
for (p = Last; p && !trans[p][id]; p = link[p]) trans[p][id] = cur;
if (!p)
link[cur] = 1;
else {
int q = trans[p][id];
if (maxlen[q] == maxlen[p] + 1)
link[cur] = q;
else {
int clone = (++Size);
maxlen[clone] = maxlen[p] + 1;
memcpy(trans[clone], trans[q], sizeof trans[q]);
link[clone] = link[q];
for (; p && trans[p][id] == q; p = link[p]) trans[p][id] = clone;
link[cur] = link[q] = clone;
}
}
Last = cur;
}
void work() {
long long ans = 0;
for (register int i = 2; i <= Size; ++i) {
ans += (long long)(maxlen[i] - maxlen[link[i]]) * (num[i]) * (num[i]);
}
cout << ans << endl;
}
} sam;
char s[N];
int main() {
int t = in();
while (t--) {
sam.init();
scanf("%s", s + 1);
int len = strlen(s + 1);
for (register int i = 1; i <= len; ++i) sam.Extend(s[i] - 'a');
sam.Qsort();
sam.work();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int chan[2005][10];
string ans;
int dp[2005][2005][10];
int func(int ind, int k, int num) {
if (ind == n) {
if (k == 0) {
dp[ind][k][num] = 1;
return 1;
}
return 0;
}
if (dp[ind][k][num] != -1) return dp[ind][k][num];
int maxi = 0;
for (int j = 9; j >= 0; j--) {
if (chan[ind][j] != -1 && chan[ind][j] <= k) {
maxi = max(maxi, func(ind + 1, k - chan[ind][j], j));
}
}
return dp[ind][k][num] = maxi;
}
void findans(int ind, int k, int num) {
if (ind == n) return;
for (int j = 9; j >= 0; j--) {
if (dp[ind + 1][k - chan[ind][j]][j] == 1) {
char ch = j + '0';
ans.push_back(ch);
findans(ind + 1, k - chan[ind][j], j);
return;
}
}
}
int main() {
int i, j, l, k;
cin >> n >> l;
memset(dp, -1, sizeof(dp));
vector<string> vec1, vec2;
for (i = 0; i < n; i++) {
string str;
cin >> str;
vec1.push_back(str);
}
vec2.push_back("1110111");
vec2.push_back("0010010");
vec2.push_back("1011101");
vec2.push_back("1011011");
vec2.push_back("0111010");
vec2.push_back("1101011");
vec2.push_back("1101111");
vec2.push_back("1010010");
vec2.push_back("1111111");
vec2.push_back("1111011");
for (i = 0; i < n; i++) {
for (j = 0; j < 10; j++) {
string str1 = vec1[i], str2 = vec2[j];
int count = 0;
for (k = 0; k < 7; k++) {
if (str1[k] == '0' && str2[k] == '1')
count++;
else if (str1[k] == '1' && str2[k] == '0')
break;
}
if (k == 7)
chan[i][j] = count;
else
chan[i][j] = -1;
}
}
func(0, l, 0);
findans(0, l, 0);
if (ans.size() == 0)
cout << "-1";
else
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
signed long long GETi() {
signed long long i;
scanf("%lld", &i);
return i;
}
signed long long mo = 1000000007;
int N, K;
signed long long dpdp[51][51][2];
signed long long comb(int P_, int Q_) {
static const int N_ = 1020;
static signed long long C_[N_][N_];
if (C_[0][0] == 0) {
int i, j;
for (i = 0; i < N_; i++) C_[i][0] = C_[i][i] = 1;
for (i = 1; i < N_; i++)
for (j = 1; j < i; j++) C_[i][j] = (C_[i - 1][j - 1] + C_[i - 1][j]) % mo;
}
if (P_ < 0 || P_ > N_ || Q_ < 0 || Q_ > P_) return 0;
return C_[P_][Q_];
}
void solve() {
int f, i, j, k, l, x, y;
cin >> N >> K;
if (N < 2 * K) return (void)printf("0\n");
dpdp[1][0][1] = 1;
for (x = 2; x <= N; x++)
for (y = 0; y < K + 1; y++) {
for (l = 1; l <= x - 2; l++) {
int r = x - 1 - l;
signed long long pat = comb(x - 1, 2) * comb(x - 3, l - 1) % mo;
for (int lk = 0; lk <= y; lk++) {
int rk = y - lk;
dpdp[x][y][1] += pat * dpdp[l][lk][0] % mo * dpdp[r][rk][0];
dpdp[x][y][1] %= mo;
}
for (int lk = 0; lk <= y - 1; lk++) {
int rk = y - 1 - lk;
dpdp[x][y][0] += pat * dpdp[l][lk][1] % mo * dpdp[r][rk][0];
dpdp[x][y][0] += pat * dpdp[l][lk][0] % mo * dpdp[r][rk][1];
dpdp[x][y][0] += pat * dpdp[l][lk][1] % mo * dpdp[r][rk][1];
dpdp[x][y][0] %= mo;
}
}
if (y > 0) dpdp[x][y][0] += (x - 1) * dpdp[x - 1][y - 1][1];
dpdp[x][y][1] += (x - 1) * dpdp[x - 1][y][0];
dpdp[x][y][0] %= mo;
dpdp[x][y][1] %= mo;
}
cout << (dpdp[N][K][0] + dpdp[N][K][1]) % mo << endl;
}
int main(int argc, char** argv) {
string s;
if (argc == 1) ios::sync_with_stdio(false);
for (int i = 1; i < argc; i++) s += argv[i], s += '\n';
for (int i = s.size() - 1; i >= 0; i--) ungetc(s[i], stdin);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
struct MI {
private:
char bb[1 << 14];
FILE* f;
char *bs, *be;
char e;
bool o, l;
public:
MI() : f(stdin), bs(0), be(0) {}
inline char get() {
if (o) {
o = 0;
return e;
}
if (bs == be) be = (bs = bb) + fread(bb, 1, sizeof(bb), f);
if (bs == be) {
l = 1;
return -1;
};
return *bs++;
}
inline void unget(char c) {
o = 1;
e = c;
}
template <class T>
inline T read() {
T r;
*this > r;
return r;
}
template <class T>
inline MI& operator>(T&);
};
template <class T>
struct Q {
const static bool U = T(-1) >= T(0);
inline void operator()(MI& t, T& r) const {
r = 0;
char c;
bool y = 0;
if (U)
for (;;) {
c = t.get();
if (c == -1) goto E;
if (isdigit(c)) break;
}
else
for (;;) {
c = t.get();
if (c == -1) goto E;
if (c == '-') {
c = t.get();
if (isdigit(c)) {
y = 1;
break;
};
} else if (isdigit(c))
break;
;
};
for (;;) {
if (c == -1) goto E;
if (isdigit(c))
r = r * 10 + (c ^ 48);
else
break;
c = t.get();
}
t.unget(c);
E:;
if (y) r = -r;
}
};
template <>
struct Q<char> {};
template <class T>
inline MI& MI::operator>(T& t) {
Q<T>()(*this, t);
return *this;
}
template <class T>
std::ostream& operator<(std::ostream& out, const T& t) {
return out << t;
}
using std::cout;
MI cin;
const int $n = 100005;
const int $l = 30;
int n, cnt[$l + 1];
inline void work() {
cin > n;
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= n; ++i) {
int v = (cin.read<int>());
for (int j = 0; j <= $l; ++j) {
cnt[j] += v & 1;
v >>= 1;
}
}
for (int i = $l; ~i; --i) {
if (!(cnt[i] & 1)) continue;
if ((cnt[i] & 3) == 1) return (void)(cout < "WIN\n");
if ((cnt[i] & 3) == 3) {
if ((n - cnt[i]) & 1)
return (void)(cout < "WIN\n");
else
return (void)(cout < "LOSE\n");
}
}
cout < "DRAW\n";
}
int main() {
for (int T = (cin.read<int>()); T; --T) work();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int first = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) {
if (ch == '-') f = -1;
}
for (; isdigit(ch); ch = getchar()) {
first = first * 10 + ch - 48;
}
return first * f;
}
const int mxN = 1e5;
const int P = 1e9 + 7;
int n, q;
long long ans;
int a[mxN + 3];
vector<int> disc, c[mxN + 3];
int id[mxN + 3];
long long f[mxN + 3], g[mxN + 3];
bool sta[mxN + 3];
struct BITree {
vector<long long> bit;
void resize(int sz) { bit.resize(sz + 1); }
void add(int u, long long first) {
while (u < bit.size()) {
bit[u] += first;
u += (u & (-u));
}
}
long long query(int u) {
long long ret = 0ll;
while (u) {
ret += bit[u];
u -= (u & (-u));
}
return ret % P;
}
} bit1, bit2;
struct SgTNode {
long long a[3][3];
SgTNode() { memset(a, 0, sizeof(a)); }
};
SgTNode operator+(SgTNode ls, SgTNode rs) {
SgTNode ret;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
ret.a[i][j] = ls.a[i][j] + rs.a[i][j];
for (int k = i; k < j; k++) ret.a[i][j] += ls.a[i][k] * rs.a[k + 1][j];
ret.a[i][j] %= P;
}
return ret;
}
struct SegmentTree {
int clr;
vector<SgTNode> sgt;
void build(int u, int le, int ri) {
if (le == ri) {
sgt[u].a[0][0] = f[c[clr][le]], sgt[u].a[1][1] = 1ll,
sgt[u].a[2][2] = g[c[clr][le]];
return;
}
int mid = (le + ri) >> 1;
build(u << 1, le, mid);
build(u << 1 | 1, mid + 1, ri);
sgt[u] = sgt[u << 1] + sgt[u << 1 | 1];
}
void modify(int u, int le, int ri, int first) {
int xx = c[clr][first];
if (le == ri) {
sgt[u].a[0][0] = (sta[xx] ? 0 : f[xx]),
sgt[u].a[1][1] = (sta[xx] ? 0 : 1ll),
sgt[u].a[2][2] = (sta[xx] ? 0 : g[xx]);
return;
}
int mid = (le + ri) >> 1;
if (first <= mid) {
modify(u << 1, le, mid, first);
} else {
modify(u << 1 | 1, mid + 1, ri, first);
}
sgt[u] = sgt[u << 1] + sgt[u << 1 | 1];
}
} sgt[mxN + 3];
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read(), disc.push_back(a[i]);
sort(disc.begin(), disc.end());
disc.erase(unique(disc.begin(), disc.end()), disc.end());
for (int i = 1; i <= n; i++)
a[i] = lower_bound(disc.begin(), disc.end(), a[i]) - disc.begin() + 1;
for (int i = 1; i <= n; i++) {
c[a[i]].push_back(i);
id[i] = c[a[i]].size() - 1;
}
bit1.resize(n), bit2.resize(n);
for (int i = 1; i <= n; i++) {
f[i] = bit1.query(a[i]);
bit1.add(a[i], 1);
}
for (int i = n; i >= 1; i--) {
g[i] = bit2.query(a[i]);
bit2.add(a[i], 1);
}
for (int i = 1; i <= disc.size(); i++) {
sgt[i].clr = i;
sgt[i].sgt.resize(c[i].size() * 4 + 1);
sgt[i].build(1, 0, c[i].size() - 1);
ans = (ans + sgt[i].sgt[1].a[0][2]) % P;
}
q = read();
while (q--) {
int typ = read(), u = read();
sta[u] = typ == 1 ? 1 : 0;
ans = (ans - sgt[a[u]].sgt[1].a[0][2] + P) % P;
sgt[a[u]].modify(1, 0, c[a[u]].size() - 1, id[u]);
ans = (ans + sgt[a[u]].sgt[1].a[0][2]) % P;
printf("%lld\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
{
long long int n;
cin >> n;
vector<pair<long long int, long long int>> a(n);
long long int b[n], maxi = 0;
for (long long int i = 0; i < n; i++)
cin >> b[i], a[i].first = (b[i] / n), a[i].second = i + 1,
maxi = max(maxi, b[i] / n);
sort(a.begin(), a.end());
long long int ans = 0;
bool ok = false;
long long int y = 0;
for (long long int i = 0; i < n; i++) {
if (a[i].first != y) {
y = a[i].first;
for (long long int j = 0; j < i; j++) {
long long int x = b[a[j].second - 1] % n - (a[j].second - 1);
x -= n;
if (x <= 0) {
ans = a[j].second;
ok = true;
}
if (ok) break;
}
}
long long int x = b[a[i].second - 1] % n - (a[i].second - 1);
if (x <= 0 && (!ok || a[i].second < ans)) {
ans = a[i].second;
ok = true;
}
if (ok) break;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int pan[110][110];
char st[110];
int n;
const int dir[4][2] = {0, -1, 0, 1, -1, 0, 1, 0};
int pand(int x, int y) {
int x1, y1, k;
int res = 0;
for (k = 0; k < 4; k++) {
x1 = x + dir[k][0];
y1 = y + dir[k][1];
res += pan[x1][y1];
}
return res;
}
int main() {
int i, j;
while (scanf("%d", &n) != EOF) {
memset(pan, 0, sizeof(pan));
getchar();
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
char cc = getchar();
if (cc == 'o') pan[i][j] = 1;
}
getchar();
}
bool ff = true;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (pand(i, j) & 1) {
ff = false;
break;
}
if (ff)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MAXN = 2000005;
const int BASE = 153;
const int MOD = 1000000009;
const int BASE2 = 137;
const int MOD2 = 1000000007;
using namespace std;
int n, ans;
map<pair<int, int>, bool> m;
set<pair<int, pair<pair<int, int>, pair<int, int>>>> st;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
long long temp = 0, temp2 = 0;
temp2 = temp2 * 1ll * BASE;
temp2 += s[0] - 'a' + 1;
temp2 %= MOD;
long long ttemp = 0, ttemp2 = 0;
ttemp2 = ttemp2 * 1ll * BASE2;
ttemp2 += s[0] - 'a' + 1;
ttemp2 %= MOD2;
st.insert({0, {{temp2, ttemp2}, {temp, ttemp}}});
for (int j = 1; j < s.size(); j++) {
temp = temp * 1ll * BASE;
temp += s[j] - 'a' + 1;
temp %= MOD;
temp2 = temp2 * 1ll * BASE;
temp2 += s[j] - 'a' + 1;
temp2 %= MOD;
ttemp = ttemp * 1ll * BASE2;
ttemp += s[j] - 'a' + 1;
ttemp %= MOD2;
ttemp2 = ttemp2 * 1ll * BASE2;
ttemp2 += s[j] - 'a' + 1;
ttemp2 %= MOD2;
st.insert({-j, {{temp2, ttemp2}, {temp, ttemp}}});
}
}
for (auto x : st)
if (!m.count(x.second.first)) {
m[x.second.second] = 1;
ans++;
}
cout << ans << endl;
st.clear();
m.clear();
ans = 0;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int N;
char A[10000005];
char B[10000005];
int P, Q, R, S;
void Init() {
Get(N);
N <<= 1;
scanf("%s%s", A + 1, B + 1);
for (int i = 1; i <= N; i++) {
if (A[i] == '1' && B[i] == '1') P++;
if (A[i] == '1' && B[i] == '0') Q++;
if (A[i] == '0' && B[i] == '1') R++;
if (A[i] == '0' && B[i] == '0') S++;
}
}
int Ans;
void Work() {
Ans = -P - R;
Q += R;
if (P & 1) {
Ans += ceil(P / 2.0) * 2;
Ans += floor(Q / 2.0);
} else {
Ans += ceil(P / 2.0) * 2;
Ans += ceil(Q / 2.0);
}
}
void Output() {
if (Ans > 0) puts("First");
if (Ans == 0) puts("Draw");
if (Ans < 0) puts("Second");
}
int main() {
Init();
Work();
Output();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int cnt[100009], pw[100009];
int mod(long long x) {
while (x < 0) x += 1000000007;
return (x % 1000000007);
}
int main() {
pw[0] = 1;
for (int i = 1; i < 100009; i++) pw[i] = mod(pw[i - 1] * 2LL);
int n, tot = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
cnt[x]++;
}
for (int i = 1; i < 100009; i++)
for (int j = i * 2; j < 100009; j += i) cnt[i] += cnt[j];
for (int i = 1; i < 100009; i++) {
if (!cnt[i]) continue;
int BLOK = sqrt(i), x = i, bit = 0;
for (int j = 2; j <= BLOK; j++) {
int cc = 0;
while (x % j == 0) x /= j, cc++;
if (cc >= 2) {
bit = -1;
break;
}
if (cc == 1) bit++;
}
if (bit == -1) continue;
if (x != 1) bit++;
if (bit & 1)
tot = mod(tot - mod(pw[cnt[i]] - 1));
else
tot = mod(tot + mod(pw[cnt[i]] - 1));
}
printf("%d\n", tot);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 50;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
long long dx[] = {-1, 0, 1, 0};
long long dy[] = {0, 1, 0, -1};
bool compare(const pair<long long, long long>& i,
const pair<long long, long long>& j) {
return i.second < j.second;
}
long long fact[N];
vector<bool> is_prime(100000, true);
vector<long long> prime;
void pre() {
fact[0] = 1;
for (long long i = 1; i < N; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= mod;
}
}
long long modexp(long long x, long long n) {
long long r = 1;
while (n) {
if (n & 1) r = (r * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return r % mod;
}
long long modinv(long long x) { return modexp(x, mod - 2); }
long long ncr(long long n, long long r) {
if (n < r) return 0;
long long ans =
(fact[n] % mod * modinv(fact[r]) % mod * modinv(fact[n - r]) % mod) % mod;
return ans;
}
long long exp(long long x, long long n) {
long long r = 1;
while (n) {
if (n & 1) r = (r * x);
x = (x * x);
n >>= 1;
}
return r;
}
void solve() {
long long n, m;
cin >> n >> m;
vector<vector<long long>> A(n, vector<long long>(2 * m, 0));
for (long long i = 0; i < n; i++)
for (long long j = 0; j < 2 * m; j++) cin >> A[i][j];
long long cnt = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 2 * m; j += 2) {
if (A[i][j] == 1 or A[i][j + 1] == 1) cnt++;
}
}
cout << cnt << "\n";
return;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int mod = 998244353;
int n, m;
int arr[505];
int mem[505][505];
int solve(int l, int r) {
if (l >= r) return 1;
if (mem[l][r] != -1) return mem[l][r];
int index = l;
for (int i = l; i <= r; ++i)
if (arr[index] > arr[i]) index = i;
int ret1 = 0, ret2 = 0;
for (int a = l; a <= index; ++a) {
ret1 = (ret1 + 1LL * solve(l, a - 1) * solve(a, index - 1) % mod) % mod;
}
for (int b = index; b <= r; ++b) {
ret2 = (ret2 + 1LL * solve(index + 1, b) * solve(b + 1, r) % mod) % mod;
}
return mem[l][r] = 1LL * ret1 * ret2 % mod;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) cin >> arr[i];
memset(mem, -1, sizeof(mem));
cout << solve(0, m - 1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
continue;
}
long long k = n / 2;
long long moves = 0;
while (n) {
moves += (4 * n - 4) * k;
k--;
n--;
}
cout << moves << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int Max = 1000;
const int D = 1000;
int n, q, top = 0;
int a[N];
int trac[Max + D];
int d[D + Max];
queue<int> Q;
int main() {
scanf("%d%d", &q, &n);
for (int i = (1), _b = (n); i <= _b; ++i) {
int x;
scanf("%d", &x);
if (d[x] == 0) {
a[++top] = x - q;
d[x] = 1;
}
}
for (int i = (-Max), _b = (Max); i <= _b; ++i) d[i + 1000] = 0;
Q.push(0);
while (!Q.empty()) {
int v = Q.front();
Q.pop();
for (int i = (1), _b = (top); i <= _b; ++i) {
int u = v + a[i];
if (u >= -Max && u <= Max && d[u + 1000] == 0) {
Q.push(u);
d[u + 1000] = d[v + 1000] + 1;
}
}
}
x:;
cout << ((d[0 + 1000] == 0) ? -1 : d[0 + 1000]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double pi = acosl(-1);
const int inf = 2e9;
const int maxn = 1e6 + 15;
struct L {
long long pos, l, r;
} a1[maxn], a2[maxn], b[maxn];
long long tot1, tot2;
struct node {
long long l, r, laz;
} t[maxn << 2];
void build(long long p, long long l, long long r) {
t[p].l = l;
t[p].r = r;
t[p].laz = 0;
if (t[p].l == t[p].r) {
return;
}
long long mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
}
void push_down(long long p) {
t[p << 1].laz += t[p].laz;
t[p << 1 | 1].laz += t[p].laz;
t[p].laz = 0;
}
void change(long long p, long long l, long long r, long long val) {
if (l <= t[p].l && t[p].r <= r) {
t[p].laz += val;
return;
}
push_down(p);
long long mid = (t[p].l + t[p].r) >> 1;
if (mid >= l) change(p << 1, l, r, val);
if (mid < r) change(p << 1 | 1, l, r, val);
}
long long query(long long p, long long l, long long r) {
if (l <= t[p].l && t[p].r <= r) {
return t[p].laz;
}
push_down(p);
long long mid = (t[p].l + t[p].r) >> 1;
long long ans = 0;
if (mid >= l) ans += query(p << 1, l, r);
if (mid < r) ans += query(p << 1 | 1, l, r);
return ans;
}
int main() {
long long n, m;
scanf("%lld%lld", &n, &m);
for (long long i = 1; n >= i; i++) {
L tmp;
scanf("%lld%lld%lld", &tmp.pos, &tmp.l, &tmp.r);
if (tmp.l == 0)
a1[++tot1] = tmp;
else
a2[++tot2] = tmp;
}
long long ans = 1;
for (long long i = 1; m >= i; i++) {
scanf("%lld%lld%lld", &b[i].pos, &b[i].l, &b[i].r);
if (b[i].l == 0 && b[i].r == 1e6) ans++;
}
sort(b + 1, b + m + 1, [](L a, L b) { return a.pos < b.pos; });
sort(a1 + 1, a1 + tot1 + 1, [](L a, L b) { return a.r < b.r; });
build(1, 1, 1e6 + 1);
long long now = 1;
for (long long i = 1; tot1 >= i; i++) {
while (now <= m && a1[i].r >= b[now].pos) {
change(1, b[now].l + 1, b[now].r + 1, 1);
now++;
}
ans += query(1, a1[i].pos + 1, a1[i].pos + 1);
if (a1[i].r == 1e6) ans++;
}
sort(b + 1, b + m + 1, [](L a, L b) { return a.pos > b.pos; });
sort(a2 + 1, a2 + tot2 + 1, [](L a, L b) { return a.l > b.l; });
build(1, 1, 1e6 + 1);
now = 1;
for (long long i = 1; tot2 >= i; i++) {
while (now <= m && a2[i].l <= b[now].pos) {
change(1, b[now].l + 1, b[now].r + 1, 1);
now++;
}
ans += query(1, a2[i].pos + 1, a2[i].pos + 1);
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s;
struct substring {
int f, b;
bool operator>(const substring &o) const {
int cmp = s.compare(f, b - f + 1, s, o.f, o.b - o.f + 1);
return cmp != 0 ? cmp > 0 : f > o.f;
}
};
string kthSubstring(int k) {
priority_queue<substring, vector<substring>, greater<substring>> pq;
int len = s.length();
for (int i = 0; i < len; i++) {
pq.push({i, i});
}
while (!pq.empty()) {
int f = pq.top().f, b = pq.top().b;
pq.pop();
if (--k == 0) return s.substr(f, b - f + 1);
if (++b < len) {
pq.push({f, b});
}
}
return "";
}
int main() {
int k;
cin >> s >> k;
int len = s.length();
long long possible = ((long long)len * (len + 1)) / 2;
if (k > possible)
cout << "No such line." << '\n';
else
cout << kthSubstring(k) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
int n;
const int maxn = 25;
const long long mod = 1e9 + 7;
long long s;
long long f[maxn];
using namespace std;
long long qPow(long long a, long long k, long long p) {
long long ans = 1;
while (k) {
if (k & 1) ans = (ans * a) % p;
a = (a * a) % p;
k /= 2;
}
return ans;
}
long long C(long long a, long long b, long long p) {
if (a < b) return 0;
if (b > a - b) b = a - b;
long long up = 1, down = 1;
for (long long i = 0; i < b; i++) {
up = up * (a - i) % p;
down = down * (i + 1) % p;
}
return up * qPow(down, p - 2, p) % p;
}
long long lucas(long long a, long long b, long long p) {
if (b == 0) return 1;
return C(a % p, b % p, p) * lucas(a / p, b / p, p) % p;
}
long long ans = 0;
void solve() {
for (int i = 0; i < (1 << n); i++) {
long long bit = 1, sum = s;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
sum -= (f[j] + 1);
bit = bit * -1;
}
}
if (sum < 0) continue;
ans += bit * lucas(sum + n - 1, sum, mod);
}
}
int main() {
while (~scanf("%d%I64d", &n, &s)) {
for (int i = 0; i < n; i++) scanf("%I64d", &f[i]);
solve();
ans = (ans % mod + mod) % mod;
cout << ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b > a) swap(a, b);
if (b == 0) return 0;
return gcd(a % b, b) + a / b;
}
int main() {
long long a, b;
scanf("%I64d%I64d", &a, &b);
printf("%I64d\n", gcd(a, b));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int g[100001];
int cnt[100001];
int tmp[100001];
int lcp[100001];
int s_ix[100000];
int d;
bool cmp(int a, int b) {
if (g[a] != g[b]) return g[a] < g[b];
return g[a + d] < g[b + d];
}
void cnt_sort(int len) {
int i;
memset(cnt, 0, sizeof(cnt));
memset(tmp, 0, sizeof(tmp));
for (i = 0; i < len; i++) cnt[g[min(len, s_ix[i] + d)]]++;
for (i = 1; i <= 'z' || i < len; i++) cnt[i] += cnt[i - 1];
for (i = len - 1; i >= 0; i--) tmp[--cnt[g[min(len, s_ix[i] + d)]]] = s_ix[i];
memset(cnt, 0, sizeof(cnt));
for (i = 0; i < len; i++) cnt[g[tmp[i]]]++;
for (i = 1; i <= 'z' || i < len; i++) cnt[i] += cnt[i - 1];
for (i = len - 1; i >= 0; i--) s_ix[--cnt[g[tmp[i]]]] = tmp[i];
}
int main() {
int i, j, k;
int T;
int val;
int offset;
long long ans = 0;
cin >> T;
while (T--) {
ans = 0;
cin >> s;
for (i = 0; i < s.size(); i++) {
g[i] = s[i];
s_ix[i] = i;
ans += i + 1;
}
g[i] = 0;
d = 1;
do {
cnt_sort(s.size());
tmp[s_ix[0]] = 1;
for (i = 1; i < s.size(); i++)
tmp[s_ix[i]] = tmp[s_ix[i - 1]] + cmp(s_ix[i - 1], s_ix[i]);
tmp[i] = 0;
d <<= 1;
for (i = 0; i < s.size(); i++) g[i] = tmp[i];
} while (g[s_ix[s.size() - 1]] != s.size());
for (i = 0; i < s.size(); i++) g[i]--;
d = 0;
vector<pair<int, int> > v;
set<int> st;
for (i = 0; i < s.size(); i++) {
if (g[i] == 0) continue;
j = s_ix[g[i] - 1];
d = max(d - 1, 0);
lcp[g[i]] = 0;
while (i + d < s.size() && j + d < s.size() && s[i + d] == s[j + d])
lcp[g[i]] = ++d;
d = lcp[g[i]] - 1;
if (lcp[g[i]] == 0)
st.insert(g[i]);
else
v.push_back(make_pair(lcp[g[i]], g[i]));
}
lcp[i] = 0;
st.insert(0);
st.insert(s.size());
sort(v.begin(), v.end());
for (i = 0; i < v.size(); i++) {
st.insert(v[i].second);
auto r = st.find(v[i].second);
auto l = st.find(v[i].second);
r++;
l--;
offset = max(lcp[*l], lcp[*r]);
val = (*r - *l);
ans += (v[i].first - offset) * ((long long)val * val - val);
}
cout << ans << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
void write(long long x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
}
const long long MAXN = 3010;
long long n, m;
vector<long long> a[MAXN], sum[MAXN];
long long V[MAXN], W[MAXN];
long long now[MAXN];
long long Ans;
inline void dp(int l, int r) {
if (l == r) {
for (int i = 0; i < a[l].size() && m - i - 1 >= 0; ++i)
Ans = max(Ans, now[m - i - 1] + sum[l][i]);
return;
}
long long cur[MAXN], mid = l + r >> 1;
for (long long i = (0); i <= (m); ++i) cur[i] = now[i];
for (long long i = (mid + 1); i <= (r); ++i)
for (long long j = (m); j >= (V[i]); --j)
now[j] = max(now[j], now[j - V[i]] + W[i]);
dp(l, mid);
for (long long i = (0); i <= (m); ++i) now[i] = cur[i];
for (long long i = (l); i <= (mid); ++i)
for (long long j = (m); j >= (V[i]); --j)
now[j] = max(now[j], now[j - V[i]] + W[i]);
dp(mid + 1, r);
for (long long i = (0); i <= (m); ++i) now[i] = cur[i];
}
int main() {
Ans = (long long)-1e18;
n = read(), m = read();
for (long long i = (1); i <= (n); ++i) {
long long num = read(), x, w = 0;
V[i] = num;
for (long long j = (1); j <= (num); ++j)
x = read(), a[i].push_back(x), w += x;
sum[i].push_back(a[i][0]);
for (long long j = (1); j <= (num - 1); ++j)
sum[i].push_back(sum[i][j - 1] + a[i][j]);
W[i] = w;
}
dp(1, n);
printf("%lld\n", Ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<int> D, R;
int n;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
cin >> s;
queue<int> q;
for (int i = 0; i < n; i++) {
if (s[i] == 'D')
D.push_back(i);
else
R.push_back(i);
q.push(i);
}
int removeR = 0;
int removeD = 0;
while (!q.empty()) {
if (R.size() - removeR <= 0) {
cout << "D";
return 0;
}
if (D.size() - removeD <= 0) {
cout << "R";
return 0;
}
int temp = q.front();
q.pop();
if (s[temp] == 'R') {
if (removeR) {
R.erase(R.end() - 1);
removeR--;
} else {
removeD++;
q.push(temp);
}
} else {
if (removeD) {
D.erase(D.end() - 1);
removeD--;
continue;
} else {
removeR++;
q.push(temp);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long int power(long long int x, long long int n) {
long long int result = 1;
while (n) {
if (n % 2 == 1) result = result * x;
n = n / 2;
x = x * x;
}
return result;
}
long long int gcd(long long int a, long long int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int BS(long long int a[], long long int s, long long int n,
long long int val) {
long long int mid, beg = s, end = n - 1;
while (beg <= end) {
mid = (beg + end) / 2;
if (val == a[mid]) {
break;
} else if (val > a[mid]) {
beg = mid + 1;
} else {
end = mid - 1;
}
}
return mid;
}
using namespace std;
void start() {}
int main() {
start();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int l1, l2, l3;
cin >> l1 >> l2 >> l3;
if (l1 == l2 && l3 % 2 == 0)
cout << "YES"
<< "\n";
else if (l2 == l3 && l1 % 2 == 0)
cout << "YES"
<< "\n";
else if (l1 == l3 && l2 % 2 == 0)
cout << "YES"
<< "\n";
else {
if (l1 + l2 == l3)
cout << "YES"
<< "\n";
else if (l3 + l2 == l1)
cout << "YES"
<< "\n";
else if (l1 + l3 == l2)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int bm(long long int base, long long int power, long long int modu) {
if (power == 0) {
return 1;
}
if (power % 2 == 0) {
long long int ret = (bm(base, power / 2, modu));
return (ret * ret) % modu;
} else {
return (base * (bm(base, power - 1, modu))) % modu;
}
}
int main() {
ios::sync_with_stdio(false);
long long int i, j, x, y, n, m, k, a, b, c, d, e;
cin >> n >> m >> k;
a = n / k;
b = a * (k - 1);
c = n % k;
b += c;
d = max((long long)0, m - b);
e = k * 2;
x = bm(2, d, 1000000009) - 1;
x = x * e;
y = d * k;
y = m - y;
cout << (x + y) % 1000000009;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int num[100001];
int cmp(const int a, const int b) {
int ta, tb;
ta = a - (a / 10) * 10;
tb = b - (b / 10) * 10;
return ta > tb;
}
int main() {
int n, k, ans, i;
cin >> n >> k;
ans = 0;
for (i = 1; i <= n; i++) {
cin >> num[i];
ans += num[i] / 10;
}
sort(num + 1, num + n + 1, cmp);
for (i = 1; i <= n; i++) {
if (num[i] % 10 == 0) continue;
k -= 10 - (num[i] - (num[i] / 10) * 10);
if (k < 0) break;
ans++;
}
if (k > 0) {
ans = ans + k / 10 > n * 10 ? n * 10 : ans + k / 10;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
const int B = 27;
int zhu[B], n, m;
char s[N], t[N];
void solve() {
memset(zhu, 0, sizeof(zhu));
n = strlen(s);
m = strlen(t);
for (int i = 0; i < n; ++i) zhu[s[i] - 'a']++;
int r = -1, p;
if (n > m)
p = m;
else
p = min(n, m) - 1;
for (int i = t[0] - 'a' + 1; i < 26; ++i)
if (zhu[i]) r = 0;
for (int i = 1; i <= p; ++i) {
zhu[t[i - 1] - 'a']--;
if (zhu[t[i - 1] - 'a'] < 0) break;
if (i == m) {
r = m;
continue;
}
for (int j = t[i] - 'a' + 1; j < 26; ++j)
if (zhu[j]) r = i;
}
if (r == -1) {
printf("-1\n");
return;
} else {
memset(zhu, 0, sizeof(zhu));
for (int i = 0; i < n; ++i) zhu[s[i] - 'a']++;
for (int i = 0; i < r; ++i) {
printf("%c", t[i]);
zhu[t[i] - 'a']--;
}
if (r < m)
for (int i = t[r] - 'a' + 1; i < 26; ++i)
if (zhu[i]) {
printf("%c", i + 'a');
zhu[i]--;
break;
}
for (int i = 0; i < 26; ++i)
while (zhu[i]--) printf("%c", i + 'a');
printf("\n");
}
}
int main() {
while (~scanf("%s%s", s, t)) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(pair<long long, long long> a) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(a.first + FIXED_RANDOM) +
splitmix64(a.second + FIXED_RANDOM);
}
};
vector<long long> factorize(long long num) {
vector<long long> res;
for (long long i = 1; i <= sqrt(num); i++) {
if ((num % i) == 0) {
if (i * i == num) {
res.push_back(i);
} else {
res.push_back(i);
res.push_back(num / i);
}
}
}
sort(res.begin(), res.end());
return res;
}
int main() {
long long(n), (m);
scanf("%lld%lld", &(n), &(m));
;
vector<pair<long long, long long> > A, B;
unordered_set<pair<long long, long long>, custom_hash> second;
for (long long i = 0; i < (m); i++) {
long long(a), (b);
scanf("%lld%lld", &(a), &(b));
;
--a;
--b;
A.push_back({a, b});
second.insert({a, b});
}
vector<long long> factors = factorize(n);
for (auto i : factors) {
if (i == n) continue;
bool flag = 0;
for (long long j = 0; j < (m); j++) {
long long a = (A[j].first + i) % n;
long long b = (A[j].second + i) % n;
if (second.find({a, b}) == second.end() &&
second.find({b, a}) == second.end()) {
flag = 1;
break;
}
}
if (!flag) {
printf("Yes\n");
return 0;
}
}
printf("No\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
int jud(int a, int b, int c) {
if ((a == 1 && b == 2 && c == 2) || (a == 2 && b == 3 && c == 3) ||
(a == 3 && b == 1 && c == 1))
return 1;
return 0;
}
int solve(int f, int m, int s) {
if (jud(f, m, s)) return 1;
if (jud(m, f, s)) return 2;
if (jud(s, f, m)) return 3;
return 0;
}
int ex(char s[]) {
if (!strcmp(s, "rock")) return 1;
if (!strcmp(s, "scissors")) return 2;
if (!strcmp(s, "paper")) return 3;
}
int main() {
int f, m, s;
char c[10], o;
scanf("%s", c);
f = ex(c);
scanf("%s", c);
m = ex(c);
scanf("%s", c);
s = ex(c);
switch (solve(f, m, s)) {
case 1:
o = 'F';
break;
case 2:
o = 'M';
break;
case 3:
o = 'S';
break;
default:
o = '?';
}
printf("%c\n", o);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p[66][66], l, r, b, e, used[66] = {0};
double f[8][66], g[8][66], now, ans = 0.0;
int main() {
scanf("%d", &n);
m = 1 << n;
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &p[i][j]);
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
f[i][j] = i == 0 ? 1.0 : 0.0;
g[i][j] = 0.0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
now = f[i][j];
b = j / (1 << i);
b ^= 1;
l = b * (1 << i);
r = l + (1 << i);
for (int k = l; k < r; k++) {
f[i + 1][j] += now * f[i][k] * (double)p[j][k] / 100.0;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
b = j / (1 << (i - 1));
b ^= 1;
l = b * (1 << (i - 1));
r = l + (1 << (i - 1));
for (int k = l; k < r; k++) {
g[i][j] =
max(g[i][j], g[i - 1][j] + g[i - 1][k] + f[i][j] * (1 << (i - 1)));
}
if (i == n) {
ans = max(ans, g[i][j]);
}
}
}
printf("%.10lf\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, i, n, k;
scanf("%lld", &t);
while (t--) {
scanf("%lld%lld", &n, &k);
long long int arr[n], flag = 1, max, min;
for (i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<long long int>());
min = arr[n - 1];
max = arr[0];
if (min + k >= max - k)
printf("%lld\n", (min + k));
else
printf("-1\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long b[100009], g[100009], a[100009], dp[109];
int q[100009], l = 1, cur, i;
int main() {
int n;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
g[0] = -1, i = 1;
for (; i < n; g[i] = (dp[i] - dp[q[l - 1]]) / (b[q[l - 1]] - b[i]), q[l] = i,
i++, l++) {
while (cur < l - 1 && a[i] >= g[q[cur + 1]]) cur++;
dp[i] = b[q[cur]] * a[i] + dp[q[cur]];
while (l > 1 && dp[i] - dp[q[l - 2]] <= g[q[l - 1]] * (b[q[l - 2]] - b[i]))
l--;
}
cout << dp[n - 1];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int col[200010];
int lstx[200010], lsty[200010];
struct Edge {
int v, nxt;
} e[400010];
int tot;
int first[200010];
void build(int u, int v) {
e[++tot] = (Edge){v, first[u]};
first[u] = tot;
return;
}
void dfs(int u, int now) {
if (col[u]) return;
col[u] = now;
for (int i = first[u]; i; i = e[i].nxt) dfs(e[i].v, now ^ 1);
return;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d %d", &x, &y);
if (lstx[x]) {
build(lstx[x], i);
build(i, lstx[x]);
lstx[x] = 0;
} else
lstx[x] = i;
if (lsty[y]) {
build(lsty[y], i);
build(i, lsty[y]);
lsty[y] = 0;
} else
lsty[y] = i;
}
for (int i = 1; i <= n; i++) {
dfs(i, 0);
if (col[i])
printf("b");
else
printf("r");
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, m, s, t1, t2;
cin >> h >> m >> s >> t1 >> t2;
if (t1 > t2) swap(t1, t2);
if (h == 12) h = 0;
float angh, angm, angs, angt1, angt2;
angh = h * 30 + m / 2.0 + s / 120.0;
angm = m * 6 + s / 10.0;
angs = s * 6;
angt1 = t1 * 30;
angt2 = t2 * 30;
if ((angt2 > angh && angt2 > angm && angt2 > angs) &&
(angt1 < angh && angt1 < angm && angt1 < angs)) {
cout << "YES";
} else if (angt2 > angm && angm > angt1) {
cout << "NO";
} else if (angt2 > angs && angs > angt1) {
cout << "NO";
} else if (angt2 > angh && angh > angt1) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int D = 10000010;
const int MAXW = N + 1000;
const int mod = 1e9 + 7;
int n, m;
int pw2[MAXW + 10];
struct edge {
int to, nx, w;
} ee[N * 2];
int eq[N], en = 1;
int dn, flag;
int l[D], r[D], hs[D];
int ans[N], root[N], pred[N];
bool done[N];
int sv[N], svt;
bool cmp(int u, int v) {
if (!l[u] && !r[u])
return hs[u] <= hs[v];
else
return hs[r[u]] == hs[r[v]] ? cmp(l[u], l[v]) : cmp(r[u], r[v]);
}
struct compare {
bool operator()(const pair<int, int>& u, const pair<int, int>& v) {
if (hs[u.first] == hs[v.first])
return u > v;
else
return !cmp(u.first, v.first);
}
};
priority_queue<pair<int, int>, vector<pair<int, int> >, compare> Q;
void update(int d, int lt, int rt) {
int md = (lt + rt) >> 1;
hs[d] = (1LL * hs[r[d]] * pw2[md - lt + 1] + hs[l[d]]) % mod;
}
int add(int d, int lt, int rt) {
int nd = ++dn, md = (lt + rt) >> 1;
if (lt == rt)
hs[nd] = 1;
else {
if ((hs[l[d]] + 1) % mod != pw2[md - lt + 1]) {
l[nd] = add(l[d], lt, md);
r[nd] = r[d];
} else {
l[nd] = 0;
r[nd] = add(r[d], md + 1, rt);
}
update(nd, lt, rt);
}
return nd;
}
int add(int d, int lt, int rt, int w) {
int nd = ++dn, md = (lt + rt) >> 1;
if (lt == rt) {
if (hs[d])
return 0;
else {
flag = 1;
return hs[nd] = 1, nd;
}
}
if (w <= md) {
l[nd] = add(l[d], lt, md, w);
if (flag) {
r[nd] = r[d];
} else {
if ((hs[r[d]] + 1) % mod == pw2[rt - md])
r[nd] = 0;
else {
flag = 1;
r[nd] = add(r[d], md + 1, rt);
}
}
} else {
l[nd] = l[d];
r[nd] = add(r[d], md + 1, rt, w);
}
update(nd, lt, rt);
return nd;
}
void link(int u, int v, int w) { ee[++en] = (edge){v, eq[u], w}, eq[u] = en; }
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i <= MAXW; ++i) {
pw2[i] = !i ? 1 : (pw2[i - 1] * 2) % mod;
}
for (int i = 1; i <= m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
link(u, v, w);
link(v, u, w);
}
int s, t;
scanf("%d %d", &s, &t);
for (int i = 1; i <= n; ++i) {
if (i != s) {
flag = 0;
root[i] = add(root[i], 0, MAXW, MAXW);
}
Q.push(make_pair(root[i], i));
}
while (!Q.empty()) {
int u = Q.top().second;
Q.pop();
if (done[u]) continue;
done[u] = 1;
for (int j = eq[u], v; v = ee[j].to, j; j = ee[j].nx)
if (!done[v]) {
flag = 0;
int nt = add(root[u], 0, MAXW, ee[j].w);
if (cmp(nt, root[v])) {
root[v] = nt;
pred[v] = u;
ans[v] = (ans[u] + pw2[ee[j].w]) % mod;
flag = 0;
int nt = add(root[u], 0, MAXW, ee[j].w);
Q.push(make_pair(root[v], v));
}
}
}
if (s == t || pred[t]) {
printf("%d\n", ans[t]);
svt = 0;
for (int o = t; o; o = pred[o]) sv[++svt] = o;
printf("%d\n", svt);
for (int i = svt; i >= 1; --i) printf("%d ", sv[i]);
putchar('\n');
} else {
printf("-1\n");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve();
void fastIO() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
fastIO();
solve();
}
void solve() {
int r, c;
cin >> r >> c;
char p[r][c];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) cin >> p[i][j];
}
int flag = 1;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (p[i][j] == 'S') {
if (j < c - 1) {
if (p[i][j + 1] == 'W') flag = 0;
}
if (j > 0) {
if (p[i][j - 1] == 'W') flag = 0;
}
if (i > 0) {
if (p[i - 1][j] == 'W') flag = 0;
}
if (i < r - 1) {
if (p[i + 1][j] == 'W') flag = 0;
}
}
if (flag == 0) break;
}
if (flag == 0) break;
}
if (flag == 0) {
cout << "No";
return;
}
cout << "Yes" << '\n';
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (p[i][j] == 'S') {
if (j < c - 1) {
if (p[i][j + 1] == '.') p[i][j + 1] = 'D';
}
if (j > 0) {
if (p[i][j - 1] == '.') p[i][j - 1] = 'D';
}
if (i > 0) {
if (p[i - 1][j] == '.') p[i - 1][j] = 'D';
}
if (i < r - 1) {
if (p[i + 1][j] == '.') p[i + 1][j] = 'D';
}
}
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cout << p[i][j];
}
cout << '\n';
}
return;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
vector<int> par(N, -1);
vector<set<int>> children(N, set<int>());
for (int i = 1; i < N; ++i) {
scanf("%d", &par[i]);
children[par[i]].insert(i);
}
vector<int> bfs = {0};
for (int i = 0; i < bfs.size(); ++i) {
bfs.insert(bfs.end(), children[bfs[i]].begin(), children[bfs[i]].end());
}
vector<int> order;
vector<int> ops;
int cur = bfs.back();
while (cur != 0) {
int p = par[cur];
if (children[p].size() == 1) {
order.push_back(cur);
cur = p;
} else {
ops.push_back(cur);
children[p].erase(cur);
int sibling = *children[p].begin();
par[cur] = sibling;
children[sibling].insert(cur);
}
}
order.push_back(0);
for (int i = N - 1; i >= 0; --i) {
printf("%d", order[i]);
if (i == 0)
printf("\n");
else
printf(" ");
}
printf("%d\n", (int)ops.size());
for (int i = ops.size() - 1; i >= 0; --i) {
printf("%d", ops[i]);
if (i == 0)
printf("\n");
else
printf(" ");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, k, Fa[N], C[N], D[N];
vector<int> Adj[N];
void DFS(int u, int root) {
Fa[u] = root;
D[u] = C[u];
for (int i = 0; i < Adj[u].size(); i++) {
int v = Adj[u][i];
if (v == root) continue;
DFS(v, u);
D[u] += D[v];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
memset(C, sizeof(C), 0);
for (int i = 0; i < 2 * k; i++) {
int x;
cin >> x;
C[x]++;
}
for (int i = 1; i <= n; i++) Adj[i].clear();
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
Adj[u].push_back(v);
Adj[v].push_back(u);
}
DFS(1, 0);
long long ans = 0;
for (int i = 2; i <= n; i++) ans += min(D[i], 2 * k - D[i]);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "0";
} else {
cout << "1";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<string> SubstringGenerate(string str);
int main() {
string str;
vector<string> store;
int i, j;
int answer = 0;
while (cin >> str) {
answer = 0;
store = SubstringGenerate(str);
for (i = 0; i < store.size(); i++) {
for (j = 0; j < store.size(); ++j) {
if (i != j) {
if (store[i] == store[j] && store[i].size() > answer)
answer = store[i].size();
}
}
}
cout << answer << endl;
}
}
vector<string> SubstringGenerate(string str) {
int i, j, len;
vector<string> store;
len = str.size();
for (i = 0; i < len; i++) {
for (j = i; j < len; j++) store.push_back(str.substr(i, j - i + 1));
}
return store;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265358979323846;
const long long mod = 1e9 + 7;
const long long N = 5e5;
const long long INF = 1e9 + 1;
long long n, k, x, y;
int main() {
cin >> n >> k >> x >> y;
string ans = "";
long long res = 1;
if (x > y) {
ans += "G";
x--;
} else {
ans += "B";
y--;
}
for (int i = 0; i < n - 1; ++i) {
if (x >= y && ans[i] == 'G' && res < k && x > 0) {
ans += 'G';
res++;
x--;
} else if (y >= x && ans[i] == 'B' && res < k && y > 0) {
ans += 'B';
res++;
y--;
} else if (res == k && ans[i] == 'G' && y > 0) {
res = 1;
ans += 'B';
y--;
} else if (res == k && ans[i] == 'B' && x > 0) {
res = 1;
ans += 'G';
x--;
} else if (x >= y && ans[i] == 'B' && res < k && x > 0) {
ans += 'G';
res = 1;
x--;
} else if (y >= x && ans[i] == 'G' && res < k && y > 0) {
ans += 'B';
res = 1;
y--;
} else {
cout << "NO";
return 0;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000010;
int main() {
int n, l, r, ql, qr;
int a[111111];
int L[111111], R[111111];
int i, j;
scanf("%d%d%d%d%d", &n, &l, &r, &ql, &qr);
memset(a, 0, sizeof(a));
memset(L, 0, sizeof(L));
memset(R, 0, sizeof(R));
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
L[0] = R[0] = 0;
for (i = 1; i <= n; i++) L[i] = L[i - 1] + a[i];
for (i = 1, j = n; j >= 1, i <= n; i++, j--) R[i] = R[i - 1] + a[j];
int sum = 0, ans = INF;
for (i = 0; i <= n; i++) {
sum = L[i] * l + R[n - i] * r;
if (i > n - i) sum += (2 * i - n - 1) * ql;
if (i < n - i) sum += (n - 2 * i - 1) * qr;
ans = min(ans, sum);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, res = 999999;
cin >> n >> m >> k;
vector<vector<int> > a(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
if (n > k) {
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
int cntt = 0;
for (int c = 0; c < m; c++)
if (a[i][c] == a[j][c]) cntt++;
cnt += ((cntt < m - cntt) ? cntt : m - cntt);
}
res = ((res < cnt) ? res : cnt);
}
} else {
for (int c = 0; c < (1 << n); c++) {
int cnt = 0;
for (int i = 0; i < m; i++) {
int cntt = 0;
for (int j = 0; j < n; j++)
if (a[j][i] == (c >> j & 1)) cntt++;
cnt += ((cntt < n - cntt) ? cntt : n - cntt);
}
res = ((res < cnt) ? res : cnt);
}
}
if (res > k)
cout << -1 << endl;
else
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long mod2 = 998244353;
long long mod3 = 1000003;
long long mod4 = 998244853;
long long mod5 = 1000000009;
long long inf = 1LL << 62;
double pi = 3.141592653589793238462643383279L;
double eps = 1e-14;
int dh[4] = {1, -1, 0, 0};
int dw[4] = {0, 0, 1, -1};
int ddh[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int ddw[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
if (a % b == 0) return b;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
long long c = gcd(a, b);
return a * b / c;
}
long long Pow(long long n, long long k) {
long long ret = 1;
long long now = n;
while (k > 0) {
if (k & 1) ret *= now;
now *= now;
k /= 2;
}
return ret;
}
long long beki(long long n, long long k, long long md) {
long long ret = 1;
long long now = n;
now %= md;
while (k > 0) {
if (k % 2 == 1) {
ret *= now;
ret %= md;
}
now *= now;
now %= md;
k /= 2;
}
return ret;
}
long long gyaku(long long n, long long md) { return beki(n, md - 2, md); }
long long popcount(long long n) {
long long ret = 0;
long long u = n;
while (u > 0) {
ret += u % 2;
u /= 2;
}
return ret;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
int a[n], b[n];
for (long long i = 0; i < n; i++) scanf("%d %d", &a[i], &b[i]);
long long dp[n + 1][k];
for (long long i = 0; i < n + 1; i++) {
for (long long j = 0; j < k; j++) dp[i][j] = -inf;
}
dp[0][0] = 0;
long long sum = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < k; j++) {
if (dp[i][j] < 0) continue;
long long bl = sum - j + k;
bl %= k;
long long ama = (a[i] + b[i]) % k;
for (long long l = 0; l < k; l++) {
long long nr = l, nb = ama - l;
if (nb < 0) nb += k;
long long ns = (a[i] + b[i] - nr - nb) / k;
if (nr > a[i]) break;
if (nb > b[i]) continue;
long long ner = nr + j, neb = bl + nb;
if (ner >= k) {
ns++;
ner -= k;
}
if (neb >= k) ns++;
dp[i + 1][ner] = max(dp[i + 1][ner], dp[i][j] + ns);
}
}
sum += a[i] + b[i];
}
long long ans = 0;
for (long long i = 0; i < k; i++) ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int INF32 = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3f;
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = 1.0e-8;
struct Point {
double x, y, t, d;
Point(double _x = 0, double _y = 0, double _t = 0, double _d = 0) {
x = _x;
y = _y;
t = _t;
d = _d;
}
friend Point operator+(const Point &a, const Point &b) {
return Point(a.x + b.x, a.y + b.y);
}
friend Point operator-(const Point &a, const Point &b) {
return Point(a.x - b.x, a.y - b.y);
}
friend double operator^(Point a, Point b) { return a.x * b.y - a.y * b.x; }
friend int operator==(const Point &a, const Point &b) {
if (fabs(a.x - b.x) < EPS && fabs(a.y - b.y) < EPS) return 1;
return 0;
}
friend double operator*(const Point &a, const Point &b) {
return a.x * b.x + a.y * b.y;
}
};
struct V {
Point start, end;
double ang;
V(Point _start = Point(0, 0), Point _end = Point(0, 0), double _ang = 0.0) {
start = _start;
end = _end;
ang = _ang;
}
friend V operator+(const V &a, const V &b) {
return V(a.start + b.start, a.end + b.end);
}
friend V operator-(const V &a, const V &b) {
return V(a.start - b.start, a.end - b.end);
}
};
Point Basic, points[MAXN];
set<Point> S;
int N;
int Sgn(double key) { return fabs(key) < EPS ? 0 : (key < 0 ? -1 : 1); }
int Cmp(double key1, double key2) { return Sgn(key1 - key2); }
double GetLen(Point key) { return sqrt(key * key); }
bool operator<(Point key1, Point key2) {
key1 = key1 - Basic;
key2 = key2 - Basic;
double Ang1 = atan2(key1.y, key1.x), Ang2 = atan2(key2.y, key2.x);
double Len1 = GetLen(key1), Len2 = GetLen(key2);
if (Cmp(Ang1, Ang2) != 0) return Cmp(Ang1, Ang2) < 0;
return Cmp(Len1, Len2) < 0;
}
set<Point>::iterator Prev(set<Point>::iterator key) {
if (key == S.begin()) key = S.end();
return --key;
}
set<Point>::iterator Next(set<Point>::iterator key) {
++key;
return key == S.end() ? S.begin() : key;
}
int Query(Point key) {
set<Point>::iterator it = S.lower_bound(key);
if (it == S.end()) it = S.begin();
return Sgn((key - *(Prev(it))) ^ (*(it) - *(Prev(it)))) <= 0;
}
void Insert(Point key) {
if (Query(key)) return;
S.insert(key);
set<Point>::iterator Cur = Next(S.find(key));
while (S.size() > 3 &&
Sgn((key - *(Next(Cur))) ^ (*(Cur) - *(Next(Cur)))) <= 0) {
S.erase(Cur);
Cur = Next(S.find(key));
}
Cur = Prev(S.find(key));
while (S.size() > 3 && Sgn((key - *(Cur)) ^ (*(Cur) - *(Prev(Cur)))) >= 0) {
S.erase(Cur);
Cur = Prev(S.find(key));
}
}
int main() {
scanf("%d", &N);
Basic = Point(0, 0);
for (int i = 1, T; i <= 3; ++i) {
scanf("%d%lf%lf", &T, &points[i].x, &points[i].y);
Basic = Basic + points[i];
}
Basic.x /= 3.0;
Basic.y /= 3.0;
for (int i = 1; i <= 3; ++i) {
S.insert(points[i]);
}
for (int i = 4, T; i <= N; ++i) {
scanf("%d%lf%lf", &T, &points[i].x, &points[i].y);
if (T == 1)
Insert(points[i]);
else {
if (Query(points[i]))
printf("YES\n");
else
printf("NO\n");
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 105;
int pow2[25];
inline void init() {
pow2[0] = 1;
for (int i = 1; i < 25; i++) pow2[i] = pow2[i - 1] * 2;
}
int n, m;
long long B;
struct pNode {
long long cost;
long long moni;
int solve;
};
pNode p[Maxn];
inline bool cmpNode(pNode a, pNode b) {
if (a.moni < b.moni) return true;
return false;
}
inline void input() {
scanf("%d%d%I64d", &n, &m, &B);
for (int i = 1; i <= n; i++) {
int m;
scanf("%I64d%I64d%d", &p[i].cost, &p[i].moni, &m);
for (int j = 1; j <= m; j++) {
int tmp;
scanf("%d", &tmp);
p[i].solve += pow2[tmp - 1];
}
}
sort(p + 1, p + n + 1, cmpNode);
}
long long Ans = -1;
int maxLimi;
long long F[1 << 21];
inline void dp() {
maxLimi = (1 << m) - 1;
memset(F, -1, sizeof(F));
F[0] = 0;
for (int i = 1; i <= n; i++) {
for (int st = maxLimi; st >= 0; st--) {
if (F[st] != -1) {
int tst = st | p[i].solve;
if (F[tst] == -1) {
F[tst] = F[st] + p[i].cost;
} else {
F[tst] = min(F[tst], F[st] + p[i].cost);
}
if (tst == maxLimi) {
if (Ans == -1) {
Ans = F[tst] + p[i].moni * B;
} else {
Ans = min(Ans, F[tst] + p[i].moni * B);
}
}
}
}
}
printf("%I64d\n", Ans);
}
int main() {
init();
input();
dp();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7, N = 1e5 + 7;
int n, m, x;
struct T {
long long ans;
vector<pair<int, int> > l, r;
T() {}
T(int val) {
l = r = {{val, 1}};
ans = val >= x;
}
};
vector<pair<int, int> > cmb(vector<pair<int, int> > a,
vector<pair<int, int> > b) {
assert(a.size());
for (pair<int, int> p : b) {
if ((p.first | a.back().first) == a.back().first)
a.back().second += p.second;
else
a.emplace_back(p.first | a.back().first, p.second);
}
return a;
}
T operator+(const T a, const T b) {
T c;
c.ans = a.ans + b.ans;
c.l = cmb(a.l, b.l);
c.r = cmb(b.r, a.r);
long long sum = 0;
for (int i = 0, j = (int)b.l.size() - 1; i < a.r.size(); i++) {
while (j >= 0 && (b.l[j].first | a.r[i].first) >= x)
sum += b.l[j].second, j--;
c.ans += sum * a.r[i].second;
}
return c;
}
T t[N * 4];
int a[N];
void build(int v = 1, int tl = 0, int tr = n) {
if (tr - tl == 1) {
t[v] = T(a[tl]);
return;
}
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm, tr);
t[v] = t[v * 2] + t[v * 2 + 1];
}
void upd(int pos, int val, int v = 1, int tl = 0, int tr = n) {
if (tr - tl == 1) {
t[v] = T(val);
return;
}
int tm = (tl + tr) / 2;
if (pos < tm)
upd(pos, val, v * 2, tl, tm);
else
upd(pos, val, v * 2 + 1, tm, tr);
t[v] = t[v * 2] + t[v * 2 + 1];
}
T qry(int l, int r, int v = 1, int tl = 0, int tr = n) {
if (l <= tl && tr <= r) return t[v];
int tm = (tl + tr) / 2;
if (r <= tm)
return qry(l, r, v * 2, tl, tm);
else if (l >= tm)
return qry(l, r, v * 2 + 1, tm, tr);
else
return qry(l, r, v * 2, tl, tm) + qry(l, r, v * 2 + 1, tm, tr);
}
signed main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
;
cin >> n >> m >> x;
for (int i = 0; i < n; i++) cin >> a[i];
build();
while (m--) {
int op;
cin >> op;
if (op == 1) {
int i, y;
cin >> i >> y;
upd(i - 1, y);
} else {
int l, r;
cin >> l >> r;
cout << qry(l - 1, r).ans << endl;
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, a, b, res;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y >> a >> b;
if (y < x)
res = -1;
else {
int dif = y - x;
int sum = a + b;
if (dif % sum == 0) {
res = dif / sum;
} else
res = -1;
}
cout << res << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
unsigned long long int idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ", ";
dbs(str.substr(idx + 1), s...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
unsigned long long int t;
t = 1;
unsigned long long int n;
unsigned long long int bits = 23;
const unsigned long long int N = (1 << bits) - 1;
while (t--) {
cin >> n;
vector<unsigned long long int> v(N);
vector<unsigned long long int> a(n);
unsigned long long int x;
for (unsigned long long int i = 0; i < n; i++) {
cin >> a[i];
v[a[i]] = a[i];
}
vector<unsigned long long int> F(N);
for (unsigned long long int i = 0; i < N; i++) {
F[i] = v[i];
}
for (unsigned long long int mask = 0; mask < N; mask++) {
for (unsigned long long int i = 0; i < bits; i++) {
if (mask & (1 << i) && !F[mask]) F[mask] = F[mask ^ (1 << i)];
}
}
unsigned long long int ans = 0;
for (unsigned long long int i = 0; i < n; i++) {
x = a[i];
if (F[~x & N] != 0)
cout << F[~x & N] << " ";
else
cout << -1 << " ";
}
cout << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long a[maxn];
map<int, int> mp[12];
int ss(int s) {
int res = 0;
while (s) {
res++;
s /= 10;
}
return res;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
int t = a[i] % k;
int cur = ss(a[i]);
mp[cur][t]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int t = a[i] % k;
int cur = ss(a[i]);
long long mu = a[i] % k;
for (int j = 1; j <= 10; j++) {
mu *= 10;
mu %= k;
int tmp = (k - mu) % k;
if (j == cur && tmp == t)
ans += mp[j][tmp] - 1;
else
ans += mp[j][tmp];
}
}
printf("%I64d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char zn;
long long mass[10];
long long k;
void printt(long long number) {
for (long long i = 0; i < number; i++) {
cout << '+';
};
cout << "++++++++++++++++++++++++++++++++++++++++++++++++.>";
}
long long razb() {
long long number;
long long res;
cin >> number;
res = number;
while (cin >> zn) {
if (zn == '-') {
cin >> number;
res -= number;
}
if (zn == '+') {
cin >> number;
res += number;
}
};
return res;
};
int main() {
long long it = razb();
mass[0] = it % 10;
k = 1;
it /= 10;
while (it > 0) {
mass[k++] = (it % 10);
it /= 10;
}
k--;
for (k; k >= 0; k--) printt(mass[k]);
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
const int MAXN = 120000;
int was[MAXN];
vector<pair<int, int>> eds[MAXN];
vector<int> go[MAXN];
int pe[MAXN];
int p[MAXN];
int h[MAXN];
int ad[MAXN];
vector<pair<int, int>> vv;
int cc[MAXN];
int n, m;
int dfs1(int v) {
int cur = 0;
was[v] = 1;
for (auto e : eds[v]) {
int u = e.first;
if (was[u]) {
if (h[u] < h[v] - 1) {
--ad[u];
vv.push_back(make_pair(v, u));
go[v].push_back(e.second);
++cur;
}
} else {
h[u] = h[v] + 1;
p[u] = v;
pe[u] = e.second;
cur += dfs1(u);
}
}
cur += ad[v];
if (h[v] != 0) {
cc[pe[v]] = cur;
}
return cur;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
eds[a].push_back(make_pair(b, i));
eds[b].push_back(make_pair(a, i));
}
for (int i = 0; i < n; ++i)
if (!was[i]) dfs1(i);
vector<int> ans;
for (auto e : vv) {
int a, b;
tie(a, b) = e;
int fl = 0;
while (a != b) {
if (cc[pe[a]] != 1) {
fl = 1;
break;
}
a = p[a];
}
if (!fl) {
tie(a, b) = e;
ans.push_back(go[a][0]);
while (a != b) {
ans.push_back(pe[a]);
a = p[a];
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (int i : ans) cout << i + 1 << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int v, id;
bool operator<(const Node& p) const {
if (v == p.v) return id < p.id;
return v < p.v;
}
};
const int N = 1e5 + 10;
int a[N], cnt[N];
set<Node> s;
int main() {
int n;
scanf("%d", &n);
set<Node>::iterator it;
set<Node>::iterator it2;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
for (int i = 1; i <= 100000; i++) {
if (cnt[i]) s.insert((Node){cnt[i], i});
}
for (int i = n; i >= 2; i--) {
if ((int)s.size() == 1) {
printf("%d\n", i);
return 0;
}
it = s.begin();
it2 = s.end();
it2--;
if (it->v == 1) {
it++;
if (it->v == it2->v) {
printf("%d\n", i);
return 0;
}
it--;
}
if (it2->v == it->v + 1) {
it2--;
if (it->v == it2->v) {
printf("%d\n", i);
return 0;
}
}
it = s.lower_bound((Node){cnt[a[i]], a[i]});
s.erase(it);
if (--cnt[a[i]]) s.insert((Node){cnt[a[i]], a[i]});
}
printf("1\n");
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.