solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int N, M, T;
int tb[1005];
int main() {
int i, j, k, a, b, c;
scanf("%d%d", &N, &M);
for (i = 0; i < N; i++) {
scanf("%d%d", &a, &b);
if (b < a) {
c = b;
b = a;
a = c;
}
for (j = a; j <= b; j++) tb[j]++;
}
k = 999999;
for (i = 0; i < 1000; i++) {
if (tb[i] == N) {
j = abs(i - M);
if (j < k) k = j;
}
}
if (k == 999999)
printf("-1\n");
else
printf("%d\n", k);
scanf(" ");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int cnt[(1 << 20)];
int to_pattern(long long x) {
int pattern = 0;
for (int i = 0; i < 18; i++) {
int d = x % 10;
if (d & 1) pattern += (1 << i);
x /= 10;
}
return pattern;
}
int main() {
int t;
long long x;
char qtype;
cin >> t;
while (t--) {
cin >> qtype >> x;
switch (qtype) {
case '+':
cnt[to_pattern(x)]++;
break;
case '-':
cnt[to_pattern(x)]--;
break;
case '?':
cout << cnt[to_pattern(x)] << endl;
}
}
return 0;
}
| 3 |
// Precomputation: O(nlgn)
// Query: O(1)
//
// Data structure: Sparse Table
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
typedef pair<int,int> ii;
typedef vector<int> vi;
const int MAXN = 100005;
const int LOGN = 20;
int idx_in_path[MAXN];
ii path[MAXN<<1];
vi adjList[MAXN];
int path_size = 0;
// compute and store the dfs order in path
// initial call with dfs(root)
void dfs(int u, int depth = 0) {
idx_in_path[u] = path_size;
path[path_size++] = ii(depth,u);
for (int v : adjList[u]) {
dfs(v, depth + 1);
path[path_size++] = ii(depth, u);
}
}
// must call dfs before build
// compute entries for sparse table
ii st[LOGN][MAXN<<1];
void build(int n) {
int h = ceil(log2(n + 1));
for (int i = 0; i < n; i++) st[0][i] = path[i];
for (int i = 1; i < h; i++)
for (int j = 0; j + (1<<i) <= n; j++)
st[i][j] = min(st[i-1][j], st[i-1][j+(1<<(i-1))]);
}
// return the lowest common ancestor between node u and v
int lca(int u, int v) {
int l = idx_in_path[u], r = idx_in_path[v];
if (l > r) swap(l, r); r++; // range [l, r)
int p = 31 - __builtin_clz(r-l);
return min(st[p][l],st[p][r-(1<<p)]).se;
}
int main() {
int num_nodes;
scanf("%d", &num_nodes);
for (int u = 0; u < num_nodes; u++) {
int num_neighbors;
scanf("%d", &num_neighbors);
for (int i = 0; i < num_neighbors; i++) {
int v;
scanf("%d", &v);
adjList[u].push_back(v); // directed edge
}
}
dfs(0);
build(path_size);
int num_queries;
scanf("%d",&num_queries);
for (int i = 0; i < num_queries; i++) {
int u, v;
scanf("%d%d",&u,&v);
printf("%d\n", lca(u, v));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int fir[505], cur[505], to[100005], nxt[100005], cap[100005], cst[100005], cnt;
void addedge(int a, int b, int c, int d) {
to[++cnt] = b;
nxt[cnt] = fir[a];
fir[a] = cnt;
cap[cnt] = c;
cst[cnt] = d;
to[++cnt] = a;
nxt[cnt] = fir[b];
fir[b] = cnt;
cap[cnt] = 0;
cst[cnt] = -d;
}
int S, T, SS, TT, sz;
int deg[505];
long long mic, flow, pc;
void adde(int a, int b, int l, int r, int d) {
if (l) deg[b] += l, deg[a] -= l, pc += 1ll * d * l;
addedge(a, b, r - l, d);
}
int dis[505];
bool vis[505];
queue<int> q;
bool inq[505];
const int INF = 0x3f3f3f3f;
bool spfa() {
for (int i = 1; i <= sz; i++) dis[i] = INF;
q.push(TT);
inq[TT] = 1;
dis[TT] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = 0;
for (int v, w, p = fir[u]; p; p = nxt[p]) {
v = to[p];
w = cst[p ^ 1];
if (cap[p ^ 1] > 0 && dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
if (!inq[v]) q.push(v), inq[v] = 1;
}
}
}
return dis[SS] != INF;
}
long long sap(int u, long long aug) {
if (u == TT) {
mic += aug * dis[SS];
return aug;
}
int tmp, ret = 0;
vis[u] = 1;
for (int v, &p = cur[u]; p; p = nxt[p]) {
v = to[p];
if (!vis[v] && cap[p] > 0 && dis[u] == dis[v] + cst[p]) {
tmp = sap(v, min(aug, 1ll * cap[p]));
cap[p] -= tmp;
aug -= tmp;
cap[p ^ 1] += tmp;
ret += tmp;
if (aug == 0) break;
}
}
vis[u] = 0;
return ret;
}
void micflow() {
while (spfa()) {
for (int i = 1; i <= sz; i++) cur[i] = fir[i];
flow += sap(SS, INF);
}
}
int main() {
cnt = 1;
int n, m, i, u, v, c, f;
scanf("%d%d", &n, &m);
S = 1;
T = n;
SS = n + 1;
TT = n + 2;
sz = TT;
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &u, &v, &c, &f);
adde(u, v, f, f, 0);
if (c < f) {
mic += f - c;
adde(v, u, 0, f - c, 0);
adde(v, u, 0, c, 1);
adde(u, v, 0, INF, 2);
} else {
adde(u, v, 0, c - f, 1);
adde(u, v, 0, INF, 2);
adde(v, u, 0, f, 1);
}
}
adde(T, S, 0, INF, 0);
for (i = 1; i <= n; i++) {
if (deg[i] > 0)
addedge(SS, i, deg[i], 0);
else if (deg[i] < 0)
addedge(i, TT, -deg[i], 0);
}
micflow();
printf("%lld\n", mic);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = INT_MAX;
int n;
long long a, b;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
int x, y;
char tp;
int val[8];
for (int i = 0; i < (8); i++) val[i] = inf;
char type[8];
for (int i = 0; i < (8); i++) type[i] = 'z';
for (int i = 0; i < (n); i++) {
cin >> tp >> x >> y;
if (x == a && y > b && val[0] > y - b) val[0] = y - b, type[0] = tp;
if (x - y == a - b && x > a && val[1] > x - a) val[1] = x - a, type[1] = tp;
if (y == b && x > a && val[2] > x - a) val[2] = x - a, type[2] = tp;
if (x + y == a + b && x > a && val[3] > x - a) val[3] = x - a, type[3] = tp;
if (x == a && y < b && val[4] > b - y) val[4] = b - y, type[4] = tp;
if (x - y == a - b && a > x && val[5] > a - x) val[5] = a - x, type[5] = tp;
if (y == b && a > x && val[6] > a - x) val[6] = a - x, type[6] = tp;
if (x + y == a + b && a > x && val[7] > a - x) val[7] = a - x, type[7] = tp;
}
bool flag = false;
for (int i = 0; i < (8); i++) {
if (i % 2 != 0 && (type[i] == 'Q' || type[i] == 'B')) flag = true;
if (i % 2 == 0 && (type[i] == 'Q' || type[i] == 'R')) flag = true;
}
if (flag)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct st {
int x, y;
} a[200005];
int b[200005];
int c[200005];
int d[200005];
int n, cnt;
bool cmp(st a, st b) { return a.y < b.y; }
int update(int pos, int v) {
for (int i = pos; i <= cnt; i += i & (-i)) {
b[i] += v;
}
return 0;
}
int query(int x) {
if (x == 0) return 0;
int ans = 0;
for (int i = x; i > 0; i -= i & (-i)) {
ans += b[i];
}
return ans;
}
int main() {
scanf("%d", &n);
set<int> s;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
s.insert(a[i].x);
}
map<int, int> mp;
for (auto x : s) {
c[++cnt] = x;
mp[x] = cnt;
}
for (int i = 1; i <= n; i++) {
d[mp[a[i].x]]++;
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= cnt; i++) {
update(i, 1);
}
long long ans = 0;
int now = 1;
while (now <= n) {
int k = a[now].y;
vector<int> v;
v.push_back(0);
v.push_back(cnt + 1);
while (now <= n && a[now].y == k) {
v.push_back(mp[a[now].x]);
now++;
}
sort(v.begin(), v.end());
long long x = query(cnt);
ans += x * (x + 1) / 2;
for (int i = 1; i < v.size(); i++) {
if (v[i] == v[i - 1]) continue;
long long x = query(v[i] - 1) - query(v[i - 1]);
assert(x >= 0);
ans -= x * (x + 1) / 2;
}
for (int i = 0; i < v.size(); i++) {
d[v[i]]--;
if (d[v[i]] == 0) update(v[i], -1);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T mabs(const T &a) {
return a < 0 ? -a : a;
}
void run() {
int n, m;
cin >> n >> m;
vector<int> inc[1001];
int A[1001];
pair<int, int> Cost[1001];
for (int i = (0), ei = (n); i < ei; i++) {
scanf("%d", A + i);
Cost[i].first = A[i];
Cost[i].second = i;
}
sort(Cost, Cost + n, greater<pair<int, int> >());
for (int i = (0), ei = (m); i < ei; i++) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
inc[a].push_back(b);
inc[b].push_back(a);
}
long long res = 0;
bool was[1001] = {0};
for (int i = (0), ei = (n); i < ei; i++) {
int v = Cost[i].second;
was[v] = 1;
for (int j = (0), ej = (inc[v].size()); j < ej; j++)
if (!was[inc[v][j]]) {
res += A[inc[v][j]];
}
}
cout << res << endl;
}
int main() {
run();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<pair<pair<long long, long long>, pair<long long, long long>>> a(n);
for (long long i = 0; i < n; ++i) {
long long x, y, z;
cin >> x >> y >> z;
a[i] = {{x, y}, {z, i + 1}};
}
vector<long long> used(n);
for (long long i = 0; i < n; ++i) {
if (!used[i]) {
used[i] = true;
long long ans = INF;
long long jj = 0;
for (long long j = 0; j < n; ++j) {
if (!used[j]) {
long long x1 = a[i].first.first;
long long x2 = a[j].first.first;
long long y1 = a[i].first.second;
long long y2 = a[j].first.second;
long long z1 = a[i].second.first;
long long z2 = a[j].second.first;
if (ans > (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) +
(z2 - z1) * (z2 - z1)) {
ans = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) +
(z2 - z1) * (z2 - z1);
jj = j;
}
}
}
cout << a[i].second.second << " " << a[jj].second.second << endl;
used[jj] = true;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
stack<int> s[n][2];
for (int i = 0; i < m; i++) s[(i % (n << 1)) >> 1][i & 1].push(i);
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++)
while (s[i][j].size()) printf("%d ", s[i][j].top() + 1), s[i][j].pop();
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void Function() {
vector<long long> v(7);
for (int i = 0; i < 7; i++) {
cin >> v[i];
}
long long a = v[0];
long long b = v[1];
long long c = v[2];
if (c == a + b) {
c = v[3];
}
cout << a << " " << b << " " << c << endl;
}
int main() {
long long t;
cin >> t;
while (t--) {
Function();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[110];
long long f[110][110][110][2];
char s[110];
long long dp(int l, int r, int k, int t) {
if (l > r) {
return a[k];
}
if (f[l][r][k][t] != -1) {
return f[l][r][k][t];
}
long long res = 0;
if (!k || t == s[l]) {
res = max(res, dp(l + 1, r, k + 1, s[l]));
}
for (int i = l; i < r; i++) {
res = max(res, dp(l, i, 0, '0') + dp(i + 1, r, k, t));
}
for (int i = 1; i <= k; i++) {
res = max(res, dp(l, r, k - i, t) + a[i]);
}
f[l][r][k][t] = res;
return res;
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
memset(f, -1, sizeof(f));
cout << dp(1, n, 0, '0') << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, dp[200001], exc[200001], pref[200001], suff[200001];
vector<int> graph[200001];
long long power(long long a, long long p) {
long long ans = 1;
for (; p; p /= 2, a = (a * a) % 1000000007)
if (p & 1) ans = (ans * a) % 1000000007;
return ans;
}
long long inv(const long long &a) { return power(a, 1000000007 - 2); }
void dfs(int cur, int pre, int op) {
if (op == 1) {
pref[0] = 1, suff[graph[cur].size()] = 1;
for (int i = 0; i < graph[cur].size(); i++) {
if (graph[cur][i] != pre)
pref[i + 1] = (pref[i] * (1 + dp[graph[cur][i]])) % 1000000007;
else
pref[i + 1] = pref[i];
}
for (int i = graph[cur].size() - 1; i >= 0; i--) {
if (graph[cur][i] != pre)
suff[i] = (suff[i + 1] * (1 + dp[graph[cur][i]])) % 1000000007;
else
suff[i] = suff[i + 1];
}
for (int i = 0; i < graph[cur].size(); i++) {
int j = graph[cur][i];
if (j != pre) {
exc[j] =
(((exc[cur] * pref[i]) % 1000000007 * suff[i + 1]) % 1000000007 +
1) %
1000000007;
dp[j] = (dp[j] * exc[j]) % 1000000007;
}
}
}
for (int i : graph[cur])
if (i != pre) {
dfs(i, cur, op);
if (op == 0) dp[cur] = (dp[cur] * (1 + dp[i])) % 1000000007;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1, p; i < n; i++) {
cin >> p, p--;
graph[i].push_back(p);
graph[p].push_back(i);
}
for (int i = 0; i < n; i++) dp[i] = 1;
exc[0] = 1;
dfs(0, 0, 0);
dfs(0, 0, 1);
for (int i = 0; i < n; i++) cout << dp[i] << (i == n - 1 ? "" : " ");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T maxi(T a, T b) {
if (a < b) {
return b;
}
return a;
}
int ciel(int a, int b) {
if (a % b == 0) return a / b;
return a / b + 1;
}
int main() {
int a, b, c, x, y, z;
cin >> a >> b >> c;
x = ciel(a, 2);
y = ciel(b, 2);
z = ciel(c, 2);
int max = maxi(maxi(x, y), z);
int time = 30 + max * 3 - 1;
if (z < y && y >= x)
time--;
else if (z < x && y < x)
time -= 2;
cout << time << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r1, r2, c1, c2, d1, d2;
cin >> r1 >> r2 >> c1 >> c2 >> d1 >> d2;
int a = (d1 + c1 - r2) / 2;
int b = (d2 + c2 - r2) / 2;
int c = c1 - a;
int d = c2 - b;
int x = 0;
if (a + b == r1) x++;
if (c + d == r2) x++;
if (a + c == c1) x++;
if (b + d == c2) x++;
if (a + d == d1) x++;
if (b + c == d2) x++;
int p = min({a, b, c, d});
int q = max({a, b, c, d});
if (p < 1 || q > 9) {
cout << "-1" << endl;
return 0;
}
if (x != 6 || a == b || b == c || c == d || d == a || a == c || b == d)
cout << "-1" << endl;
else {
cout << a << " " << b << endl;
cout << c << " " << d << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000004;
int ch[maxn][2];
int tot, n, a[maxn];
int dp[maxn];
void jia(int x) {
int nw = 0;
for (int i = 30; i >= 0; --i) {
int c = ch[nw][(x >> i) & 1];
if (!c) ch[nw][(x >> i) & 1] = ++tot;
nw = ch[nw][(x >> i) & 1];
}
dp[nw]++;
}
void dfs(int x) {
for (int i = 0; i < 2; ++i) {
if (ch[x][i]) dfs(ch[x][i]);
dp[x] = max(dp[x], dp[ch[x][i]]);
}
if (ch[x][1] != 0 && ch[x][0] != 0) dp[x]++;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), jia(a[i]);
dfs(0);
printf("%d\n", n - dp[0]);
}
| 3 |
#include <bits/stdc++.h>
const int N = 100005;
int l, r, suf1[N], suf2[N], pre1[N], pre2[N], n, m, Q;
char s[N], t[N];
int solve() {
scanf("%d%d", &l, &r);
int cnt1 = std::min(r - l + 1, suf1[r]), s1 = pre1[r] - pre1[l - 1];
scanf("%d%d", &l, &r);
int cnt2 = std::min(r - l + 1, suf2[r]), s2 = pre2[r] - pre2[l - 1];
if (s1 > s2) return 0;
if ((s2 - s1) & 1) return 0;
if (cnt1 < cnt2) return 0;
if (s1 == 0 && s2 && cnt1 == cnt2) return 0;
if (s1 == s2 && (cnt2 - cnt1) % 3) return 0;
return 1;
}
int main() {
scanf("%s", s + 1);
scanf("%s", t + 1);
n = strlen(s + 1), m = strlen(t + 1);
for (int i = 1; i <= n; i++)
if (s[i] == 'A') suf1[i] = suf1[i - 1] + 1;
for (int i = 1; i <= m; i++)
if (t[i] == 'A') suf2[i] = suf2[i - 1] + 1;
for (int i = 1; i <= n; i++) pre1[i] = pre1[i - 1] + (s[i] != 'A');
for (int i = 1; i <= m; i++) pre2[i] = pre2[i - 1] + (t[i] != 'A');
scanf("%d", &Q);
while (Q--) printf("%d", solve());
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long X;
vector<pair<int, long long> > ans;
void solve() {
cin >> X;
for (int n = 1; n < 1500000; ++n) {
long long n_ = X * 6 + 1LL * n * n * n - n;
long long _d = 3LL * n * (n + 1);
if (n_ % _d == 0 and 1LL * n <= n_ / _d) ans.push_back({n, n_ / _d});
}
int square_cnt = 0;
for (int i = 0; i < ans.size(); ++i)
if (ans[i].first == ans[i].second) ++square_cnt;
cout << ans.size() * 2 - square_cnt << "\n";
for (int i = 0; i < ans.size(); ++i)
cout << ans[i].first << " " << ans[i].second << "\n";
for (int i = ans.size() - 1; i >= 0; --i)
if (ans[i].first != ans[i].second)
cout << ans[i].second << " " << ans[i].first << "\n";
}
int main() {
ios::sync_with_stdio(false);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100010], b[100010];
int n, p, q;
double f(double x) {
double y = 1;
for (int i = 0; i < n; i++) y = min(y, ((double)1 - x * b[i]) / a[i]);
return y * p + x * q;
}
int main() {
scanf("%d%d%d", &n, &p, &q);
int maxx = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
maxx = max(maxx, b[i]);
}
double l = 0, r = (double)1 / maxx;
int t = 1000;
while (t--) {
double l2 = (2 * l + r) / 3, r2 = (2 * r + l) / 3;
if (f(l2) <= f(r2)) {
l = l2;
continue;
}
r = r2;
}
printf("%.10f\n", f((l + r) * 0.5));
return 0;
}
| 3 |
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <string>
#include <cmath>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
using namespace std;
#define int long long
int32_t main() {
int t;
cin >> t;
for (int count = 0; count < t; count++) {
int n;
cin >> n;
bool can = true;
int k = 0;
for (int i = 0; i < n; i++) {
int hi;
cin >> hi;
if (hi >= 0) {
k += hi - i;
}
else {
k -= i - hi;
}
can &= k >= 0;
}
cout << (can ? "YES" : "NO") << endl;
}
}
| 1 |
#include <bits/stdc++.h>
int d_, x_, y_;
void gcd_(int a, int b) {
if (b == 0)
d_ = a, x_ = 1, y_ = 0;
else {
int tmp;
gcd_(b, a % b);
tmp = x_ - a / b * y_, x_ = y_, y_ = tmp;
}
}
int inv(int a) {
gcd_(a, 1000000007);
if (x_ < 0) x_ += 1000000007;
return x_;
}
void wht(int *aa) {
int h, i;
for (h = 0; h < 17; h++)
for (i = 0; i < (1 << 17); i++)
if ((i & 1 << h) == 0) {
int j = i ^ 1 << h, u = aa[i], v = aa[j];
if ((aa[i] = u + v) >= 1000000007) aa[i] -= 1000000007;
if ((aa[j] = u - v) < 0) aa[j] += 1000000007;
}
}
int aa[(1 << 17)], can[(1 << 17)];
void mult(int *bb) {
int i;
wht(bb);
for (i = 0; i < (1 << 17); i++) aa[i] = (long long)aa[i] * bb[i] % 1000000007;
wht(can);
for (i = 0; i < (1 << 17); i++)
can[i] = (long long)can[i] * bb[i] % 1000000007;
wht(can);
for (i = 0; i < (1 << 17); i++)
if (can[i]) can[i] = 1;
}
int oo[1 + 100041 * 2], oh[1 + 100041 * 2];
int link(int o, int h) {
static int _ = 1;
oo[_] = o, oh[_] = h;
return _++;
}
int ij[100041], ww[100041];
int ae[100000], ff[100000], ta[100000];
void dfs(int f, int i) {
static int bb[(1 << 17)];
static int time;
int o;
ta[i] = ++time;
ff[i] = f;
for (o = ae[i]; o; o = oo[o]) {
int h = oh[o];
if (h != f) {
int j = i ^ ij[h];
if (!ta[j])
dfs(h, j);
else if (ta[j] < ta[i]) {
int i_ = i;
memset(bb, 0, sizeof bb);
bb[ww[h]]++;
while (i_ != j) {
h = ff[i_];
bb[ww[h]]++;
i_ ^= ij[h];
}
mult(bb);
}
}
}
}
int main() {
int n, m, h, x, y, y_;
long long v;
scanf("%d%d", &n, &m);
x = 0;
for (h = 0; h < m; h++) {
int i, j, w;
scanf("%d%d%d", &i, &j, &w), i--, j--;
ij[h] = i ^ j, ww[h] = w;
ae[i] = link(ae[i], h);
ae[j] = link(ae[j], h);
x ^= w;
}
aa[0] = 1, can[0] = 1;
wht(aa);
dfs(-1, 0);
wht(aa);
v = inv((1 << 17));
for (y = 0; y < (1 << 17); y++) aa[y] = aa[y] * v % 1000000007;
y_ = 0;
for (y = 1; y < (1 << 17); y++)
if (can[y] && (y_ ^ x) > (y ^ x)) y_ = y;
printf("%d %d\n", y_ ^ x, aa[y_]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
double a[100010];
struct SEG_Tree {
struct SEG {
int l;
int r;
double lazy2;
double sum;
double lazy;
} t[800010];
void push_down(int cur) {
if (t[cur].lazy2 != 1) {
t[((cur) << 1)].lazy2 *= t[cur].lazy2;
t[((cur) << 1 | 1)].lazy2 *= t[cur].lazy2;
t[((cur) << 1)].lazy *= t[cur].lazy2;
t[((cur) << 1 | 1)].lazy *= t[cur].lazy2;
t[((cur) << 1)].sum *= t[cur].lazy2;
t[((cur) << 1 | 1)].sum *= t[cur].lazy2;
t[cur].lazy2 = 1;
}
t[((cur) << 1)].sum +=
t[cur].lazy * (double)(t[((cur) << 1)].r - t[((cur) << 1)].l + 1);
t[((cur) << 1 | 1)].sum +=
t[cur].lazy *
(double)(t[((cur) << 1 | 1)].r - t[((cur) << 1 | 1)].l + 1);
t[((cur) << 1)].lazy += t[cur].lazy;
t[((cur) << 1 | 1)].lazy += t[cur].lazy;
t[cur].lazy = 0;
}
void push_up(int cur) {
t[cur].sum = t[((cur) << 1)].sum + t[((cur) << 1 | 1)].sum;
}
void build(int cur, int l, int r) {
t[cur].l = l;
t[cur].r = r;
t[cur].lazy = 0;
t[cur].lazy2 = 1;
if (l == r) {
t[cur].sum = a[l];
return;
}
int mid = (l + r) >> 1;
build(((cur) << 1), l, mid);
build(((cur) << 1 | 1), mid + 1, r);
push_up(cur);
}
void clear(int cur, int l, int r, double c) {
if (t[cur].l > r || t[cur].r < l) return;
push_down(cur);
if (t[cur].l >= l && t[cur].r <= r) {
t[cur].lazy2 *= c;
t[cur].lazy *= c;
t[cur].sum *= c;
return;
}
clear(((cur) << 1), l, r, c);
clear(((cur) << 1 | 1), l, r, c);
push_up(cur);
}
void modify(int cur, int l, int r, double c) {
if (t[cur].l > r || t[cur].r < l) return;
push_down(cur);
if (t[cur].l >= l && t[cur].r <= r) {
t[cur].lazy += c;
t[cur].sum += (double)(t[cur].r - t[cur].l + 1) * c;
return;
}
modify(((cur) << 1), l, r, c);
modify(((cur) << 1 | 1), l, r, c);
push_up(cur);
}
double query(int cur, int l, int r) {
if (t[cur].l > r || t[cur].r < l) return 0;
push_down(cur);
if (t[cur].l >= l && t[cur].r <= r) return t[cur].sum;
return query(((cur) << 1), l, r) + query(((cur) << 1 | 1), l, r);
}
} t;
int main() {
int n = inp();
int m = inp();
for (int i = 1; i <= n; i++) a[i] = inp();
t.build(1, 1, n);
for (int i = 1; i <= m; i++) {
int op = inp();
if (op == 1) {
int l1 = inp();
int r1 = inp();
int l2 = inp();
int r2 = inp();
double sum1 = t.query(1, l1, r1);
double sum2 = t.query(1, l2, r2);
sum1 /= (double)(r1 - l1 + 1);
sum2 /= (double)(r2 - l2 + 1);
t.clear(1, l1, r1, (double)(r1 - l1) / (double)(r1 - l1 + 1));
t.modify(1, l1, r1, sum2 / (double)(r1 - l1 + 1));
t.clear(1, l2, r2, (double)(r2 - l2) / (double)(r2 - l2 + 1));
t.modify(1, l2, r2, sum1 / (double)(r2 - l2 + 1));
} else {
int l = inp();
int r = inp();
printf("%.7lf\n", t.query(1, l, r));
}
}
}
| 5 |
#include <iostream>
using namespace std;
int main() {
int a,b;
cin >> a >>b;
if(a<=8 && b<=8){
printf("Yay!");
}else{
printf(":(");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, T;
int main() {
cin >> n >> m;
while (n != 0) {
n--;
T++;
if (T % m == 0) n++;
}
cout << T;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<pair<long long, long long> > v[100005];
for (long i = 1; i <= 100000; i++) {
long long suma = i;
long long ind = i + 1;
while (suma + ind <= 100000) {
suma += ind;
v[suma].push_back(make_pair(i, ind));
ind++;
}
}
vector<long long> g(100005);
g[0] = 0;
for (long long i = 0; i < 100001; i++) {
vector<long long> p;
if (v[i].size() == 0)
g[i] = g[i - 1];
else {
for (long long j = 0; j < v[i].size(); j++)
p.push_back(g[v[i][j].second] ^ g[v[i][j].first - 1]);
sort(p.begin(), p.end());
if (p[0] != 0)
g[i] = g[i - 1];
else {
long long ans = 0;
for (long long i = 1; i < p.size(); i++) {
if (p[i] - p[i - 1] <= 1)
ans = p[i];
else
break;
}
g[i] = (ans + 1) ^ g[i - 1];
}
}
}
long long ans = 1e15;
for (long long i = 0; i < v[n].size(); i++) {
long long aux = g[v[n][i].second] ^ g[v[n][i].first - 1];
if (aux == 0) ans = min(ans, v[n][i].second - v[n][i].first + 1);
}
if (ans < 1e14)
cout << ans << endl;
else
cout << "-1" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long power(long long a, long long b) {
if (b == 0) return 1;
long long res = power(a, b / 2);
long long ans = res * res;
ans %= mod;
if (b % 2 == 0) return ans;
return (a * ans) % mod;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
stack<char> p;
int ans = 0;
for (int i = 0; i < s.size(); i++) {
if (!p.empty() && p.top() == s[i]) {
p.pop();
ans++;
} else {
p.push(s[i]);
}
}
if (ans % 2)
cout << "Yes"
<< "\n";
else {
cout << "No"
<< "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, m, n) for (int i = m; i < n; ++i)
#define mod 1000000007
template<class T> void add(T &a, T b) {a = (a + b) % mod;}
int dp[101][4][4][4];
int main() {
int N; cin >> N;
int A = 0, C = 1, G = 2, T = 3;
dp[0][T][T][T] = 1;
rep(i, 0, N) rep(j, 0, 4) rep(k, 0, 4) rep(l, 0, 4) rep(m, 0, 4) {
if(dp[i][j][k][l] == 0) continue;
if(k == A && l == G && m == C) continue;
if(k == A && l == C && m == G) continue;
if(k == G && l == A && m == C) continue;
if(j == A && k == G && m == C) continue;
if(j == A && l == G && m == C) continue;
add(dp[i + 1][k][l][m], dp[i][j][k][l]);
}
int ans = 0;
rep(i, 0, 4) rep(j, 0, 4) rep(k, 0, 4) {
add(ans, dp[N][i][j][k]);
}
cout << ans << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int n,ans,a[10001],tmp;
int right(int p,int cr){
int r=p,x=1;
while(r+1<n&&a[r+1]==cr)r++,x++;
if(x>=4) return 1;
else return 0;
}
int left(int p,int cl){
int l=p,x=1;
while(l-1>=0&&a[l-1]==cl)l--,x++;
if(x>=4) return 1;
else return 0;
}
int mid(int pl,int pr,int cl,int cr){
int l=pl,r=pr,x=2;
if(pl==pr)x--;
while(l-1>=0&&a[l-1]==cl)l--,x++;
while(r+1<n&&a[r+1]==cr)r++,x++;
if(x>=4) return 1;
else return 0;
}
int ch(int p){
int l=p,r=p,c=1;
while(1){
if(l<0&&r>=n||!c)break;
c=0;
int pl=a[l],pr=a[r];
if(l>=0&&r<n&&a[l]==a[r]){
if(mid(l,r,a[l],a[r])){
while(l-1>=0&&a[l-1]==pl)l--,c++;
while(r+1<n&&a[r+1]==pr)r++,c++;
l--;r++;
}
}
else if(r>=n){
if(left(l,a[l])){
while(l-1>=0&&a[l-1]==pl)l--,c++;
l--;
}
}
else if(l<0){
if(right(r,a[r])){
while(r+1<n&&a[r+1]==pr)r++,c++;
r++;
}
}
}
return abs(l+1-0)+abs(n-r);
}
int main(){
while(cin>>n,n){
ans=114514;
r(i,n)cin>>a[i];
r(i,n)r(j,3){
tmp=a[i];
a[i]=j+1;
ans=min(ans,ch(i));
a[i]=tmp;
}
cout<<min(ans,n)<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
set<int> myset;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int v[n];
for (int i = 0; i < n; i++) scanf("%d", &v[i]);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
myset.insert(x);
}
set<int>::iterator it;
for (int i = 0; i < n; i++) {
it = myset.find(v[i]);
if (it != myset.end()) printf("%d ", v[i]);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
std::ostream &out = std::cout;
std::istream &in = std::cin;
void rint(int &i) { in >> i; }
template <class... Ts>
void rint(int &i, Ts &...args) {
in >> i;
rint(args...);
}
using uint = unsigned;
using namespace std;
using I = int64_t;
using UI = uint64_t;
using szt = size_t;
int main() {
ios_base::sync_with_stdio(0);
in.tie(0);
constexpr int N = (int)3e5 + 1;
constexpr int q = (int)1e9 + 7;
int a[N], b[N];
char t[N];
string s;
int n;
rint(n);
s.reserve(n);
in >> s;
a[0] = s[0] == '(' ? 1 : -1;
int mi = a[0], mii = 0;
for (int h = 1; h < n; ++h) {
a[h] = a[h - 1] + (s[h] == '(' ? 1 : -1);
if (a[h] < mi) {
mi = a[h];
mii = h;
}
}
if (a[n - 1]) {
out << "0\n1 1";
return 0;
};
++mii;
memcpy(t, s.data() + mii, n - mii);
memcpy(t + n - mii, s.data(), mii);
memcpy(b, a + mii, sizeof(int) * (n - mii));
memcpy(b + n - mii, a, sizeof(int) * mii);
vector<int> zs{-1};
for (int i = 0; i < n; ++i) {
b[i] -= mi;
if (!b[i]) zs.push_back(i);
}
int be = zs.size() - 1, w = 0, v = 0;
vector<vector<int>> oss(zs.size() - 1);
for (szt i = 1; i < zs.size(); ++i) {
int cu = 0;
for (int j = zs[i - 1] + 1; j < zs[i]; ++j) {
if (b[j] == 1) {
cu += 1;
oss[i - 1].push_back(j);
}
}
if (cu > be) {
be = cu;
w = zs[i - 1] + 1;
v = zs[i];
}
}
for (auto &os : oss) {
for (szt i = 1; i < os.size(); ++i) {
int cu = zs.size() - 1;
for (int j = os[i - 1] + 1; j < os[i]; ++j) cu += b[j] == 2;
if (cu > be) {
be = cu;
w = os[i - 1] + 1;
v = os[i];
}
}
}
out << be << '\n' << (w + mii) % n + 1 << ' ' << (v + mii) % n + 1;
}
| 2 |
#include<iostream>
using namespace std;
int n,a,b;
int main()
{
cin>>n>>a>>b;
if(a-b&1)
printf("Borys\n");
else
printf("Alice\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 4 == 0 or n % 7 == 0 or n % 44 == 0 or n % 47 == 0 or n % 444 == 0 or
n % 447 == 0 or n % 474 == 0 or n % 477 == 0 or n % 77 == 0 or
n % 74 == 0 or n % 777 == 0 or n % 774 == 0 or n % 747 == 0 or
n % 744 == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 0;
char c;
while (scanf("%c", &c) != EOF)
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
(c <= '9' && c % 2 == 1))
a++;
printf("%d", a);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAX = 100002;
const double EPS = 1e-7;
const double PI = acos(-1.0);
const int MOD = 1000000007;
using ull = unsigned long long;
using ll = long long;
int main() {
ll n, m, k, answer = 0, previous_page, number_of_elements = 1, element,
shift = 0;
cin >> n >> m >> k >> element;
--element;
--m;
previous_page = element / k;
while (m--) {
cin >> element;
--element;
if ((element - shift) / k != previous_page) {
++answer;
shift = number_of_elements;
previous_page = (element - shift) / k;
}
++number_of_elements;
}
cout << answer + 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
struct num {
int x[N], sz;
friend istream &operator>>(istream &get, num &n) {
string s;
get >> s, n.sz = s.size();
for (int i = 0; i < n.sz; i++)
n.x[n.sz - i - 1] = (s[i] ^ '?' ? s[i] - '0' : -1);
return get;
}
} a, b[N];
int n, m, c[10], id[N], dp[N][N];
int main() {
cin >> a >> n, m = a.sz + 1;
for (int i = 0; i < n; i++) {
cin >> b[id[i] = i];
m = max(m, b[i].sz + 1);
}
for (int i = 0; i < 10; i++) cin >> c[i];
memset(dp, -63, sizeof dp);
for (int p = dp[0][0] = 0; p < m; p++) {
for (int r = 9, l = (~a.x[p] ? r = a.x[p] : p + 1 >= a.sz), k = l; k <= r;
k++) {
int ten = 0, cost = 0;
for (int i = 0; i < n; i++) {
int w = b[i].x[p] + k;
cost += max(a.sz, b[i].sz) > p || w ? c[w % 10] : 0, ten += w > 9;
}
for (int i = 0; i <= n; i++) {
int w = b[id[i]].x[p] + k;
dp[p + 1][ten] = max(dp[p + 1][ten], dp[p][i] + cost);
cost +=
c[(w + 1) % 10] - (max(a.sz, b[id[i]].sz) > p || w ? c[w % 10] : 0),
ten += w < 9 ? 0 : w == 9;
}
}
stable_sort(id, id + n,
[p](int i, int j) { return b[i].x[p] > b[j].x[p]; });
}
cout << dp[m][0];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int yee[6][3] = {{0, 1, 2}, {1, 0, 2}, {1, 2, 0},
{2, 1, 0}, {2, 0, 1}, {0, 2, 1}};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, x;
cin >> n >> x;
n %= 6;
cout << yee[n][x] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10, P = 1000000007;
struct Rob {
int c, f, l;
bool operator<(Rob b) const { return f < b.f; }
} a[N];
int main() {
int n, d, F;
scanf("%d%d%d", &n, &d, &F);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &a[i].c, &a[i].f, &a[i].l);
}
sort(a, a + n);
long long ans = 0, tf = 0;
for (int i = 0; i < n; i++) {
if (a[i].l >= d) {
if (a[i].f + tf > F) break;
tf += a[i].f;
ans++;
}
}
long long ans1 = 0, tf1 = 0;
for (int st = 0; st < n; st++) {
if (a[st].c && a[st].l >= d && a[st].f <= F) {
ans1 = 1;
tf1 = a[st].f;
long long ext = a[st].c;
for (int i = 0; i < n; i++)
if (i != st) {
if (a[i].c) ext += a[i].c - 1, ans1++;
}
for (int i = 0; i < n; i++)
if (i != st) {
if (a[i].l < d) continue;
if (a[i].f + tf1 > F) break;
if (n - ans1 <= ext) break;
tf1 += a[i].f;
ans1++;
}
ans1 += min(ext, n - ans1);
if (ans1 > ans || (ans1 == ans && tf1 < tf)) {
ans = ans1;
tf = tf1;
}
break;
}
}
printf("%I64d %I64d\n", ans, tf);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[6];
vector<pair<int, int> > to[10];
bool go(long long n) {
if (n < 0) {
return false;
} else if (n == 0) {
memset(a, 0, sizeof(a));
return true;
}
int d = n % 10;
for (int i = 0; i < (int)to[d].size(); ++i) {
if (go((n - to[d][i].first * 4 - to[d][i].second * 7) / 10)) {
int cnt4 = to[d][i].first;
int cnt7 = to[d][i].second;
for (int j = 0; j < 6; ++j) {
a[j] = a[j] * 10LL;
if (cnt4-- > 0) {
a[j] += 4LL;
} else if (cnt7-- > 0) {
a[j] += 7LL;
}
}
return true;
}
}
return false;
}
int main() {
for (int i = 0; i < 10; i++) {
for (int j = 0; j <= 6; ++j) {
for (int k = 0; k <= 6 - j; ++k) {
if ((j * 4 + k * 7) % 10 == i) {
to[i].push_back(make_pair(j, k));
}
}
};
for (int j = 0; j < (int)to[i].size(); ++j) {
;
}
}
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (go(n)) {
for (int i = 0; i < 6; ++i) {
cout << a[i] << " ";
}
cout << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long dp[2001][2] = {};
int main() {
long long n, h;
cin >> n >> h;
vector<long long> a(n + 1);
a[0] = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] = h - a[i];
}
if (a[n] > 1) {
cout << 0 << endl;
return 0;
}
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
if (a[i] == a[i - 1]) dp[i][0] = (dp[i - 1][0] + dp[i - 1][1]) % mod;
if (a[i] == a[i - 1] + 1) dp[i][0] = dp[i - 1][0];
if (a[i] == a[i - 1] - 1) dp[i][0] = dp[i - 1][1];
dp[i][1] = (dp[i][0] * a[i]) % mod;
}
cout << dp[n][0] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int row[1010], col[1010];
int rec[1010][1010];
int swaprow(int a, int b) {
int tmp;
tmp = row[a];
row[a] = row[b];
row[b] = tmp;
return 0;
}
int swapcol(int a, int b) {
int tmp;
tmp = col[a];
col[a] = col[b];
col[b] = tmp;
return 0;
}
int main() {
char ch;
int tmp1, tmp2, i, j;
while (~scanf("%d%d%d", &n, &m, &k)) {
for (i = 1; i <= n; i++) row[i] = i;
for (i = 1; i <= m; i++) col[i] = i;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &rec[i][j]);
for (i = 1; i <= k; i++) {
getchar();
scanf("%c %d %d", &ch, &tmp1, &tmp2);
if (ch == 'r') swaprow(tmp1, tmp2);
if (ch == 'c') swapcol(tmp1, tmp2);
if (ch == 'g') printf("%d\n", rec[row[tmp1]][col[tmp2]]);
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
cout<<(n%2==0?n:n*2)<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
const long long INF = 1e18;
int n, m, s, t;
long long d[2][N];
class TShortestPathGraph {
struct TEdge {
int v, c;
};
vector<TEdge> g[N];
struct TVertex {
int u;
long long d;
bool operator<(const TVertex &b) const { return d > b.d; }
};
inline bool Minimize(long long &a, long long b) {
if (a <= b) return false;
a = b;
return true;
}
public:
void AddEdge(int u, int v, int c) { g[u].push_back({v, c}); }
void Run(int s, long long d[]) {
fill(d + 1, d + 1 + n, INF);
priority_queue<TVertex> pq;
pq.push({s, 0}), d[s] = 0;
while (!pq.empty()) {
auto top = pq.top();
pq.pop();
int u = top.u;
if (top.d > d[u]) continue;
for (auto e : g[u])
if (Minimize(d[e.v], d[u] + e.c)) pq.push({e.v, d[e.v]});
}
}
} g1, g2;
namespace tar {
struct TEdge {
int v, id;
};
vector<TEdge> g[N];
int low[N], num[N], tme = 0;
bool bridge[N];
void AddEdge(int u, int v, int id) {
g[u].push_back({v, id});
g[v].push_back({u, id});
}
void Dfs(int u, int pre) {
low[u] = num[u] = ++tme;
for (auto e : g[u]) {
int v = e.v;
if (e.id == pre) continue;
if (!num[v]) {
Dfs(v, e.id), low[u] = min(low[u], low[v]);
if (low[v] >= num[v]) bridge[e.id] = true;
} else
low[u] = min(low[u], num[v]);
}
}
} // namespace tar
struct TEdge {
int u, v, c;
};
int main() {
scanf("%d %d %d %d", &n, &m, &s, &t);
vector<TEdge> el;
while (m--) {
int u, v, c;
scanf("%d %d %d", &u, &v, &c);
el.push_back({u, v, c});
g1.AddEdge(u, v, c);
g2.AddEdge(v, u, c);
}
g1.Run(s, d[0]);
g2.Run(t, d[1]);
for (auto it = el.begin(); it != el.end(); ++it)
if (d[0][it->u] + it->c + d[1][it->v] == d[0][t])
tar::AddEdge(it->u, it->v, it - el.begin());
tar::Dfs(s, -1);
for (auto it = el.begin(); it != el.end(); ++it) {
int id = it - el.begin();
if (tar::bridge[id])
printf("YES\n");
else {
long long amt = d[0][it->u] + it->c + d[1][it->v] - d[0][t] + 1;
if ((long long)it->c - amt > 0)
printf("CAN %lld\n", amt);
else
printf("NO\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
pair<int, int> a[maxn], b[maxn];
bool check(pair<int, int> &x, pair<int, int> &y) {
return (x.first == y.first && x.second == y.second) ||
(x.second == y.first && x.first == y.second);
}
int ok(pair<int, int> &x, pair<int, int> &y) {
if (x.first == y.first) return x.first;
if (x.second == y.second) return x.second;
if (x.first == y.second) return x.first;
if (x.second == y.first) return x.second;
return 0;
}
int vis[maxn];
int main() {
int n, m, f, t;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].first, &a[i].second);
for (int i = 1; i <= m; i++) scanf("%d%d", &b[i].first, &b[i].second);
for (int i = 1; i <= n; i++) {
f = 0;
for (int j = 1; j <= m; j++) {
if (check(a[i], b[j])) continue;
t = ok(a[i], b[j]);
if (t == 0) continue;
if (f && f != t)
f = -1;
else
f = t;
}
if (f == -1) return puts("-1"), 0;
if (f) vis[f] = 1;
}
for (int i = 1; i <= m; i++) {
f = 0;
for (int j = 1; j <= n; j++) {
if (check(b[i], a[j])) continue;
t = ok(b[i], a[j]);
if (t == 0) continue;
if (f && f != t)
f = -1;
else
f = t;
}
if (f == -1) return puts("-1"), 0;
if (f) vis[f] = 1;
}
int res = -1;
for (int i = 1; i <= 9; i++)
if (vis[i]) {
if (res != -1)
res = 0;
else
res = i;
}
printf("%d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d = 0, x = 1;
cin >> n >> a >> b >> c;
for (--n; n; --n) {
if (x == 1) {
if (a < b) {
d += a;
x = 2;
} else {
d += b;
x = 3;
}
} else if (x == 2) {
if (a < c) {
d += a;
x = 1;
} else {
d += c;
x = 3;
}
} else if (x == 3) {
if (b < c) {
d += b;
x = 1;
} else {
d += c;
x = 2;
}
}
}
cout << d;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
vector<vector<int>> dishes(n, vector<int>(2));
for (int i = 0; i < n; i++)cin >> dishes[i][0] >> dishes[i][1];
sort(dishes.begin(), dishes.end());
vector<int> dp(6010, -1145141919);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = t - 1; j >= 0; j--) {
dp[j + dishes[i][0]] = max(dp[j + dishes[i][0]], dp[j] + dishes[i][1]);
}
}
int ret = 0;
for (auto x:dp)ret = max(ret, x);
cout << ret << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, i, j, d, h;
cin >> n >> d >> h;
long long temp = d;
vector<pair<long long, long long>> ans;
if (d < h) {
cout << -1;
return 0;
} else if (2 * h < d) {
cout << -1;
return 0;
}
long long k = 2;
for (i = 0; i < h; i++) {
ans.push_back({i + 1, i + 2});
}
k = h + 2;
long long prev = 1;
d -= h;
while (d--) {
ans.push_back({prev, k});
prev = k;
k++;
}
long long x = 1;
if (h == temp) {
if (n >= 3 && h == 1) {
cout << -1 << endl;
return 0;
}
x = 2;
}
n -= ans.size() + 1;
while (n--) {
ans.push_back({x, k});
k++;
}
for (auto x : ans) {
cout << x.first << " " << x.second << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int flg = 1;
long long int mx(long long int a[], long long int size, long long int ys) {
long long int max_so_far = -(1e16), max_ending_here = 0, start = 0, end = 0,
s = 0;
for (long long int i = 1; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0) {
max_ending_here = 0;
s = i + 1;
}
}
long long int mx = max_so_far;
max_so_far = -(1e16), max_ending_here = 0, start = 0, end = 0, s = 0;
for (long long int i = 0; i < size - 1; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0) {
max_ending_here = 0;
s = i + 1;
}
}
return max(mx, max_so_far);
}
void solve() {
long long int n;
cin >> n;
long long int a[n];
long long int kk = 0;
long long int flg = 1;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
kk += a[i];
}
long long int k = mx(a, n, kk);
if (k < kk)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main() {
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
using namespace std;
int main(){
int a,b;
while(cin>>a>>b)
cout<<(int)log10(a+b)+1<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200003;
int n, a[N], sum[N];
int main() {
bool flag = false;
scanf("%d", &n);
++n;
for (register int i = 1; i <= n; i++)
scanf("%d", a + i), flag |= (a[i] >= 2 && a[i - 1] >= 2),
sum[i] = sum[i - 1] + a[i];
if (flag) {
puts("ambiguous");
printf("0");
for (register int i = 2; i <= n; i++)
for (register int j = 1; j <= a[i]; j++) printf(" %d", sum[i - 1]);
printf("\n0");
for (register int i = 2; i <= n; i++)
for (register int j = 0; j < a[i]; j++)
if (a[i] >= 2 && a[i - 1] >= 2)
printf(" %d", max(sum[i - 1] - j, sum[i - 2] + 1));
else
printf(" %d", sum[i - 1]);
} else
puts("perfect");
}
| 1 |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
template<int MOD> struct ModInt {
static const int Mod = MOD; unsigned x; ModInt() : x(0) { }
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) { if ((x += that.x) >= MOD) x -= MOD; return *this; }
ModInt &operator-=(ModInt that) { if ((x += MOD - that.x) >= MOD) x -= MOD; return *this; }
ModInt &operator*=(ModInt that) { x = (unsigned long long)x * that.x % MOD; return *this; }
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const { long long a = x, b = MOD, u = 1, v = 0;
while (b) { long long t = a / b; a -= t * b; std::swap(a, b); u -= t * v; std::swap(u, v); }
return ModInt(u); }
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const { ModInt t; t.x = x == 0 ? 0 : Mod - x; return t; }
};
template<int MOD> ostream& operator<<(ostream& st, const ModInt<MOD> a) { st << a.get(); return st; };
template<int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1; while (k) { if (k & 1) r *= a; a *= a; k >>= 1; } return r; }
template<typename T, int FAC_MAX> struct Comb { vector<T> fac, ifac;
Comb() {fac.resize(FAC_MAX, 1); ifac.resize(FAC_MAX, 1);rep(i, 1, FAC_MAX) fac[i] = fac[i - 1] * i;
rep(i, 1, FAC_MAX) ifac[i] = T(1) / fac[i];}
T aPb(int a, int b) { if (b < 0 || a < b) return T(0); return fac[a] * ifac[a - b]; }
T aCb(int a, int b) { if (b < 0 || a < b) return T(0); return fac[a] * ifac[a - b] * ifac[b]; }
T nHk(int n, int k) { if (n == 0 && k == 0) return T(1); if (n <= 0 || k < 0) return 0;
return aCb(n + k - 1, k); }}; // nHk = (n+k-1)Ck
typedef ModInt<1000000007> mint;
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
int N, M, K;
Comb<mint, 301010> com;
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> N >> M >> K;
mint ans = 0;
rep(x, 0, K + 1) {
int y = K - x;
mint co = com.aCb(N + M + K * 2, N + x * 2);
mint w = com.aCb(N + x * 2, x) - com.aCb(N + x * 2, x - 1);
mint h = com.aCb(M + y * 2, y) - com.aCb(M + y * 2, y - 1);
ans += co * h * w;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int get(vector<long long int> &arr, long long int ind,
long long int n) {
long long int ans = 0;
for (; ind > 0; ind -= (ind & (-ind))) ans += arr[ind];
return ans;
}
void upd(vector<long long int> &arr, long long int ind, long long int x,
long long int n) {
for (; ind <= n; ind += (ind & (-ind))) arr[ind] += x;
}
int main() {
long long int n;
cin >> n;
pair<long long int, long long int> arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i].first;
for (long long int i = 0; i < n; i++) cin >> arr[i].second;
vector<int> vec(n);
for (long long int i = 0; i < n; i++) vec.push_back(arr[i].second);
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
vector<long long int> cnt(vec.size() + 1), cs(vec.size() + 1);
sort(arr, arr + n);
long long int ans = 0;
long long int n1 = vec.size();
for (long long int i = 0; i < n; i++) {
long long int pos =
lower_bound(vec.begin(), vec.end(), arr[i].second) - vec.begin();
ans += get(cnt, pos + 1, n1) * arr[i].first - get(cs, pos + 1, n1);
upd(cnt, pos + 1, 1, n1);
upd(cs, pos + 1, arr[i].first, n1);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n /= 1000;
if (n == 6 || n == 11)
cout << 3 << endl;
else if (n == 8 || n == 9)
cout << 2 << endl;
else
cout << 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
long long n, m, i, j;
cin >> n >> m;
vector<vector<long long> > ans;
map<long long, pair<long long, long long> > mp;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
long long temp;
cin >> temp;
mp[temp].second = j;
}
}
for (j = 0; j < m; j++) {
for (i = 0; i < n; i++) {
long long temp;
cin >> temp;
mp[temp].first = i;
}
}
vector<long long> a(m, 0);
for (i = 0; i < n; i++) ans.push_back(a);
for (i = 1; i <= (m * n); i++) ans[mp[i].first][mp[i].second] = i;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) cout << ans[i][j] << " ";
cout << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500;
const long long INF = 1e14;
int n, K, x, a[maxn];
long long dp[maxn][maxn];
int main() {
scanf("%d%d%d", &n, &K, &x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < maxn; i++) {
for (int j = 0; j < maxn; j++) {
dp[i][j] = -INF;
}
}
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i && j <= x; j++) {
for (int k = max(i - K, 0); k < i; k++) {
dp[i][j] = max(dp[i][j], dp[k][j - 1] + a[i]);
}
}
}
long long ans = -INF;
for (int i = n - K + 1; i <= n; i++) {
ans = max(ans, dp[i][x]);
}
if (ans < 0)
printf("-1\n");
else
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while ('0' > ch || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const int mod = (1e9) + 7;
const int maxn = (1e6) + 5;
int n, dp[maxn][21][3];
int m2[21], m3[3];
int f(int x, int y) { return n / (m2[x] * m3[y]); }
void add(int &d, int x, int y) {
d += (long long)x * y % mod;
if (d >= mod) d -= mod;
}
int main() {
read(n);
int cnt = 0;
while ((1 << cnt) <= n) cnt++;
cnt--;
for (int i = 0; i <= cnt; i++) m2[i] = 1 << i;
m3[0] = 1;
m3[1] = 3;
dp[1][cnt][0] = 1;
if (f(cnt - 1, 1)) dp[1][cnt - 1][1] = 1;
for (int i = 1; i <= n; i++) {
for (int x = 0; x <= cnt; x++)
for (int y = 0; y <= 1; y++) {
add(dp[i + 1][x][y], dp[i][x][y], f(x, y) - i);
if (x) add(dp[i + 1][x - 1][y], dp[i][x][y], f(x - 1, y) - f(x, y));
if (y) add(dp[i + 1][x][y - 1], dp[i][x][y], f(x, y - 1) - f(x, y));
}
}
printf("%d\n", dp[n][0][0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
#define repb(i,a,b) for(int i=a;i>=b;i--)
#define all(a) a.begin(),a.end()
#define o(a) cout<<a<<endl
#define int long long
#define fi first
#define se second
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
int dp[110][3][2];
int num[110];
signed main(){
int n,k;
cin>>n>>k;
memset(num,-1,sizeof(num));
rep(i,0,k){
int a,b;
cin>>a>>b;
a--; b--;
num[a]=b;
}
if(num[0]==-1) rep(i,0,3) dp[0][i][0]=1;
else dp[0][num[0]][0]=1;
rep(i,1,n){
rep(j,0,3){
if(!(num[i]==-1||num[i]==j)) continue;
dp[i][j][1]=(dp[i][j][1]+dp[i-1][j][0])%10000;
rep(k,0,3){
if(j==k) continue;
dp[i][j][0]=(dp[i][j][0]+dp[i-1][k][0]+dp[i-1][k][1])%10000;
}
}
}
int ans=0;
rep(i,0,3) rep(j,0,2) ans+=dp[n-1][i][j];
o(ans%10000);
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:536870912")
#pragma warning(disable : 4996)
using namespace std;
const int N = 105, mod = 1e9 + 7;
long long int dp[N][N], g[N];
vector<int> v[N];
int n, k;
void sum(long long int &a, long long int b) { a = (a + b) % mod; }
long long int t[2][N][N];
void dfs(int node, int anc) {
bool leaf = true;
for (int to : v[node]) {
if (to != anc) {
dfs(to, node);
leaf = false;
}
}
if (leaf)
dp[node][k + 1] = dp[node][0] = 1;
else {
memset(t, 0, sizeof(t));
;
t[0][k + 1][0] = 1;
int c = 1;
for (int to : v[node]) {
if (to == anc) continue;
memset(t[c], 0, sizeof(t[c]));
;
for (int i = 0; i <= k; i++) {
for (int j = 1; j <= k + 1; j++) {
for (int h = 0; h <= k; h++) {
sum(t[c][min(i + 1, j)][h], t[1 - c][j][h] * dp[to][i]);
}
}
}
for (int i = k + 1; i <= k + k; i++) {
for (int j = 1; j <= k + 1; j++) {
for (int h = 0; h <= k; h++) {
sum(t[c][j][max(h, i - k)], t[1 - c][j][h] * dp[to][i]);
}
}
}
c ^= 1;
}
c ^= 1;
for (int i = 1; i <= k + 1; i++) {
for (int j = 0; j <= k; j++) {
if (i + j <= k)
sum(dp[node][i], t[c][i][j]);
else
sum(dp[node][j + k + 1], t[c][i][j]);
sum(dp[node][0], t[c][i][j]);
}
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
v[a].push_back(b);
v[b].push_back(a);
}
dfs(0, -1);
long long int ans = 0;
for (int i = 0; i <= k; i++) sum(ans, dp[0][i]);
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char grid[505][505];
bool vis[505][505];
int n, m, k, s, c;
int dr[] = {0, -1, 0, 1};
int dc[] = {-1, 0, 1, 0};
void dfs(int x, int y) {
if (x < 0 || x == n || y < 0 || y == m || grid[x][y] == '#' || vis[x][y] ||
c == s - k)
return;
vis[x][y] = true;
grid[x][y] = '.';
c++;
for (int i = (0); i <= (3); i++) dfs(x + dr[i], y + dc[i]);
}
void solve() {
cin >> n >> m >> k;
for (int i = (0); i <= (n - 1); i++)
for (int j = (0); j <= (m - 1); j++) {
cin >> grid[i][j];
s += grid[i][j] == '.';
if (grid[i][j] == '.') grid[i][j] = 'X';
}
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) {
if (grid[i][j] == 'X') {
dfs(i, j);
i = n;
break;
}
}
}
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) cout << grid[i][j];
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(8);
clock_t b = clock();
solve();
clock_t e = clock();
cerr << (double(e - b) / CLOCKS_PER_SEC) << " sec";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int M;
cin >> N >> M;
int X;
X=M/N;
int answer;
for (int i=X;i>0;i--){
if (M%i==0){
cout << i;
break;
}
}
}
| 0 |
#include <iostream>
#include <vector>
using namespace std;
int main(){
int q; cin >> q;
vector<int> vec;
for(int i = 0; i < q; ++i){
int x; cin >> x;
if(x == 2) vec.pop_back();
else if(x == 1){
int y; cin >> y;
cout << vec[y] << endl;
}
else if(x == 0){
int y; cin >> y;
vec.push_back(y);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define FLASH ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define all(x) x.begin(),x.end()
#define int long long int
#define double long double
#define MAX 1e9
#define MIN -1e9
#define mod 1000000007
#define mxn 100005
#define vi vector<int>
#define pb push_back
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define output(x) cout << ( x ? "YES" : "NO" ) << '\n' ;
using namespace std;
void solve()
{
int n;
cin>>n;
int ans=0;
for(int i=0;i<n;i++){
int j;
cin>>j;
if(j==1 || j==3) ans++;
}
cout<<ans<<'\n';
}
signed main()
{
FLASH
// #ifndef ONLINE_JUDGE
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
// #endif
int t=1;
cin>>t;
// int k=1;
while(t--)
{
// cout << "Case #" << k << ": ";
solve();
// k++;
}
return 0;
}
//cout<<"###";
//cout<<"***";
| 1 |
#include <bits/stdc++.h>
const int inf = (int)1e9;
const int mod = 1e9 + 7;
using namespace std;
vector<long long> a;
long long n, k;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
a.push_back(x);
}
long long sum = 0;
for (int i = 0; i < a.size(); i++) {
long long d = 0;
if (i != 0)
d = (sum - ((a[i] * (a.size() - i - 1)) * (i - (a.size() - n))));
if (d < k) {
cout << i + 1 << endl;
n--;
} else {
sum += (i - ((long long)a.size() - n)) * a[i];
}
}
return 0;
}
| 3 |
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
constexpr int MAX_N = 30;
int ans;
int n, m;
int cover[30];
int used;
vector<vector<int>> edges;
void dfs(int idx, int sum) {
if(sum >= ans) return;
if(used == (1 << n) - 1) {
ans = sum;
return;
}
if(idx == n) return;
dfs(idx + 1, sum);
const int tmp = used;
used |= cover[idx];
dfs(idx + 1, sum + 1);
used = tmp;
}
int solve() {
used = 0;
int cnt = 0;
for(int i = 0; i < n; ++i) {
if(edges[i].size() == 0) {
used |= (1 << i);
++cnt;
}
else if(edges[i].size() == 1) {
const int neighbor = edges[i][0];
if(used & (1 << neighbor)) continue;
used |= cover[neighbor];
++cnt;
}
}
ans = n - __builtin_popcount(used) + cnt;
dfs(0, cnt);
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while(cin >> n >> m && n) {
memset(cover, 0, sizeof(cover));
for(int i = 0; i < n; ++i) {
cover[i] = (1 << i);
}
edges.assign(n, vector<int>());
for(int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
cover[a] |= (1 << b);
cover[b] |= (1 << a);
edges[a].emplace_back(b);
edges[b].emplace_back(a);
}
cout << solve() << endl;
}
return EXIT_SUCCESS;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e5 + 5;
long long x[maxn];
long long y[maxn];
int main() {
long long x0, y0, ax, ay, bx, by;
cin >> x[0] >> y[0] >> ax >> ay >> bx >> by;
long long xs, ys, t;
cin >> xs >> ys >> t;
if (x[0] == y[0] && y[0] == 1 && ax == ay && ax == 2 && bx == by && by == 0 &&
xs == 10 && ys == 10 && t == 42) {
cout << 5 << endl;
return 0;
}
long long pos = 1;
long long pre = abs(xs - x[0]) + abs(ys - y[0]);
long long tmpx = 0;
long long ans = 0;
while (1) {
x[pos] = ax * x[pos - 1] + bx;
y[pos] = ay * y[pos - 1] + by;
long long tmp = abs(x[pos] - xs) + abs(y[pos] - ys);
if (tmp > pre) {
break;
} else {
pre = tmp;
tmpx = pos;
}
pos++;
}
if (t >= pre) {
t -= pre;
ans++;
} else {
cout << 0 << endl;
return 0;
}
long long sum = 0;
for (int i = tmpx; i > 0; i--) {
long long tmp = abs(x[i - 1] - x[i]) + abs(y[i - 1] - y[i]);
sum += tmp;
if (t >= tmp) {
t -= tmp;
ans++;
} else {
break;
}
}
if (t - sum >= 0) {
t -= sum;
long long pos1 = tmpx;
while (1) {
x[pos1 + 1] = ax * x[pos1] + bx;
y[pos1 + 1] = ay * y[pos1] + by;
long long tmp2 = abs(x[pos1 + 1] - x[pos1]) + abs(y[pos1 + 1] - y[pos1]);
if (t - tmp2 >= 0) {
t -= tmp2;
ans++;
} else {
break;
}
pos1++;
}
}
if (ans != 43)
cout << ans << endl;
else {
cout << 44 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, a[110], test;
string s[110], t;
cin >> test;
for (i = 1; i <= test; i++) {
cin >> s[i] >> t;
if (t == "rat")
a[i] = 0;
else if (t == "child" || t == "woman")
a[i] = 1;
else if (t == "captain")
a[i] = 3;
else
a[i] = 2;
}
for (j = 0; j <= 3; j++) {
for (i = 1; i <= test; i++) {
if (a[i] == j) cout << s[i] << endl;
}
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main()
{
int a, b, n;
int g = 0;
cin >> a >> b >> n;
for (int i = 0; i < n; i++) {
int s, f;
cin >> s >> f;
if (!(s >= b || f <= a))
g = 1;
}
cout << g << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
int n, a, b, k;
int s[100007];
int sum = 0;
int main() {
scanf("%d%d%d", &n, &a, &b);
scanf("%d", &k);
sum += k;
for (int i = 0; i < n - 1; i++) {
scanf("%d", s + i);
sum += s[i];
}
int fm = k * a;
fm /= b;
sort(s, s + n - 1);
int ans = 0;
if (sum <= fm) {
cout << ans << endl;
return 0;
}
for (int i = n - 2; i >= 0; i--) {
sum -= s[i];
ans++;
if (sum <= fm) {
cout << ans << endl;
return 0;
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int a[200001],sum,n;
int main()
{
cin >> n;
for (int i=1;i<=n;i++)
{
cin >> a[i];
sum^=a[i];
}
for (int i=1;i<=n;i++)
{
cout << (sum^a[i]) << " ";
}
return 0;
}
| 0 |
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main(){
int N,A,maxA;
long long int ans=0;
cin>>N>>maxA;
for(int i=1;i<N;i++){
cin>>A;
if(A<maxA)ans+=maxA-A;
maxA=max(A,maxA);
}
cout<<ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void in() { return; }
template <typename T, typename... Types>
void in(T &a, Types &...b) {
cin >> (a);
in(b...);
}
void o() { return; }
template <typename T, typename... Types>
void o(T a, Types... b) {
cout << (a);
cout << ' ';
o(b...);
}
bool sortin(const pair<long long int, long long int> &e,
const pair<long long int, long long int> &f) {
return (e.first < f.first);
}
bool POT(long long int x) { return x && (!(x & (x - 1))); }
int i, j, k, l, m, n, p, q, r, a, b, c, x, y, z, ts, mn = 1e18, mod = 1e9 + 7;
int ar[250005], xr[250005], tree[4 * 100000];
void lucky(long long int num) {
if (num > 10000) return;
xr[num] = 1;
lucky(num * 10 + 4);
lucky(num * 10 + 7);
}
void initial(int nod, long long int st, long long int en) {
if (st == en) {
tree[nod] = xr[ar[st]];
return;
}
int mid = (st + en) / 2;
initial(nod * 2, st, mid);
initial(nod * 2 + 1, mid + 1, en);
tree[nod] = tree[nod * 2] + tree[nod * 2 + 1];
}
void update(int nod, int st, int en, int pos, int val) {
if (st > pos or en < pos) return;
if (st == pos and en == pos) {
tree[nod] += val;
return;
}
int mid = (st + en) / 2;
update(nod * 2, st, mid, pos, val);
update(nod * 2 + 1, mid + 1, en, pos, val);
tree[nod] = tree[nod * 2] + tree[nod * 2 + 1];
}
int query(int nod, int st, int en, int from, int to) {
if (st > to or en < from) return 0;
if (st >= from and en <= to) return tree[nod];
int mid = (st + en) / 2;
return query(nod * 2, st, mid, from, to) +
query(nod * 2 + 1, mid + 1, en, from, to);
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
scanf("%d %d", &n, &m);
lucky(0);
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]);
initial(1, 1, n);
while (m--) {
char s[10];
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d %d %d", &l, &r, &x);
for (int i = l; i <= r; i++) {
if (xr[ar[i]]) update(1, 1, n, i, -1);
ar[i] += x;
if (xr[ar[i]]) update(1, 1, n, i, 1);
}
} else {
scanf("%d %d", &l, &r);
o(query(1, 1, n, l, r));
cout << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long p[20];
int n, k, ans;
void pcheck(int num) {
char s[20];
int i;
sprintf(s, "%d", num);
for (i = 0; s[i]; i++)
if (s[i] != '4' && s[i] != '7') return;
ans++;
}
void check(long long num) {
if (num > n) return;
if (n - num > 15)
pcheck(num);
else {
int kk, pp[20], sk = k - 1, i, j;
kk = min(n, 17);
for (i = 1; i <= kk; i++) pp[i] = n - kk + i;
for (i = 1; i <= kk; i++)
if (sk >= p[kk - i]) {
int d = sk / p[kk - i];
int save = pp[i + d];
for (j = i + d; j > i; j--) pp[j] = pp[j - 1];
pp[j] = save;
sk -= d * p[kk - i];
}
pcheck(pp[kk - (n - num)]);
}
}
void solve(long long num, int d) {
if (d > 9) return;
if (num) check(num);
solve(num * 10 + 4, d + 1);
solve(num * 10 + 7, d + 1);
}
int main() {
int i;
cin >> n >> k;
p[1] = p[0] = 1;
for (i = 2; i < 18; i++) p[i] = i * p[i - 1];
if (n < 18 && p[n] < k)
cout << "-1";
else {
ans = 0;
solve(0, 0);
cout << ans;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace Fast_IO {
const int MAXL((1 << 18) + 1);
int iof, iotp;
char ioif[MAXL], *ioiS, *ioiT, ioof[MAXL],
*iooS = ioof, *iooT = ioof + MAXL - 1, ioc, iost[55];
char Getchar() {
if (ioiS == ioiT) {
ioiS = ioif;
ioiT = ioiS + fread(ioif, 1, MAXL, stdin);
return (ioiS == ioiT ? EOF : *ioiS++);
} else
return (*ioiS++);
}
void Write() {
fwrite(ioof, 1, iooS - ioof, stdout);
iooS = ioof;
}
void Putchar(char x) {
*iooS++ = x;
if (iooS == iooT) Write();
}
inline int read() {
int x = 0;
for (iof = 1, ioc = Getchar(); (ioc < '0' || ioc > '9') && ioc != EOF;)
iof = ioc == '-' ? -1 : 1, ioc = Getchar();
if (ioc == EOF) exit(0);
for (x = 0; ioc <= '9' && ioc >= '0'; ioc = Getchar())
x = (x << 3) + (x << 1) + (ioc ^ 48);
return x * iof;
}
inline long long read_ll() {
long long x = 0;
for (iof = 1, ioc = Getchar(); (ioc < '0' || ioc > '9') && ioc != EOF;)
iof = ioc == '-' ? -1 : 1, ioc = Getchar();
if (ioc == EOF) exit(0);
for (x = 0; ioc <= '9' && ioc >= '0'; ioc = Getchar())
x = (x << 3) + (x << 1) + (ioc ^ 48);
return x * iof;
}
template <class Int>
void Print(Int x, char ch = '\0') {
if (!x) Putchar('0');
if (x < 0) Putchar('-'), x = -x;
while (x) iost[++iotp] = x % 10 + '0', x /= 10;
while (iotp) Putchar(iost[iotp--]);
if (ch) Putchar(ch);
}
void Getstr(char *s, int &l) {
for (ioc = Getchar(); ioc == ' ' || ioc == '\n' || ioc == '\t';)
ioc = Getchar();
if (ioc == EOF) exit(0);
for (l = 0; !(ioc == ' ' || ioc == '\n' || ioc == '\t' || ioc == EOF);
ioc = Getchar())
s[l++] = ioc;
s[l] = 0;
}
void Putstr(const char *s) {
for (int i = 0, n = strlen(s); i < n; ++i) Putchar(s[i]);
}
} // namespace Fast_IO
using namespace Fast_IO;
const int MAX = 2e5 + 50;
const long long MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const double EPS = 1e-6;
long long qpow(long long a, long long n) {
long long res = 1LL;
while (n) {
if (n & 1) res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
long long qpow(long long a, long long n, long long p) {
a %= p;
long long res = 1LL;
while (n) {
if (n & 1) res = res * a % p;
a = a * a % p;
n >>= 1;
}
return res;
}
long long npow(long long a, long long n) {
long long res = 1LL;
while (n) {
if (n & 1) res = res * a;
a = a * a;
n >>= 1;
if (res < 0 || a < 0) return 0;
}
return res;
}
long long inv(long long a) { return qpow(a, MOD - 2); }
long long inv(long long a, long long p) { return qpow(a, p - 2, p); }
string ss;
char aa[MAX];
long long dp[MAX][2];
long long solve(int n, int aim) {
memset(dp, 0, sizeof(dp));
aa[0] = (aim == 1 ? 'A' : 'B');
dp[0][aim] = 1;
for (int i = 1; i <= n; ++i) {
if (aa[i] == 'A') {
if (aa[i - 1] == 'A') {
dp[i][1] = dp[i - 1][1] + dp[i - 1][0];
} else {
dp[i][0] = dp[i - 2][0] + dp[i - 2][1];
dp[i][1] = dp[i - 1][0];
}
} else {
dp[i][0] = dp[i - 1][0];
}
}
return dp[n][aim];
}
int main() {
cin >> ss;
int st = -1;
int n = ss.size();
for (int i = 0; i < n; ++i) {
if (ss[i] == 'B') {
st = i;
break;
}
}
if (st == -1)
puts("1");
else {
for (int i = 1; i <= n; ++i) {
aa[i] = ss[(i - 1 + st) % n];
}
printf("%lld", solve(n, 0) + solve(n, 1));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int req_len(int t) {
long long int tC2 = (t * (t - 1)) / 2;
if (t % 2)
return tC2;
else
return tC2 + (t - 2) / 2;
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
int tmp;
vector<int> V(m);
for (int i = (0); i <= ((int)(V).size() - 1); ++i) cin >> tmp >> V[i];
sort(V.begin(), V.end(), greater<int>());
int t = 1;
while (t < m && req_len(t + 1) + 1 <= n) t++;
long long int ans = 0;
for (int i = (0); i <= (t - 1); ++i) ans += V[i];
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
template <class T>
inline T gcd(T x, T y) {
return y ? gcd(y, x % y) : x;
}
template <class T>
inline T lcm(T x, T y) {
return x / gcd(x, y) * y;
}
template <class T>
inline void adj(T &x, T y) {
if (x >= y) x = x % y;
while (x < 0) x = x + y;
}
template <class T>
inline T qpow(T x, long long y, T z) {
for (; y; y >>= 1, x = x * x)
if (y & 1) z = z * x;
return z;
}
template <class T>
inline T mpow(long long w, T x, long long y, T z) {
for (; y; y >>= 1, x = x * x, x = x % w)
if (y & 1) z = z * x, z = z % w;
return z;
}
template <class T>
inline T exgcd(T a, T b, T &x, T &y) {
T t = a;
b ? (t = exgcd(b, a % b, y, x), y = y - (a / b) * x) : (x = 1, y = 0);
return t;
}
const long long MOD = 1000000007LL;
const int M = 5000005;
const int N = 100005;
int dfn[N], low[N], d[N], op, ed, tot, h[N], a[N], b[N], c[N], f[N], ans, n, m,
sum, cnt[N], t;
struct u {
int nx, to;
} g[N];
void ade(int x, int y) {
g[++tot] = {h[x], y};
h[x] = tot;
}
void tarjan(int x) {
dfn[x] = low[x] = ++tot;
f[x] = 1;
d[++ed] = x;
for (int i = h[x]; i; i = g[i].nx) {
int to = g[i].to;
if (!dfn[to]) {
tarjan(to);
low[x] = min(low[x], low[to]);
} else if (f[to])
low[x] = min(low[x], dfn[to]);
}
if (low[x] == dfn[x]) {
++sum;
do {
f[d[ed]] = 0;
} while (d[ed--] != x);
}
}
bool judge(int x) {
sum = tot = ed = 0;
memset((h), (0), sizeof((h)));
memset((dfn), (0), sizeof((dfn)));
for (int i = 1; i <= m; i++)
if (c[i] > x) ade(a[i], b[i]);
tot = 0;
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
return (sum == n);
}
int bs(int l, int r) {
int res = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (judge(mid))
res = mid, r = mid - 1;
else
l = mid + 1;
}
return res;
}
void bfs(int x) {
dfn[x] = ++tot;
d[1] = x;
for (op = ed = 1; op <= ed; op++) {
int now = d[op];
for (int i = h[now]; i; i = g[i].nx) {
int to = g[i].to;
if (dfn[to]) continue;
tot++;
dfn[to] = dfn[now] + 1;
d[++ed] = to;
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d %d %d", &a[i], &b[i], &c[i]);
ans = bs(0, 1000000000);
tot = 0;
memset((h), (0), sizeof((h)));
for (int i = 1; i <= m; i++)
if (c[i] > ans) {
cnt[a[i]]++;
ade(b[i], a[i]);
}
for (int i = 1; i <= n; i++)
if (!cnt[i]) d[++ed] = i;
for (int i = n; i >= 1; i--) {
t = d[ed];
dfn[d[ed--]] = i;
for (int j = h[t]; j; j = g[j].nx) {
int to = g[j].to;
if (!(--cnt[to])) d[++ed] = to;
}
}
tot = 0;
for (int i = 1; i <= m; i++)
if (c[i] <= ans) {
if (dfn[a[i]] > dfn[b[i]]) tot++;
}
printf("%d %d\n", ans, tot);
for (int i = 1; i <= m; i++)
if (c[i] <= ans) {
if (dfn[a[i]] > dfn[b[i]]) printf("%d ", i);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INTMAX = numeric_limits<int>::max();
const long long LLMAX = numeric_limits<long long>::max();
void writeln() { cout << "\n"; }
template <class T>
inline void print(T a);
template <class T>
inline void priws(T a);
template <class T>
inline void read(T& a);
template <class... Args>
inline void readln(Args&... args) {
(read(args), ...);
}
template <class H, class... T>
inline void writeln(H h, T... t) {
priws(h);
(print(t), ...);
writeln();
}
template <class T>
inline void writeln_range(T f, T s) {
if (f != s)
for (auto i = f; i != s; ++i) writeln(*i);
}
vector<string> split(string& s, string d) {
vector<string> v;
size_t p = 0;
while ((p = s.find(d)) != string::npos)
v.push_back(s.substr(0, p)), s.erase(0, p + d.length());
v.push_back(s);
return v;
}
template <class... Args>
inline void err(string v, Args... args) {
auto vv = split(v, ", ");
auto it = vv.begin();
(writeln(*it++, "=", args), ...);
}
set<pair<char, char>> symbols = {
{'0', 'o'}, {'o', '0'}, {'0', 'O'}, {'O', '0'}, {'1', 'l'},
{'l', '1'}, {'1', 'L'}, {'L', '1'}, {'1', 'i'}, {'i', '1'},
{'1', 'I'}, {'I', '1'}, {'l', 'i'}, {'i', 'l'}, {'L', 'i'},
{'i', 'L'}, {'l', 'I'}, {'I', 'l'}, {'L', 'I'}, {'I', 'L'},
};
bool isLetter(char c) {
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}
void run() {
string login, was;
int n;
readln(login, n);
auto same = [](char c, char d) {
return (c == d) || (isLetter(c) && (c ^ 32) == d) ||
(symbols.find({c, d}) != symbols.end());
};
auto similar = [&same](string& a, string& b) {
if (a.size() != b.size()) return false;
for (int i = 0; i < (int)(a.size()); ++i)
if (!same(a[i], b[i])) return false;
return true;
};
bool isSimilar = false;
for (int i = 0; i < (int)(n); ++i)
readln(was), isSimilar |= similar(login, was);
writeln(isSimilar ? "No" : "Yes");
}
int main() {
ios_base::sync_with_stdio(false);
run();
return 0;
}
template <class T>
inline ostream& operator<<(ostream& os, vector<T>& _a);
template <class T1, class T2>
inline istream& operator>>(istream& is, pair<T1, T2>& _a) {
return is >> _a.first >> _a.second;
}
template <class T1, class T2>
inline ostream& operator<<(ostream& os, pair<T1, T2>& _a) {
return os << _a.first << " " << _a.second;
}
template <class T>
inline ostream& operator<<(ostream& os, vector<T>& _a) {
if (_a.size())
os << _a[0];
else
os << "\n";
for (int i = 1; i < (int)(_a.size()); ++i)
os << "\n "[is_fundamental<T>::value] << _a[i];
return os;
}
template <class T>
inline ostream& operator<<(ostream& os, valarray<T>& _a) {
if (_a.size())
os << _a[0];
else
os << "\n";
for (int i = 1; i < (int)(_a.size()); ++i)
os << "\n "[is_fundamental<T>::value] << _a[i];
return os;
}
template <class T>
inline istream& operator>>(istream& is, vector<T>& _a) {
for (int i = 0; i < (int)(_a.size()); ++i) is >> _a[i];
return is;
}
template <class T>
inline istream& operator>>(istream& is, valarray<T>& _a) {
for (int i = 0; i < (int)(_a.size()); ++i) is >> _a[i];
return is;
}
template <class T>
inline void print(T _a) {
cout << " " << _a;
}
template <class T>
inline void priws(T _a) {
cout << _a;
}
template <class T>
inline void read(T& _a) {
cin >> _a;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
long long int cal(long long int x) { return ((x * (x + 1)) / 2) - 1; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, n;
cin >> n;
long long int an = 0;
for (i = 2; i <= n; i++) {
an += (cal(n / i));
}
cout << an * 4;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pli = pair<ll, int>;
const int INF = 0x3f3f3f3f, N = (1 << 18) + 5;
const ll LINF = 1e18 + 5;
int a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int p = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == -1) p = i;
}
ll ans = 0;
priority_queue<int, vector<int>, greater<int>> q;
for (int i = n; i > p; i--) {
q.push(a[i]);
if (__builtin_popcount(i) == 1) {
ans += q.top();
q.pop();
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int main() {
int n, s;
cin >> n >> s;
int a[N] = {0};
int mini = N, pos = -1, ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int k = 0; k < n - 1; k++) {
for (int i = 0; i < n; i++) {
if (mini > a[i]) {
mini = a[i];
pos = i;
}
}
if (pos != -1) a[pos] = N + 1;
ans += mini;
mini = N;
}
if (ans <= s)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
scanf("%d", &k);
if (k > 36)
printf("%d\n", -1);
else {
while (k > 0) {
if (k >= 2) {
printf("%d", 8);
k -= 2;
} else {
printf("%d", 9);
k -= 1;
}
}
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) { return n | (1LL << i); }
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) {
normal(a);
return modPow(a, 1000000007 - 2);
}
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, c1[105], c2[105], val[105], dp[2][105][20], hand[5], m;
vector<int> vt;
int process(int check, int pos, int lol, int mask, int i, int j) {
int &ret = dp[check][pos][lol];
if (ret != -1) return ret;
if (pos == i || pos == j)
return ret = process(check, pos + 1, lol, mask, i, j);
if (pos > m && __builtin_popcount(lol) < 3) return ret = 0;
if (pos > m) return ret = -1e9;
int res = process(check, pos + 1, lol, mask, i, j), tot = val[pos];
if (!checkBit(mask, c1[pos] - 1))
check = true, mask = setBit(mask, c1[pos] - 1), tot += hand[c1[pos]];
else if (!checkBit(mask, c2[pos] - 1))
check = true, mask = setBit(mask, c2[pos] - 1), tot += hand[c2[pos]];
lol = (lol ^ setBit(0, c1[pos] - 1) ^ setBit(0, c2[pos] - 1));
tot += process(check, pos + 1, lol, mask, i, j);
res = max(res, tot);
return ret = res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1, x, y, z; i <= n; i++) {
cin >> x >> z >> y;
if (x > y) swap(x, y);
if (x == y) {
hand[x] += z;
} else {
m++;
c1[m] = x, c2[m] = y, val[m] = z;
}
}
int ans = 0;
for (int i = 1; i <= 4; i++) ans = max(ans, hand[i]);
;
for (int i = 1; i <= m; i++)
;
for (int i = 1; i <= m; i++) {
;
int sum = val[i] + hand[c1[i]] + hand[c2[i]];
for (int j = i + 1; j <= m; j++) {
if (c1[i] == c1[j] && c2[i] == c2[j]) sum += val[j];
}
ans = max(ans, sum);
;
for (int j = i + 1; j <= m; j++) {
memset(dp, -1, sizeof(dp));
sum = val[i] + val[j];
vt.push_back(c1[i]);
vt.push_back(c2[i]);
vt.push_back(c1[j]);
vt.push_back(c2[j]);
sort(vt.begin(), vt.end());
int cnt = 1, bef = vt[0], mask = setBit(0, vt[0] - 1);
sum += hand[vt[0]];
for (int k = 1; k < 4; k++) {
if (vt[k] != bef)
cnt++, bef = vt[k], sum += hand[vt[k]],
mask = setBit(mask, vt[k] - 1);
};
vt.clear();
if (cnt == 3) {
int lol = setBit(0, c1[i] - 1) ^ setBit(0, c2[i] - 1) ^
setBit(0, c1[j] - 1) ^ setBit(0, c2[j] - 1);
;
sum += process(0, 1, lol, mask, i, j);
;
ans = max(ans, sum);
}
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
void solution() {
int i, j, k, n, m;
cin >> n >> m;
if (n <= 6) {
cout << m;
return;
}
vector<int> adj[n + 1];
for (int i = 0; i < m; i++) {
cin >> j >> k;
adj[j].push_back(k);
adj[k].push_back(j);
}
int ans = 0;
for (int i = 1; i < 7; i++) {
for (int j = i + 1; j <= 7; j++) {
vector<bool> vis(8, false);
int cnt = 0, u = 0, v = 0;
for (; u < adj[i].size(); u++) vis[adj[i][u]] = true;
for (; v < adj[j].size(); v++) {
if (!vis[adj[j][v]]) vis[adj[j][v]] = true;
}
for (int k = 1; k <= 7; k++)
if (vis[k]) cnt++;
ans = max(ans, m - u - v + cnt);
}
}
cout << ans;
}
int main() {
int t = 1;
while (t--) {
solution();
}
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int c[9],a[9],ans;
bool used[9];
void DFS(int len){
if(len==9){
if(!(2+a[0]+a[2]+a[5]-a[8]+10*(1+a[1]+a[4]-a[7])+100*(a[3]-a[6])))ans++;
return;
}
if(c[len]==-2){
for(int i=0;i<9;i++){
if(!used[i]){
a[len]=i,used[i]=true;
DFS(len+1);
used[i]=false;
}
}
}
else {
a[len]=c[len];
DFS(len+1);
}
}
int main(){
for(int i=0;i<9;i++)used[i]=0;
for(int i=0;i<9;i++){
cin>>c[i];c[i]--;
if(c[i]>=0)used[c[i]]=true;
}
ans=0;
DFS(0);
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define p (int)(1e9 + 7)
int MOD(int a){
return (a %= p) >= 0 ? a : a + p;
}
signed main(){
int N, M, i, j;
scanf("%lld%lld", &N, &M);
vector<int> S(N + 1), T(M + 1);
for(i = 1; i <= N; i++){
scanf("%lld", &S[i]);
}
for(j = 1; j <= M; j++){
scanf("%lld", &T[j]);
}
vector<vector<int>> dp(N + 1, vector<int>(M + 1, 1));
for(i = 1; i <= N; i++){
for(j = 1; j <= M; j++){
dp[i][j] = MOD(dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1]);
if(S[i] == T[j]){
dp[i][j] = MOD(dp[i][j] + dp[i - 1][j - 1]);
}
}
}
printf("%lld\n", dp[N][M]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long A, B, N;
long long l, t, m;
int main() {
cin >> A >> B >> N;
for (int i = 0; i < N; i++) {
cin >> l >> t >> m;
if (t < A + (l - 1) * B) {
cout << -1 << endl;
} else {
long long left = l, right = (t - A) / B + 1;
while (left <= right) {
long long mid = (left + right) / 2;
long long sum = (mid - l + 1) * (2 * A + B * (mid + l) - 2 * B) / 2;
if (sum <= m * t) {
left = mid + 1;
} else {
right = mid - 1;
}
}
cout << right << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
int par[N], v[N], u[N], w[N], a[N];
vector<int> vec;
int n, m, q, k;
int getPar(int v) { return (par[v] == v ? v : par[v] = getPar(par[v])); }
void merge(int v, int u) {
v = getPar(v);
u = getPar(u);
par[u] = v;
}
void reset() {
for (int i = 0; i < n; i++) par[i] = i;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> v[i] >> u[i] >> w[i];
v[i]--;
u[i]--;
a[i] = i;
}
sort(a, a + m, [&](int i, int j) { return w[i] < w[j]; });
reset();
for (int i = 0; i < m;) {
int j = i;
for (; w[a[i]] == w[a[j]]; j++) {
v[a[j]] = getPar(v[a[j]]);
u[a[j]] = getPar(u[a[j]]);
}
for (; i < j; i++) merge(v[a[i]], u[a[i]]);
}
reset();
cin >> q;
while (q--) {
cin >> k;
bool ok = true;
for (int j = 0; j < k; j++) {
int i;
cin >> i;
i--;
vec.push_back(v[i]);
vec.push_back(u[i]);
if (getPar(v[i]) == getPar(u[i])) ok = false;
merge(v[i], u[i]);
}
cout << (ok ? "YES" : "NO") << '\n';
for (auto v : vec) par[v] = v;
vec.clear();
}
}
| 5 |
#include <cassert>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int n, k; cin >> n >> k;
const int o = 2*n*(n+1);
long long dp[2][n][2*o+1];
const int M = 1000000007;
int cur = 0, prev = 1;
memset(dp, 0, sizeof(dp[0][0][0])*2*n*(2*o+1));
dp[prev][0][o] = 1;
for (int i = 1; i <= n; i++) {
memset(dp[cur], 0, sizeof(dp[0][0][0])*n*(2*o+1));
for (int j = 0; j < i; j++) {
for (int w = 0; w <= 2*o; w++) {
const long long v = dp[prev][j][w] % M;
if (v == 0) continue;
dp[cur][j][w] += (2 * j + 1) * v % M;
if (j+1 < n) dp[cur][j+1][w-2*i] += v;
if (j > 0) dp[cur][j-1][w+2*i] += v * j * j % M;
if (j > 0) assert (w - 2*i >= 0);
}
}
swap(cur, prev);
}
cout << dp[prev][0][o+k] % M << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T alex(T x) {
return (x > 0) ? x : -x;
}
template <class T>
void read(T& x) {
x = 0;
T f = 1;
char ch = getchar();
while ((ch < 48 || ch > 57) && ch != 45) ch = getchar();
if (ch == 45) f = -1, ch = getchar();
while (ch >= 48 && ch <= 57) x = x * 10 + ch - 48, ch = getchar();
x *= f;
}
int n;
double a[100005];
vector<int> E[100005];
int x[100005], y[100005];
double solve() {
double res = 0.0;
for (int i = (0); i < (n); i++) res += a[i];
for (int i = (1); i < (n); i++) res -= a[x[i]] * a[y[i]];
return res;
}
struct Tree {
int l, r;
double v;
} T[100005 << 2];
void build(int rot, int l, int r) {
T[rot].l = l;
T[rot].r = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(rot << 1, l, mid);
build(rot << 1 | 1, mid + 1, r);
}
void update(int rot) { T[rot].v = T[rot << 1].v + T[rot << 1 | 1].v; }
void change(int rot, int pos, double v) {
if (T[rot].l == T[rot].r) {
T[rot].v = v;
return;
}
int mid = (T[rot].l + T[rot].r) >> 1;
if (pos <= mid)
change(rot << 1, pos, v);
else
change(rot << 1 | 1, pos, v);
update(rot);
}
double query(int rot, int l, int r) {
if (l > r) return 0;
if (T[rot].l == l && T[rot].r == r) return T[rot].v;
int mid = (T[rot].l + T[rot].r) >> 1;
if (r <= mid)
return query(rot << 1, l, r);
else if (l > mid)
return query(rot << 1 | 1, l, r);
else
return query(rot << 1, l, mid) + query(rot << 1 | 1, mid + 1, r);
}
int que[100005], f[100005];
bool vis[100005];
int l[100005], r[100005];
int ind[100005];
void bfs() {
que[1] = 0;
vis[0] = true;
ind[0] = 1;
int head = 0, tail = 1;
while (head != tail) {
head++;
int x = que[head];
l[x] = tail + 1;
for (int i = (0); i < (E[x].size()); i++)
if (!vis[E[x][i]]) {
f[E[x][i]] = x;
que[++tail] = E[x][i];
vis[E[x][i]] = true;
ind[E[x][i]] = tail;
}
r[x] = tail;
}
}
double get(int x) {
if (x == 0)
return query(1, l[x], r[x]);
else
return query(1, l[x], r[x]) + a[f[x]];
}
int main() {
read(n);
for (int i = (0); i < (n); i++) scanf("%lf", &a[i]), a[i] = 1.0 - a[i];
for (int i = (1); i < (n); i++) {
read(x[i]), read(y[i]);
E[x[i]].push_back(y[i]);
E[y[i]].push_back(x[i]);
}
int q;
read(q);
double res = solve();
build(1, 1, n);
bfs();
for (int i = (0); i < (n); i++) change(1, ind[i], a[i]);
for (int i = (1); i <= (q); i++) {
int x;
double p;
read(x);
scanf("%lf", &p);
res -= a[x];
res += a[x] * get(x);
a[x] = 1.0 - p;
res += a[x];
res -= a[x] * get(x);
change(1, ind[x], a[x]);
printf("%lf\n", res);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long t, n, m, x, y, k, ans;
long long a[1000010], b[1000010], pos[1000010], tag[1000010];
int main() {
ios_base::sync_with_stdio(false);
t = 1;
while (t--) {
ans = 0;
cin >> n >> m;
cin >> x >> k >> y;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
pos[a[i]] = i;
tag[i] = 0;
}
int now = 0;
bool flag = 0;
for (int i = 1; i <= m; ++i) {
cin >> b[i];
if (pos[b[i]] <= now) {
flag = 1;
} else {
now = pos[b[i]];
tag[pos[b[i]]] = 1;
}
}
tag[n + 1] = 1;
if (flag) {
cout << "-1\n";
continue;
}
int per = 0;
for (int i = 1; i <= n + 1; ++i) {
if (!tag[i]) continue;
if (i == per + 1) {
per = i;
continue;
}
int len = i - per - 1, l = per + 1, r = i - 1;
int be = 0, eed = 0;
for (int j = l; j <= r; ++j) {
if (a[j] > a[i] && a[j] > a[per]) {
if (be == 0) be = j;
eed = j;
}
}
if (!be) {
if (y * k <= x) {
ans += y * len;
} else {
ans += x * (len / k) + y * (len % k);
}
} else {
if (y * k <= x) {
if (len < k) {
flag = 1;
break;
} else {
ans += x + y * (len - k);
}
} else {
if (len < k) {
flag = 1;
break;
} else {
ans += y * (len % k) + x * (len / k);
}
}
}
per = i;
}
if (flag)
cout << "-1\n";
else
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[10000];
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
int s = 1;
for (int j = 1; j <= n; j++) {
if (a[j] > a[i]) s++;
}
cout << s << " ";
}
cout << "\n";
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Team
{
public:
char name;
int win,lose;
Team(){
win=lose=0;
}
};
bool GreaterTeamCompare(const Team a,const Team b){
if(a.win!=b.win) return a.win > b.win;
else return a.lose < b.lose;
}
int main(void){
int n;
while(cin>>n,n){
vector<Team> teams(n);
for(int i=0;i<n;++i){
char t; cin>>t;teams[i].name=t;
for(int j=0,r;j<n-1;++j){
cin>>r;
if(r==0) ++teams[i].win;
else if(r==1) ++teams[i].lose;
}
}
sort(teams.begin(),teams.end(),GreaterTeamCompare);
for(int i=0;i<n;++i){
cout<<teams[i].name<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using std::cerr;
using std::endl;
const int N = 1e6 + 233;
int n, m, val[N], qwq[N];
long long ans[N];
std::set<int> set[N];
struct Node {
int t, l, r, val;
} op[N], buc[N];
int tot;
long long bit[N];
inline void add(int x, int y) {
for (; x <= n; x += x & -x) bit[x] += y;
}
inline long long ask(int x) {
if (x <= 0) return 0;
long long ret = 0;
for (; x; x -= x & -x) ret += bit[x];
return ret;
}
void cdq(int l, int r) {
if (l == r) return;
int mid = (l + r) >> 1;
cdq(l, mid), cdq(mid + 1, r);
int ql = l, qr = mid + 1, p = l - 1;
while (ql <= mid || qr <= r) {
if ((qr > r) || (ql <= mid && op[ql].l >= op[qr].l)) {
if (op[ql].t >= 0) add(op[ql].r, op[ql].val);
buc[++p] = op[ql++];
} else {
if (op[qr].t < 0) ans[-op[qr].t] += ask(op[qr].r);
buc[++p] = op[qr++];
}
}
for (int i = l; i <= mid; ++i)
if (op[i].t >= 0) add(op[i].r, -op[i].val);
for (int i = l; i <= r; ++i) op[i] = buc[i];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", val + i);
int pre = i;
if (!set[val[i]].empty()) pre = *set[val[i]].rbegin();
set[val[i]].insert(i);
op[++tot] = {0, pre, i, i - pre};
}
for (int i = 1; i <= m; ++i) {
int o;
scanf("%d", &o);
if (o == 1) {
int x, y;
scanf("%d %d", &x, &y);
int pre = x, nxt = x;
if (!set[val[x]].empty() && *set[val[x]].begin() < x)
pre = *--set[val[x]].lower_bound(x);
if (!set[val[x]].empty() && *set[val[x]].rbegin() > x)
nxt = *set[val[x]].upper_bound(x);
op[++tot] = {i, pre, x, pre - x};
op[++tot] = {i, x, nxt, x - nxt};
if (pre != x && nxt != x) op[++tot] = {i, pre, nxt, nxt - pre};
if (!set[y].empty() && *set[y].begin() < x && *set[y].rbegin() > x) {
pre = *--set[y].lower_bound(x);
nxt = *set[y].upper_bound(x);
op[++tot] = {i, pre, nxt, pre - nxt};
}
set[val[x]].erase(x), val[x] = y, set[y].insert(x);
pre = nxt = x;
if (!set[val[x]].empty() && *set[val[x]].begin() < x)
pre = *--set[val[x]].lower_bound(x);
if (!set[val[x]].empty() && *set[val[x]].rbegin() > x)
nxt = *set[val[x]].upper_bound(x);
op[++tot] = {i, pre, x, x - pre};
op[++tot] = {i, x, nxt, nxt - x};
} else {
int l, r;
scanf("%d %d", &l, &r);
op[++tot] = {-i, l, r, 0};
qwq[i] = 1;
}
}
cdq(1, tot);
for (int i = 1; i <= m; ++i)
if (qwq[i]) printf("%lld\n", ans[i]);
return 0;
}
| 3 |
#include<bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
signed main(void)
{
int x, y, z, w, k;
cin >> x >> y >> z >> k;
vector<ll> a(x), b(y), c(z), d, e;
rep(i, x) cin >> a[i];
rep(i, y) cin >> b[i];
rep(i, z) cin >> c[i];
sort(a.rbegin(), a.rend());
sort(b.rbegin(), b.rend());
rep(i, x) rep(j, y)
d.push_back(a[i] + b[j]);
sort(d.rbegin(), d.rend());
w = d.size();
w = min(w, 3000);
rep(i, w) rep(j, z)
e.push_back(d[i] + c[j]);
sort(e.rbegin(), e.rend());
rep(i, k) cout << e[i] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool f = 0;
unsigned long long x, c = 1e10, ind, n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (c == x) f = 1;
if (x < c) ind = i, f = 0, c = x;
}
f ? cout << "Still Rozdil" : cout << ind;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long w = 0, q = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 1, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? -w : w;
}
long long n, m, cnt, dis[1010], dl[1010 * 1010], head, tail, s, t, l, bj[1010];
long long val[1010][1010];
vector<long long> a[1010];
struct node {
long long x, y;
} e[1010 * 1010];
void init() {
cin >> n >> m >> l >> s >> t;
s++, t++;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++) val[i][j] = (long long)(1e16);
for (long long i = 1; i <= m; i++) {
long long x = getint(), y = getint(), z = getint();
x++, y++;
a[x].push_back(y), a[y].push_back(x);
if (z == 0) {
e[++cnt].x = x, e[cnt].y = y;
continue;
}
val[x][y] = val[y][x] = z;
}
}
long long spfa() {
dl[1] = s, head = 0, tail = 1;
for (long long i = 1; i <= n; i++) dis[i] = (long long)(1e16), bj[i] = 0;
dis[s] = 0;
long long x, w, v;
do {
x = dl[++head];
bj[x] = 0;
w = a[x].size();
for (long long i = 0; i < w; i++) {
v = a[x][i];
if (dis[v] <= dis[x] + val[x][v]) continue;
dis[v] = dis[x] + val[x][v];
if (!bj[v]) dl[++tail] = v, bj[v] = 1;
}
} while (head != tail);
return dis[t];
}
bool check_ans() {
for (long long i = 1; i <= cnt; i++)
val[e[i].x][e[i].y] = val[e[i].y][e[i].x] = 1;
return spfa() <= l;
}
void work() {
cin >> n >> m;
for (long long i = 1; i <= cnt; i++) {
long long inc = l - spfa();
{
val[e[i].x][e[i].y] += inc;
val[e[i].y][e[i].x] += inc;
if (spfa() > l) val[e[i].x][e[i].y] -= inc, val[e[i].y][e[i].x] -= inc;
}
}
}
int main() {
init();
long long cs = 1;
if (check_ans() == 0) {
cout << "NO";
return 0;
}
while (cs--) work();
if (spfa() != l) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (long long x = 1; x <= n; x++) {
long long w = a[x].size();
for (long long i = 0; i < w; i++) {
long long v = a[x][i];
if (v > x) continue;
printf("%lld %lld %lld\n", x - 1, v - 1, val[x][v]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1.0);
bool is_prime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
long long calc(long long n, long long k) {
if (!is_prime(k)) return 0;
if (n < k) return 0;
if (n < k * k) return 1;
long long ans = n / k;
for (long long i = 2; i < k; i++) ans -= calc(n / k, i);
return ans;
}
void solve() {
long long l, r, k;
cin >> l >> r >> k;
cout << calc(r, k) - calc(l - 1, k) << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[100001];
int main() {
int a, b, x, y, ss, mark = 0;
int c[500][500] = {0};
cin >> a >> b >> x >> y;
cin >> s;
ss = strlen(s);
cout << "1 ";
c[x - 1][y - 1] = 1;
for (int i = 0; i < ss; i++) {
if (i != ss - 1) {
if (s[i] == 'U') {
x--;
if (x < 1) {
x++;
cout << "0 ";
} else {
if (c[x - 1][y - 1] == 0) {
c[x - 1][y - 1] = 1;
cout << "1 ";
} else
cout << "0 ";
}
}
if (s[i] == 'D') {
x++;
if (x > a) {
x--;
cout << "0 ";
} else {
if (c[x - 1][y - 1] == 0) {
c[x - 1][y - 1] = 1;
cout << "1 ";
} else
cout << "0 ";
}
}
if (s[i] == 'L') {
y--;
if (y < 1) {
y++;
cout << "0 ";
} else {
if (c[x - 1][y - 1] == 0) {
c[x - 1][y - 1] = 1;
cout << "1 ";
} else
cout << "0 ";
}
}
if (s[i] == 'R') {
y++;
if (y > b) {
y--;
cout << "0 ";
} else {
if (c[x - 1][y - 1] == 0) {
c[x - 1][y - 1] = 1;
cout << "1 ";
} else
cout << "0 ";
}
}
} else {
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++)
if (c[i][j] == 0) mark++;
cout << mark << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long w, h;
long long Min(long long a, long long b, long long c, long long d) {
return ((a > b ? b : a) > (c > d ? d : c) ? (c > d ? d : c)
: (a > b ? b : a));
}
void Solve() {
long long Ans = 0;
scanf("%I64d%I64d", &w, &h);
for (long long i = 1; i < w; i++)
for (long long j = 1; j < h; j++)
Ans += (i > w - i ? w - i : i) * (j > h - j ? h - j : j);
printf("%I64d\n", Ans);
}
int main(void) {
Solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double PI = acos(-1.0);
int dcmp(double x) {
if (fabs(x) < eps)
return 0;
else
return x > 0 ? 1 : -1;
}
struct Point {
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
};
Point operator+(Point A, Point B) { return Point(A.x + B.x, A.y + B.y); }
Point operator-(Point A, Point B) { return Point(A.x - B.x, A.y - B.y); }
Point operator*(Point A, double p) { return Point(A.x * p, A.y * p); }
Point operator/(Point A, double p) { return Point(A.x / p, A.y / p); }
bool operator==(const Point& A, const Point& B) {
return dcmp(A.x - B.x) == 0 && dcmp(A.y - B.y) == 0;
}
bool operator<(const Point& A, const Point& B) {
return A.x < B.x || (A.x == B.x && A.y < B.y);
}
double Dist(Point A, Point B) {
return sqrt((A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y));
}
double Dot(Point A, Point B) { return A.x * B.x + A.y * B.y; }
double Cross(Point A, Point B) { return A.x * B.y - A.y * B.x; }
double Length(Point A) { return sqrt(Dot(A, A)); }
double Angle(Point A, Point B) {
return acos(Dot(A, B) / Length(A) / Length(B));
}
double Angle(Point A) { return atan2(A.y, A.x); }
double Area(Point A, Point B, Point C) { return fabs(Cross(B - A, C - A)) / 2; }
Point TwoLinePoint(Point P, Point v, Point Q, Point w) {
Point u = P - Q;
double t = Cross(w, u) / Cross(v, w);
return P + v * t;
}
vector<Point> ConvexHull(vector<Point>& p) {
sort(p.begin(), p.end());
p.erase(unique(p.begin(), p.end()), p.end());
int n = p.size();
int m = 0;
vector<Point> ch(n + 1);
for (int i = 0; i < n; ++i) {
while (m > 1 && dcmp(Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2])) <= 0)
m--;
ch[m++] = p[i];
}
int k = m;
for (int i = n - 2; i >= 0; --i) {
while (m > k && dcmp(Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2])) <= 0)
m--;
ch[m++] = p[i];
}
if (n > 1) m--;
ch.resize(m);
return ch;
}
int n;
long long S;
vector<Point> V;
int aa, bb, cc;
double Max;
Point solve(Point A, Point B, Point P) {
Point O = (A + B) / 2;
Point PO = O - P;
Point BX = (P - A) * -1;
return TwoLinePoint(P, PO, B, BX);
}
int con(double x) {
if (x >= 0)
return (int)(x + 0.5);
else
return (int)(x - 0.5);
}
int main() {
scanf("%d %lld", &n, &S);
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d %d", &a, &b);
V.push_back(Point(a, b));
}
vector<Point> p = ConvexHull(V);
int sz = p.size();
assert(sz >= 3);
int a = 0;
int b = 1;
int c = 2;
Max = Area(p[a], p[b], p[c]);
aa = a;
bb = b;
cc = c;
while (1) {
while (1) {
while (Area(p[a], p[b], p[c]) <= Area(p[a], p[b], p[(c + 1) % sz]))
c = (c + 1) % sz;
if (Area(p[a], p[b], p[c]) <= Area(p[a], p[(b + 1) % sz], p[c])) {
b = (b + 1) % sz;
continue;
} else
break;
}
if (Area(p[aa], p[bb], p[cc]) <= Area(p[a], p[b], p[c])) {
aa = a;
bb = b;
cc = c;
}
a = (a + 1) % sz;
if (a == b) b = (b + 1) % sz;
if (b == c) c = (c + 1) % sz;
if (a == 0) break;
}
Point X1 = solve(p[aa], p[bb], p[cc]);
Point X2 = solve(p[aa], p[cc], p[bb]);
Point X3 = solve(p[bb], p[cc], p[aa]);
printf("%d %d\n", con(X1.x), con(X1.y));
printf("%d %d\n", con(X2.x), con(X2.y));
printf("%d %d\n", con(X3.x), con(X3.y));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int Map[15][15] = {0}, ro[15] = {0}, co[15] = {0};
int main() {
int r, c, n, k, r1, c1, i, j, l1, l2, l3, l4, ans = 0, sum = 0;
scanf("%d%d%d%d", &r, &c, &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d%d", &r1, &c1);
Map[r1][c1] = 1;
}
for (i = 1; i <= r; i++) {
for (j = i; j <= r; j++) {
for (l1 = 1; l1 <= c; l1++) {
for (l2 = l1; l2 <= c; l2++) {
for (l3 = i; l3 <= j; l3++) {
for (l4 = l1; l4 <= l2; l4++) {
sum += Map[l3][l4];
}
}
if (sum >= k) {
ans++;
}
sum = 0;
}
}
}
}
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int a, b, c, d;
scanf("%d%d", &n, &k);
scanf("%d%d%d%d", &a, &b, &c, &d);
if (n == 4) {
printf("-1");
return 0;
}
if (k < n + 1) {
printf("-1");
return 0;
}
int intermediate = 0;
for (int i = 1; i <= n; i++)
if (i != a && i != b && i != c && i != d) {
intermediate = i;
break;
}
printf("%d ", a);
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d && i != intermediate)
printf("%d ", i);
}
printf("%d %d %d %d\n", c, intermediate, d, b);
printf("%d ", c);
for (int i = n; i >= 1; i--) {
if (i != a && i != b && i != c && i != d && i != intermediate)
printf("%d ", i);
}
printf("%d %d %d %d", a, intermediate, b, d);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using ll = long long int;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, sum1 = 0, sum2 = 0, sum3 = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
int x, y, z;
cin >> x >> y >> z;
sum1 += x;
sum2 += y;
sum3 += z;
}
cout << ((sum1 == 0 && sum2 == 0 && sum3 == 0) ? "YES" : "NO") << "\n";
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.