solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (b != 0) {
a %= b;
swap(a, b);
}
return a;
}
long long calc(long long n, long long k) { return n / gcd(n, k); }
int main() {
int n, k, a, b;
scanf("%d%d%d%d", &n, &k, &a, &b);
long long L = n * 1LL * k;
long long ansMin = L, ansMax = 0;
for (long long i = 0; i < n; ++i) {
ansMin = min(ansMin, calc(L, i * k + (a + b) + k));
ansMin = min(ansMin, calc(L, i * k + (a - b) + k));
ansMin = min(ansMin, calc(L, i * k + (-a + b) + k));
ansMin = min(ansMin, calc(L, i * k + (-a - b) + k));
ansMax = max(ansMax, calc(L, i * k + (a + b) + k));
ansMax = max(ansMax, calc(L, i * k + (a - b) + k));
ansMax = max(ansMax, calc(L, i * k + (-a + b) + k));
ansMax = max(ansMax, calc(L, i * k + (-a - b) + k));
}
printf("%lld %lld", ansMin, ansMax);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 240000 + 20;
char s[N];
int n, m;
int z[N], g2[N];
int ans[3], now[3];
int M[220][220];
struct node {
int l, r;
node() {}
node(int p, int q) : l(p), r(q) {}
bool operator<(const node& a) const {
return (l < a.l || (l == a.l && r > a.r));
}
} a[100000], b[100000];
int main() {
memset(M, 0, sizeof(M));
M['('][')'] = 1;
M['['][']'] = 1;
while (scanf("%s", s + 1) == 1) {
int nn = 0;
n = strlen(s + 1);
z[0] = z[1] = 1;
for (int i = 2; i <= n; ++i) {
if (z[0] > 0 && M[s[z[z[0]]]][s[i]] == 1) {
a[++nn] = node(z[z[0]], i);
--z[0];
} else {
z[++z[0]] = i;
if (s[i] == ')' || s[i] == ']') z[0] = 0;
}
}
if (!nn) {
puts("0");
continue;
}
memset(g2, 0, sizeof(g2));
for (int i = 1; i <= n; ++i) g2[i] = g2[i - 1] + (s[i] == '[');
memset(z, 0, sizeof(z));
for (int i = 1; i <= nn; ++i) z[a[i].l] = z[a[i].r] = 1;
nn = 0;
for (int i = 1; i <= n; ++i)
if (z[i] == 1) {
int l = i;
while (i <= n && z[i] == 1) ++i;
--i;
a[++nn] = node(l, i);
}
ans[0] = -1;
for (int i = 1; i <= nn; ++i)
if (ans[0] < g2[a[i].r] - g2[a[i].l - 1]) {
ans[0] = g2[a[i].r] - g2[a[i].l - 1];
ans[1] = a[i].l;
ans[2] = a[i].r;
}
printf("%d\n", ans[0]);
for (int i = ans[1]; i <= ans[2]; ++i) printf("%c", s[i]);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[10];
vector<string> res;
vector<int> fields;
int b[10];
void gao(const char* s, int len) {
int depth = (int)fields.size();
if ((4 - depth) * 3 < len) {
return;
}
if (depth == 4) {
if (len == 0) {
char buf[1024];
sprintf(buf, "%d.%d.%d.%d", fields[0], fields[1], fields[2], fields[3]);
res.push_back(buf);
}
} else {
if (s[0] == '0') {
fields.push_back(0);
gao(s + 1, len - 1);
fields.pop_back();
} else {
int value = 0;
for (int i = 1; i <= 3 && i <= len; ++i) {
value = value * 10 + s[i - 1] - '0';
if (value < 256) {
fields.push_back(value);
gao(s + i, len - i);
fields.pop_back();
}
}
}
}
}
void dfs(char* s, int len, int mask) {
if (mask == (1 << n) - 1) {
for (int i = 0; i < len; ++i) {
s[-i] = s[i];
}
gao(s - len + 1, len * 2 - 1);
for (int i = 0; i < len; ++i) {
s[-i - 1] = s[i];
}
gao(s - len, len * 2);
}
if (len < 6) {
for (int i = 0; i < n; ++i) {
s[len] = '0' + a[i];
dfs(s, len + 1, mask | 1 << i);
}
}
}
int main() {
char buf[1024];
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
b[a[i]] = i;
}
dfs(buf + 512, 0, 0);
printf("%d\n", (int)res.size());
for (int i = 0; i < (int)res.size(); ++i) {
printf("%s\n", res[i].c_str());
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
const double pi = acos(-1);
vector<long long> ft(1, 1LL);
void solve() {
long long x1, x2, y1, y2, a, b;
cin >> x1 >> y1 >> x2 >> y2 >> a >> b;
long long dx = abs(x1 - x2), dy = abs(y1 - y2);
if (dx % a == 0 and dy % b == 0 and (abs(dx / a - dy / b)) % 2 == 0)
cout << "YES\n";
else
cout << "NO\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
long long int k, len, m, arr[100], max = 0, i, sum = 0, c;
cin >> s;
cin >> k;
len = s.length();
m = len + k;
for (i = 0; i < 26; i++) {
cin >> arr[i];
if (arr[i] > max) max = arr[i];
}
for (i = 0; i < m; i++) {
if (i >= len)
sum = sum + (i + 1) * max;
else {
c = (int)s[i];
sum = sum + (i + 1) * arr[c - 97];
}
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll longinf = 1LL << 60;
constexpr ll mod = 1e9 + 7;
vector<set<int>> g;
void dfs(int u, vector<int>& trail) {
while (!g[u].empty()) {
int v = *g[u].begin();
g[u].erase(v);
g[v].erase(u);
dfs(v, trail);
}
trail.push_back(u);
}
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
int find(int x) {
if (par[x] < 0) return x;
return par[x] = find(par[x]);
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
if (par[x] > par[y]) {
par[y] += par[x];
par[x] = y;
} else {
par[x] += par[y];
par[y] = x;
}
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -par[find(x)]; }
};
void solve(int n, int cur, vector<vector<int>>& v) {
int m = 0;
while ((1 << m) != cur) ++m;
cout << m << endl;
g.resize(n + cur);
for (int i = (int)(0); i < (int)(n + cur); ++i) {
for (auto e : v[i]) g[i].insert(e);
}
g[0].erase(1);
g[1].erase(0);
vector<int> ans;
dfs(1, ans);
int cnt = 0;
rotate(ans.begin(), ans.begin() + 1, ans.end());
for (auto e : ans) {
if (e < n && cnt < n) {
cout << e + 1 << " ";
++cnt;
}
}
cout << endl;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(2 * n);
for (int i = (int)(0); i < (int)(n); ++i) cin >> a[2 * i] >> a[2 * i + 1];
int cur = 1 << 20;
vector<vector<int>> v(2 * n + cur);
for (int i = (int)(0); i < (int)(n); ++i) {
v[2 * i].push_back(2 * i + 1);
v[2 * i + 1].push_back(2 * i);
}
while (1) {
UnionFind uf(n + cur);
for (int i = (int)(0); i < (int)(2 * n); ++i) {
v[i].push_back(2 * n + a[i] % cur);
v[2 * n + a[i] % cur].push_back(i);
uf.unite(i / 2, n + a[i] % cur);
}
bool ok = true;
int c = 0;
for (int i = (int)(0); i < (int)(cur); ++i) {
if (v[2 * n + i].size() != 0) ++c;
if (v[2 * n + i].size() % 2 == 1) {
ok = false;
break;
}
}
if (uf.size(0) != n + c) ok = false;
if (ok) {
solve(2 * n, cur, v);
return 0;
}
for (int i = (int)(0); i < (int)(2 * n); ++i) v[i].pop_back();
for (int i = (int)(0); i < (int)(cur); ++i) v[2 * n + i].clear();
cur >>= 1;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long int n, m;
long long int row[50] = {0L};
long long int col[50] = {0L};
int main() {
scanf("%I64d%I64d", &n, &m);
long long int i, j;
int t;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &t);
if (t) {
row[i]++;
col[j]++;
}
}
}
long long int res = 0;
for (i = 0; i < n; i++) {
res += (((1LL << (row[i])) - 1LL) + ((1LL << (m - row[i])) - 1LL));
}
for (i = 0; i < m; i++) {
res += (((1LL << (col[i])) - 1LL) + ((1LL << (n - col[i])) - 1LL));
}
printf("%I64d\n", res - (n * m));
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 3e5 + 5, mod = 998244353;
int n, nxt[N << 1], to[N << 1], head[N], f[N][3], cnt;
int read() {
int x = 0, f = 1;
char s;
while ((s = getchar()) > '9' || s < '0')
if (s == '-') f = -1;
while (s >= '0' && s <= '9')
x = (x << 1) + (x << 3) + (s ^ 48), s = getchar();
return x * f;
}
void addEdge(const int u, const int v) {
nxt[++cnt] = head[u], to[cnt] = v, head[u] = cnt;
}
int inv(int x, int y) {
int r = 1;
while (y) {
if (y & 1) r = 1ll * r * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return r;
}
void DP(const int u, const int fa) {
f[u][0] = 0;
f[u][1] = f[u][2] = 1;
int tmp = 1;
for (int i = head[u]; i; i = nxt[i])
if (to[i] ^ fa) {
DP(to[i], u);
f[u][2] = 1ll * f[u][2] * (f[to[i]][0] + f[to[i]][2]) % mod;
f[u][1] = 1ll * f[u][1] * (f[to[i]][0] * 2 % mod + f[to[i]][2]) % mod;
tmp = 1ll * tmp * (f[to[i]][0] * 2 % mod + f[to[i]][2]) % mod;
}
f[u][1] = (f[u][1] - f[u][2] + mod) % mod;
for (int i = head[u]; i; i = nxt[i])
if (to[i] ^ fa)
f[u][0] = (f[u][0] +
1ll * tmp *
inv((f[to[i]][0] * 2 % mod + f[to[i]][2]) % mod, mod - 2) %
mod * (f[to[i]][1] + f[to[i]][2]) % mod) %
mod;
}
int main() {
int u, v;
n = read();
for (int i = 1; i < n; ++i) {
u = read(), v = read();
addEdge(u, v), addEdge(v, u);
}
DP(1, 0);
printf("%d\n", (f[1][0] + f[1][2]) % mod);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n) {
if (n % 2 == 0) {
cout << "Mahmoud";
break;
} else {
cout << "Ehab";
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, L, R, l[300005], r[300005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
L += l[i];
R += r[i];
}
int ans = abs(L - R), pm = 0;
for (int i = 1; i <= n; i++) {
L = L - l[i] + r[i];
R = R - r[i] + l[i];
if (ans < abs(L - R)) {
ans = abs(L - R);
pm = i;
}
L = L + l[i] - r[i];
R = R + r[i] - l[i];
}
cout << pm;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long f[60][120][2], n, L, R, now;
long long dfs(long long ws, long long res, long long flag) {
if (res < 0) return 0;
if (~f[ws][res][flag]) return f[ws][res][flag];
long long& t = f[ws][res][flag];
t = 0;
if ((1ll << ws) > now) {
if (res == 0 && flag == 0) t = 1;
return t;
}
if ((1ll << ws) & now) {
if (flag) {
t = dfs(ws + 1, res, 0);
if (ws < L && ws < R) t += dfs(ws + 1, res - 2, 1);
} else {
if (ws < L) t += dfs(ws + 1, res - 1, 0);
if (ws < R) t += dfs(ws + 1, res - 1, 0);
}
} else {
if (flag) {
if (ws < L) t += dfs(ws + 1, res - 1, 1);
if (ws < R) t += dfs(ws + 1, res - 1, 1);
} else {
t = dfs(ws + 1, res, 0);
if (ws < L && ws < R) t += dfs(ws + 1, res - 2, 1);
}
}
return t;
}
long long ans;
signed main() {
scanf("%lld", &n);
for (long long a = 0; (1ll << a) <= n; a++) {
for (long long b = 0; (1ll << b) <= n; b++) {
long long lca =
(n - (1ll << b) + 1) / ((1ll << a + 1) + (1ll << b + 1) - 3);
if (lca == 0) continue;
long long nn =
n - lca * ((1ll << a + 1) + (1ll << b + 1) - 3) + 1 - (1ll << b);
for (long long i = 0; i <= a + b; i++) {
memset(f, -1, sizeof(f));
L = a - 1;
R = b - 1;
now = nn + i;
if (now & 1) continue;
now /= 2;
ans += dfs(0, i, 0);
}
}
}
printf("%lld\n", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int C[1005][1005], s[1005], mod = 1e9 + 7;
int main() {
int i, j, m;
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &s[i]);
s[i] += s[i - 1];
}
for (i = 0; i <= s[m]; i++)
for (j = C[i][0] = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= mod) C[i][j] -= mod;
}
for (i = j = 1; i <= m; i++)
j = 1ll * j * C[s[i] - 1][s[i] - s[i - 1] - 1] % mod;
printf("%d", j);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < (long long)(n); i++) {
cin >> a[i];
}
bool z = 0;
long long prev;
long long sum = 1;
for (long long i = 0; i < (long long)(n); i++) {
if (a[i]) {
if (!z) {
z = 1;
prev = i;
} else {
sum *= (i - prev);
prev = i;
}
}
}
if (z) {
cout << sum;
} else {
cout << 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
pair<int, int> coo[3];
int miy = 1000, may = 0;
for (int i = 0; i < 3; ++i) {
cin >> coo[i].first >> coo[i].second;
miy = min(miy, coo[i].second);
may = max(may, coo[i].second);
}
sort(coo, coo + 3);
cout << (may - miy) + (coo[2].first - coo[0].first) + 1 << endl;
for (int y = miy; y <= may; ++y) {
cout << coo[1].first << " " << y << endl;
}
for (int x = coo[0].first; x < coo[1].first; ++x) {
cout << x << " " << coo[0].second << endl;
}
for (int x = coo[1].first + 1; x <= coo[2].first; ++x) {
cout << x << " " << coo[2].second << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n;
cin >> n;
if (n % 2 == 0)
cout << "NO";
else {
cout << "YES" << endl;
cout << 1 << " ";
for (long long int i = 1, j = 2; i < n and j < n; i = i + 2, j = j + 2) {
cout << n + i << " ";
if (n - j == 1)
cout << 2 * n - 1 << " ";
else
cout << n - j << " ";
}
cout << 2 << " ";
for (long long int i = 0, j = 1; i < n and j < n; i += 2, j += 2) {
cout << n + i << " ";
if (n - j == 2)
cout << 2 * n << " ";
else
cout << n - j << " ";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25e2 + 1, NN = N * N;
pair<int, int> D[NN];
int A[N][N], n, nn, t;
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
return (A[a.first][a.second] > A[b.first][b.second]);
}
bitset<N> B[N];
void SIK() {
printf("NOT MAGIC");
exit(0);
}
int main() {
scanf("%d", &n);
nn = n * n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int w;
scanf("%d", &A[i][j]);
D[t++] = {i, j};
}
sort(D, D + nn, cmp);
for (int i = 0; i < n; i++)
if (A[i][i]) SIK();
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (A[i][j] ^ A[j][i]) SIK();
for (int i = 0, j, k; i < nn; i++) {
for (j = i; j < nn; j++) {
if (A[D[i].first][D[i].second] ^ A[D[j].first][D[j].second]) {
j--;
break;
}
B[D[j].first][D[j].second] = 1;
}
for (k = i; k <= j; k++)
if ((B[D[k].first] | B[D[k].second]).count() ^ n) SIK();
i = j;
}
printf("MAGIC");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, a[105], sum = 1, sum1 = 0;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> a[i];
}
for (int i = 0; i < t; i++) {
sum = 1;
sum1 = 0;
if (a[i] % 2 != 0) {
sum1 = ((a[i] - 1) / 2) * a[i] + a[i];
} else {
sum1 = ((a[i] - 1) / 2) * a[i] + a[i] + a[i] / 2;
}
sum1 -= 2;
for (int j = 0; j < 29; j++) {
sum *= 2;
if (sum > a[i]) {
break;
}
sum1 -= (sum * 2);
}
cout << sum1 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const long long inf = 1000000000000;
int main() {
int n;
cin >> n;
long long w[26] = {0};
bool is[26] = {0};
vector<string> vs;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
vs.push_back(s);
int cnt = 0;
for (int j = s.length() - 1; j >= 0; j--) {
w[s[j] - 97] += pow(10, cnt);
cnt++;
if (j == 0) {
is[s[j] - 97] = 1;
}
}
}
vector<pair<long long, int> > vp;
for (int i = 0; i < 10; i++) {
vp.push_back(make_pair(w[i], i));
}
sort(vp.begin(), vp.end());
reverse(vp.begin(), vp.end());
int num[11];
int cnt = 1;
bool iss = false;
int allot[11];
for (int i = 0; i < vp.size(); i++) {
if (is[vp[i].second] == 0 && iss == false) {
allot[vp[i].second] = 0;
iss = true;
} else {
allot[vp[i].second] = cnt;
cnt++;
}
}
long long sum = 0;
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = vs[i].length() - 1; j >= 0; j--) {
sum += allot[vs[i][j] - 97] * pow(10, cnt);
cnt++;
}
}
cout << sum << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
char ans[100005] = {'\0'};
int curr = 0, len = 0;
ans[0] = 'a';
len++;
curr++;
char ch = 'a';
while (k != 0) {
if (k - curr >= 0) {
k -= curr;
ans[len++] = ch;
curr++;
} else {
ch++;
curr = 0;
}
}
for (int i = 0; i < len; i++) cout << ans[i];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
const int INF = 0x3f3f3f3f;
int n;
long long A[N];
multiset<int> s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &A[i]);
}
long long ans = 0;
for (int i = n; i >= 1; i--) {
if (A[i] == -1) {
break;
}
s.insert(A[i]);
if (!(i & (i - 1))) {
ans += *s.begin();
s.erase(s.begin());
}
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 200005;
int w[M], n, m, ans, sum, bk[M];
bool vis[M];
int main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> w[i];
}
for (int i = 1; i <= m; ++i) {
cin >> bk[i];
for (int j = i - 1; j >= 1; --j) {
if (bk[j] == bk[i]) {
for (int w = i - 1; w >= j; --w) vis[bk[w]] = 0;
break;
}
if (!vis[bk[j]]) sum += w[bk[j]];
vis[bk[j]] = 1;
if (j == 1) {
for (int w = i - 1; w >= j; --w) vis[bk[w]] = 0;
}
}
}
cout << sum << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 3;
long long inf = 1e13 + 1;
void solve() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int &i : a) cin >> i;
for (int &i : b) cin >> i;
for (int &i : c) cin >> i;
int pre = 1e9 + 1;
for (int i = 0; i < n - 1; i++) {
if (a[i] != pre)
cout << a[i] << ' ', pre = a[i];
else
cout << b[i] << ' ', pre = b[i];
}
if (a[n - 1] != a[0] and a[n - 1] != pre)
cout << a[n - 1] << '\n';
else if (b[n - 1] != a[0] and b[n - 1] != pre)
cout << b[n - 1] << '\n';
else
cout << c[n - 1] << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int powfi(long long int a, long long int b) {
long long int c = 1LL;
while (b > 0) {
if (b % 2 == 1) c = ((c % 1000000007) * (a % 1000000007)) % 1000000007;
a = ((a % 1000000007) * (a % 1000000007)) % 1000000007;
b = b / 2;
}
return c;
}
int main() {
int hh, mm;
cin >> hh >> mm;
int h, d, n;
double c;
cin >> h >> d >> c >> n;
double price = (4 * c) / 5;
int buns;
if (h % n == 0)
buns = h / n;
else
buns = (h / n) + 1;
double oneans = buns * c;
if (hh >= 20 && hh <= 23) {
printf("%.4lf", buns * price);
} else {
int min = 60 - mm;
hh++;
min = min + (60 * (20 - hh));
h = h + d * min;
if (h % n == 0)
buns = h / n;
else
buns = (h / n) + 1;
double newans = buns * price;
if (oneans > newans) oneans = newans;
printf("%.4lf", oneans);
}
}
| 1 |
#include <bits/stdc++.h>
int colors1[150], colors2[150];
int main() {
int i, n1, n2, count = 0;
char owns[1005], needs[1005];
scanf("%s", owns);
scanf("%s", needs);
n1 = strlen(owns);
n2 = strlen(needs);
for (i = 0; i < n1; i++) {
colors1[owns[i]]++;
}
for (i = 0; i < n2; i++) {
colors2[needs[i]]++;
}
for (i = 'a'; i <= 'z'; i++) {
if (colors2[i]) {
if (colors1[i] == 0) {
printf("-1\n");
return 0;
} else if (colors1[i] < colors2[i]) {
count += colors1[i];
} else {
count += colors2[i];
}
}
}
printf("%d\n", count);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int &i : a) cin >> i;
long long int sum = 0;
for (int i : a) sum += i;
long long int c = 2 * sum;
long long int b = n;
if (c % b != 0) {
cout << "0\n";
continue;
}
long long int x = c / b;
int N = 2 * 1e5 + 5;
map<int, long long int> freq;
sort(a.begin(), a.end());
for (int i : a) freq[i]++;
int i = 0, j = n - 1;
long long int ans = 0;
while (i <= j && i != j) {
long long int num = a[i] + a[j];
if (num == x) {
if (a[i] == a[j]) {
ans += freq[a[i]] * (freq[a[i]] - 1) / 2;
break;
}
ans += freq[a[i]] * freq[a[j]];
i += freq[a[i]];
j -= freq[a[j]];
}
if (num > x) j--;
if (num < x) i++;
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const double eps = 1e-8;
const double pi = acos(-1.0);
struct Segment {
double l, r;
bool operator<(Segment b) const {
if (fabs(r - b.r) < eps)
return l < b.l;
else
return r < b.r;
}
} seg[200100];
struct Point {
double dis, arg;
} point[200100];
int n, f[30][200100], m;
bool check(double dis) {
for (int i = 1; i <= n; i++) {
if (dis > point[i].dis) return 0;
double angle = acos(dis / point[i].dis);
seg[i] = {point[i].arg - angle, point[i].arg + angle};
if (seg[i].r > pi) seg[i].l -= pi * 2, seg[i].r -= pi * 2;
}
std::sort(seg + 1, seg + n + 1);
for (int i = 1; i <= n; i++)
seg[i + n] = {seg[i].l + pi * 2, seg[i].r + pi * 2};
f[0][2 * n + 1] = 2 * n + 1;
for (int i = 1, j = 0; i <= 2 * n; i++) {
if (j <= i) j = i + 1;
while (j <= 2 * n && seg[j].l < seg[i].r) j++;
f[0][i] = j;
}
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= 2 * n + 1; j++) f[i][j] = f[i - 1][f[i - 1][j]];
for (int i = 1, j; i <= n; i++) {
j = i;
for (int k = 20; k >= 0; k--)
if (m >> k & 1) j = f[k][j];
if (j >= i + n) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= n; i++) {
scanf("%d%d", &x, &y);
point[i].arg = atan2(x, y);
point[i].dis = sqrt(1ll * x * x + 1ll * y * y);
}
double L = 0, R = point[1].dis;
while (R - L > 1e-10) {
double mid = (L + R) / 2;
if (check(mid))
L = mid;
else
R = mid;
}
printf("%.11lf", L);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 1e2 + 10;
long long a[N][N];
int flag[N][N];
long long dp[N][N];
int main() {
int ncase;
scanf("%d", &ncase);
while (ncase--) {
int n, m;
scanf("%d%d", &n, &m);
vector<long long> v;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%lld", &a[i][j]);
a[i][j] -= i + j;
v.push_back(a[i][j]);
}
}
long long ans = 4 * INF * INF;
for (auto &x : v) {
memset((flag), (0), sizeof(flag));
memset((dp), (0x3f), sizeof(dp));
long long inf = dp[0][0];
flag[1][1] = 1;
dp[1][1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] < x) flag[i][j] = 0;
if (flag[i][j] == 0) continue;
dp[i][j] += a[i][j] - x;
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j]);
flag[i + 1][j] |= 1;
flag[i][j + 1] |= 1;
}
}
if (flag[n][m] != 0) ans = min(ans, dp[n][m]);
}
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
int maps[maxn * 2][maxn * 2];
int vis[maxn * 2];
int pre[maxn * 2];
int n1, n2, k;
int n;
int deg[maxn * 2];
int s, t;
vector<int> v[maxn * 2];
vector<int> num[maxn];
int bfs(int s, int t) {
queue<int> q;
memset(vis, 0, sizeof vis);
memset(pre, -1, sizeof pre);
pre[s] = s;
vis[s] = 1;
q.push(s);
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = 0; i <= n1 + n2 + 1; i++) {
if (maps[now][i] && !vis[i]) {
pre[i] = now;
vis[i] = 1;
if (i == t) return 1;
q.push(i);
}
}
}
return 0;
}
int EK() {
int i, j;
int ans = 0;
while (bfs(s, t)) {
int minn = (1 << 31) - 1ll;
for (i = t; i != s; i = pre[i]) {
minn = min(minn, maps[pre[i]][i]);
}
for (i = t; i != s; i = pre[i]) {
maps[pre[i]][i] -= minn;
maps[i][pre[i]] += minn;
}
ans += minn;
}
return ans;
}
vector<int> ans[maxn * 2];
int p[maxn * 2][maxn * 2];
int main() {
int i, j;
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n1 >> n2 >> k;
{
for (i = 0; i < maxn * 2; i++) ans[i].clear(), v[i].clear();
memset(maps, 0, sizeof maps);
memset(p, 0, sizeof(p));
for (i = 1; i <= k; i++) {
int l, r;
cin >> l >> r;
r += n1;
v[l].push_back(r);
p[l][r]++;
num[l].push_back(i);
deg[l]++;
deg[r]++;
}
n = n1 + n2;
int minn = 0x3f3f3f3f;
for (i = 1; i <= n; i++) minn = min(minn, deg[i]);
int mt = minn;
s = 0;
t = n + 1;
while (minn >= 1) {
for (i = 1; i <= n1; i++) {
maps[0][i] = deg[i] - minn;
maps[i][0] = 0;
}
for (i = n1 + 1; i <= n; i++) {
maps[i][n + 1] = deg[i] - minn;
maps[n + 1][i] = 0;
}
for (i = 1; i <= n1; i++) {
for (auto it : v[i]) {
maps[i][it] = p[i][it];
maps[it][i] = 0;
}
}
int QAQ = EK();
for (i = 1; i <= n1; i++) {
for (int j = 0; j < v[i].size(); j++) {
int it = v[i][j];
if (maps[i][it]) {
ans[minn].push_back(num[i][j]), maps[i][it]--;
}
}
}
minn--;
}
cout << 0 << endl;
for (i = 1; i <= mt; i++) {
cout << ans[i].size();
for (auto it : ans[i]) {
cout << " " << it;
}
cout << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int INF = 0x3f3f3f3f;
const long long mod = 998244353;
long long n, k, m;
vector<pair<long long, long long> > a[maxn];
struct tree {
long long l, r;
long long cnt, sum;
} tr[maxn << 2];
void build(long long id, long long l, long long r) {
tr[id].l = l, tr[id].r = r;
if (l == r) {
tr[id].cnt = tr[id].sum = 0;
return;
}
long long mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
}
void push_up(long long id) {
tr[id].cnt = tr[id << 1].cnt + tr[id << 1 | 1].cnt;
tr[id].sum = tr[id << 1].sum + tr[id << 1 | 1].sum;
}
void update(long long id, long long l, long long r, long long c) {
long long l_ = tr[id].l, r_ = tr[id].r;
if (l == l_ && r == r_) {
tr[id].cnt += c;
tr[id].sum += (c * (long long)r);
return;
}
long long mid = (l_ + r_) >> 1;
if (r <= mid) {
update(id << 1, l, r, c);
} else {
update(id << 1 | 1, l, r, c);
}
push_up(id);
}
long long query(long long id, long long x) {
if (tr[id].cnt <= x) return tr[id].sum;
long long l = tr[id].l, r = tr[id].r;
if (l == r) {
long long t = min(x, tr[id].cnt);
return (t * r);
}
if (tr[id << 1].cnt > x) return query(id << 1, x);
return (query(id << 1, tr[id << 1].cnt) +
query(id << 1 | 1, x - tr[id << 1].cnt));
}
int main() {
scanf("%lld%lld%lld", &n, &k, &m);
long long l, r, c, p, ans = 0;
for (int i = 1; i <= m; ++i) {
scanf("%lld%lld%lld%lld", &l, &r, &c, &p);
a[l].push_back(pair<long long, long long>(c, p));
a[r + 1].push_back(pair<long long, long long>(c * -1LL, p));
}
build(1, 1, maxn - 1);
for (int i = 1; i <= n; ++i) {
for (auto x : a[i]) {
update(1, x.second, x.second, x.first);
}
ans += query(1, k);
}
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[20], num, ans;
arr[1] = 7;
arr[2] = 2;
arr[3] = arr[4] = 3;
arr[5] = 4;
arr[6] = 2;
arr[7] = 5;
arr[8] = 1;
arr[9] = arr[0] = 2;
cin >> num;
ans = arr[num % 10];
num /= 10;
ans *= arr[num];
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e3 + 10;
const int INF = 1e9 + 9;
const int B = 1e9 + 7;
int di[] = {+1, 0, -1, 0, -1, -1, +1, +1};
int dj[] = {0, -1, 0, +1, -1, +1, -1, +1};
int u[N][N];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
pair<long long, long long> p[4];
for (int i = int(1); i <= int(3); ++i) cin >> p[i].first >> p[i].second;
queue<pair<long long, long long> > q;
q.push({p[2]});
while (q.size()) {
int first = q.front().first, second = q.front().second;
u[first][second] = 1;
q.pop();
for (int dir = int(0); dir <= int(7); ++dir) {
int i = first + di[dir], j = second + dj[dir];
if (1 <= i && i <= n && 1 <= j && j <= n && !u[i][j] &&
j != p[1].second && i != p[1].first &&
abs(p[1].first - i) != abs(p[1].second - j)) {
u[i][j] = 1;
q.push({i, j});
}
}
}
cout << (u[p[3].first][p[3].second] ? "YES\n" : "NO\n") << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int graph[6][6] = {0};
int m;
int x, y;
bool is_three_pair_wise = false;
for (cin >> m; m; m--) {
cin >> x >> y;
graph[x][y] = 1;
graph[y][x] = 1;
}
for (int i = 1; i <= 3; i++) {
for (int j = i + 1; j <= 4; j++) {
for (int k = j + 1; k <= 5; k++)
if ((graph[i][j] == 0 && graph[i][k] == 0 && graph[j][k] == 0) ||
((graph[i][j] == 1 && graph[i][k] == 1 && graph[j][k] == 1))) {
is_three_pair_wise = true;
break;
}
if (is_three_pair_wise) break;
}
if (is_three_pair_wise) break;
}
if (is_three_pair_wise)
cout << "WIN";
else
cout << "FAIL";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100 + 9];
int d, dist[100 + 9][100 + 9], x[100 + 9], y[100 + 9];
int main() {
cin >> n >> d;
for (int i = 1; i < n - 1; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
dist[i][j] = ((abs(x[i] - x[j]) + abs(y[i] - y[j])) * d) - a[j];
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
cout << dist[0][n - 1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long n, ctr = 1;
long long a[N], bit[N];
map<long long, long long> m;
void update(long long i, long long x) {
while (i <= n) {
bit[i] = max(bit[i], x);
i += (i & (-i));
}
}
long long prefmax(long long i) {
long long ans = 0;
while (i > 0) {
ans = max(ans, bit[i]);
i -= (i & (-i));
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]];
}
for (auto &it : m) {
it.second = ctr++;
}
for (long long i = 1; i <= n; i++) {
a[i] = m[a[i]];
}
m.clear();
for (long long i = 1; i <= n; i++) {
update(a[i], i);
}
for (long long i = 1; i <= n; i++) {
long long last = prefmax(a[i] - 1);
if (last < i)
cout << "-1 ";
else
cout << last - i - 1 << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
using v = vector<T>;
const ll INF = numeric_limits<ll>::max() / 10 * 9;
const ll TREES = 1e5;
const ll N = 2 * TREES;
ll heights[TREES + 1];
ll dists[TREES + 1];
ll vals[N + 1][2];
struct State {
ll bigsum, biglhs, bigrhs;
};
State seg[4 * N];
inline State merge(const State &lhs, const State &rhs) {
const ll bigsum = max({lhs.bigsum, rhs.bigsum, lhs.biglhs + rhs.bigrhs});
const ll biglhs = max(lhs.biglhs, rhs.biglhs);
const ll bigrhs = max(lhs.bigrhs, rhs.bigrhs);
return State{bigsum, biglhs, bigrhs};
}
void build(ll v, ll vl, ll vr) {
if (vl == vr) {
seg[v].bigsum = -INF;
seg[v].biglhs = vals[vl][0];
seg[v].bigrhs = vals[vl][1];
return;
}
const ll vm = (vl + vr) >> 1;
build(2 * v, vl, vm);
build(2 * v + 1, vm + 1, vr);
seg[v] = merge(seg[2 * v], seg[2 * v + 1]);
}
State query(ll v, ll vl, ll vr, ll left, ll right) {
if (left > right) {
return State{-INF, -INF, -INF};
}
if (left == vl && right == vr) {
return seg[v];
}
const ll vm = (vl + vr) >> 1;
const State lhs = query(2 * v, vl, vm, left, min(vm, right));
const State rhs = query(2 * v + 1, vm + 1, vr, max(vm + 1, left), right);
if (lhs.biglhs == -INF) {
return rhs;
} else if (rhs.biglhs == -INF) {
return lhs;
}
return merge(lhs, rhs);
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
ll n, m;
cin >> n >> m;
for (ll i = 1; i <= n; i++) {
cin >> dists[i];
}
for (ll i = 1; i <= n; i++) {
cin >> heights[i];
}
ll distance = 0;
for (ll i = 1; i <= 2 * n; i++) {
ll idx = ((i - 1) % n) + 1;
vals[i][0] = 2 * heights[idx] - distance;
vals[i][1] = 2 * heights[idx] + distance;
distance += dists[idx];
}
build(1, 1, 2 * n);
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
if (a <= b) {
const State res = query(1, 1, 2 * n, b + 1, n + a - 1);
cout << res.bigsum << "\n";
} else {
const State res = query(1, 1, 2 * n, b + 1, a - 1);
cout << res.bigsum << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e5 + 5;
const int Mod = 1e9 + 7;
long long data[Max], ndata[2][Max];
int main() {
std::ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long sum = 0, osum = 0;
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < n; i++) {
cin >> data[i];
if (i & 1) {
ndata[0][cnt1++] = data[i] - data[i - 1];
} else {
sum += data[i];
if (i) ndata[1][cnt2++] = data[i - 1] - data[i];
}
}
long long minn = 0, per = 0, sub = 0, ans = 0;
for (int i = 0; i < cnt1; i++) {
per += ndata[0][i];
minn = min(minn, per);
sub = max(sub, per - minn);
}
ans = sum + sub;
per = 0;
minn = 0;
for (int i = 0; i < cnt2; i++) {
per += ndata[1][i];
minn = min(minn, per);
sub = max(sub, per - minn);
}
ans = max(ans, sum + sub);
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 50;
const int mod = 1e9 + 7;
const int inf = (1 << 30);
int nex[maxn], a[maxn], b[maxn], ans[maxn], seg[4 * maxn];
vector<int> v[maxn];
int get(int id, int L, int R, int l, int r) {
if (L == l and R == r) return seg[id];
int mid = (L + R) / 2;
int ret = 0;
if (mid > l) ret += get(2 * id + 0, L, mid, l, min(mid, r));
if (mid < r) ret += get(2 * id + 1, mid, R, max(l, mid), r);
return ret;
}
void change(int id, int L, int R, int x, int val) {
seg[id] += val;
if (L + 1 == R) return;
int mid = (L + R) / 2;
if (mid > x)
change(2 * id + 0, L, mid, x, val);
else
change(2 * id + 1, mid, R, x, val);
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]] = n + 2;
}
for (int i = n; i >= 1; i--) {
nex[i] = b[a[i]];
b[a[i]] = i;
}
for (int i = 1; i <= n; i++) change(1, 1, n + 2, nex[i], 1);
for (int i = 1; i <= n; i++) v[1].push_back(i);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < v[i].size(); j++) {
int idx = i;
int l = idx, r = n + 1;
while (r - l > 1) {
int mid = (l + r) / 2;
int tmp = get(1, 1, n + 2, mid + 1, n + 2);
if (tmp - (n - mid) <= v[i][j])
l = mid;
else
r = mid;
}
v[r].push_back(v[i][j]);
ans[v[i][j]]++;
}
change(1, 1, n + 2, nex[i], -1);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline void rd(int &res) {
res = 0;
char c;
while (c = getchar(), c < 48)
;
do res = (res << 1) + (res << 3) + (c ^ 48);
while (c = getchar(), c >= 48);
}
inline void print(int x) {
if (!x) return;
print(x / 10);
putchar((x % 10) ^ 48);
}
inline void sc(int x) {
if (x < 0) {
x = -x;
putchar('-');
}
print(x);
if (!x) putchar('0');
putchar('\n');
}
inline void Max(int &x, int y) {
if (x < y) x = y;
}
inline void Min(int &x, int y) {
if (x > y) x = y;
}
const int M = 1e5 + 5;
int cnt[M], pos[M], mark[M], ed[M], id[M], g[M], head[M], val[M], A[M], fa[M],
sum[M];
int dis[M], n, m, ID1, ID2, D, ec = 0, tot = 0, po = 0;
struct Edge {
int to, v, nex;
} e[M << 1];
struct node {
int val, p;
} Q[M];
bool cmp(node a, node b) { return a.val > b.val; }
void add_edge(int a, int b, int c) {
e[ec] = (Edge){b, c, head[a]};
head[a] = ec++;
e[ec] = (Edge){a, c, head[b]};
head[b] = ec++;
}
void dfs(int x, int f, int d, int v) {
if (d >= D) {
D = d;
ID1 = x;
}
ed[x] = v;
fa[x] = f;
for (int i = head[x]; ~i; i = e[i].nex) {
int y = e[i].to;
if (y == f) continue;
dfs(y, x, d + e[i].v, e[i].v);
}
}
void rdfs(int h, int x, int f, int v, int d) {
id[x] = h;
g[x] = x;
fa[x] = f;
ed[x] = v;
dis[x] = d;
for (int i = head[x]; ~i; i = e[i].nex) {
int y = e[i].to;
if (y == f || mark[y]) continue;
rdfs(h, y, x, e[i].v, d + e[i].v);
if (dis[g[y]] > dis[g[x]]) g[x] = g[y];
}
}
void rdfs2(int x, int f, int an, int d) {
fa[x] = an;
for (int i = head[x]; ~i; i = e[i].nex) {
int y = e[i].to;
if (f == y || mark[y]) continue;
if (g[x] == g[y])
rdfs2(y, x, an, d + e[i].v);
else
rdfs2(y, x, x, e[i].v);
}
if (g[x] == x && !mark[x]) Q[++po] = (node){d, x};
}
void solve() {
dfs(1, -1, 0, 0);
ID2 = ID1;
dfs(ID2, -1, 0, 0);
int i, j, k, x, y, a, b, c = 0, ans, res, w;
x = ID1;
while (x != -1) {
id[x] = ++tot;
A[tot] = x;
mark[x] = 1;
val[x] = c;
c += ed[x];
x = fa[x];
}
for (i = 1; i <= tot; i++) {
rdfs(i, A[i], A[i], 0, 0);
rdfs2(A[i], A[i], A[i], 0);
}
sort(Q + 1, Q + 1 + po, cmp);
for (i = 1; i <= po; i++) {
pos[Q[i].p] = i;
sum[i] = sum[i - 1] + Q[i].val;
}
sum[po + 1] = sum[po];
for (j = 1; j <= m; j++) {
rd(x);
rd(y);
if (j > 1) {
x = (x + ans - 1) % n + 1;
y = (y + ans - 1) % n + 1;
}
y = min((y - 1) * 2, po + 1);
if (mark[x])
ans = D + sum[y];
else {
ans = 0, w = id[x], res = min(val[A[id[x]]], D - val[A[id[x]]]);
int k = y + 1, mi = Q[y].val, a = g[x], b = 0, tmp = 0;
ans = D - res + dis[g[x]] + sum[y];
if (!y) {
sc(ans);
continue;
}
cnt[k] = 0;
while (!mark[a]) {
if (pos[g[a]] <= y) {
ans -= dis[g[a]];
b = max(dis[g[a]] - dis[a], Q[k].val - cnt[k]);
ans += b;
Min(mi, b);
break;
}
cnt[pos[g[a]]] += dis[a] - dis[fa[a]];
a = fa[a];
}
if (res > mi) ans += res - mi;
}
sc(ans);
}
}
int main() {
memset(head, -1, sizeof(head));
rd(n);
rd(m);
int i, j, a, b, c;
for (i = 1; i < n; i++) {
rd(a);
rd(b);
rd(c);
add_edge(a, b, c);
}
solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100005];
char s[100005];
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= n; i++) a[i] = s[i - 1] - '0';
for (int i = 1; i <= n; i++) {
if (a[i] == 4 && a[i + 1] == 7 && a[i + 2] == 7 && i % 2 == 1) k %= 2;
if (k == 0)
break;
else {
if (a[i] == 4 && a[i + 1] == 7) {
if (i % 2 == 0) {
a[i] = 7;
k--;
i -= 2;
} else if (i % 2 == 1) {
a[i + 1] = 4;
k--;
i -= 2;
}
}
}
}
for (int i = 1; i <= n; i++) printf("%d", a[i]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt1, cnt2;
int main(int argc, char** argv) {
string a, b;
cin >> a >> b;
cnt1 = cnt2 = 0;
for (int i = 0; i < a.length(); i++) {
if (a[i] == '1') cnt1++;
}
for (int i = 0; i < b.length(); i++) {
if (b[i] == '1') cnt2++;
}
if (cnt1 + cnt1 % 2 >= cnt2) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10000000], f[10000000];
int main() {
long long int x, n, sum = 0;
long long int i;
cin >> n >> x;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
sum += f[a[i] ^ x];
f[a[i]]++;
}
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct o {
int x;
int y;
int z;
};
long a[1000][1000] = {0}, n, rt[7], f = 0, d[100000], e[100000];
o b[10000];
void dfs(int v) {
for (int k = 0; k <= 6; ++k)
if (a[v][k] > 0) {
--a[v][k];
--a[k][v];
dfs(k);
}
++f;
d[f] = v;
return;
}
int main() {
cin >> n;
for (int k = 1; k <= n; ++k) {
long x, y;
cin >> x >> y;
++a[x][y];
++a[y][x];
b[k].x = x;
b[k].y = y;
++rt[x];
++rt[y];
b[k].z = 0;
}
if (n == 1) {
cout << 1 << ' ' << '+';
return 0;
}
string t;
long kenti = 0, gamo = -1123;
for (int k = 0; k <= 6; ++k)
if (rt[k] % 2 == 1) {
++kenti;
gamo = k;
}
if (kenti > 2) {
cout << "No solution";
return 0;
}
if (gamo == -1123)
for (int k = 0; k <= 6; ++k)
if (rt[k] > 0) {
gamo = k;
}
dfs(gamo);
long s = 0;
for (int k = f; k > 1; --k) {
long d1 = 0;
for (int i = 1; i <= n; ++i) {
if (d[k - 1] == b[i].y && d[k] == b[i].x && b[i].z != -1) {
++d1;
t = t + '+';
++s;
e[s] = i;
b[i].z = -1;
break;
} else if (d[k - 1] == b[i].x && d[k] == b[i].y && b[i].z != -1) {
b[i].z = -1;
++d1;
++s;
t = t + '-';
e[s] = i;
break;
}
}
if (d1 == 0) {
cout << "No solution";
return 0;
}
}
for (int k = 1; k <= n; ++k)
if (b[k].z != -1) {
cout << "No solution";
return 0;
}
for (int k = 1; k <= s; ++k) cout << e[k] << ' ' << t[k - 1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long N, M;
long long X[200000], T[200000];
long long P[200000], B[200000];
vector<long long> x;
const int n = 1 << 19;
struct SegTree {
pair<long long, long long> dat[n * 2 - 1];
SegTree() {
for (long long(i) = 0; (i) < (n * 2 - 1); (i)++)
dat[i] = make_pair(1LL << 61, 1LL << 61);
}
void update(long long a, long long b, long long k, long long l, long long r,
pair<long long, long long> t) {
if (r <= a || b <= l) return;
if (a <= l && r <= b)
dat[k] = min(dat[k], t);
else {
update(a, b, k * 2 + 1, l, (l + r) / 2, t);
update(a, b, k * 2 + 2, (l + r) / 2, r, t);
}
}
long long getid(long long k) {
k += n - 1;
pair<long long, long long> res = dat[k];
while (k) k = (k - 1) / 2, res = min(res, dat[k]);
return res.second;
}
} seg;
multiset<pair<long long, long long> > st;
long long cnt[200000];
int main() {
scanf("%I64d%I64d", &N, &M);
for (long long(i) = 0; (i) < (N); (i)++)
scanf("%I64d%I64d", &X[i], &T[i]), x.push_back(X[i]);
for (long long(i) = 0; (i) < (M); (i)++)
scanf("%I64d%I64d", &P[i], &B[i]), x.push_back(P[i]);
sort((x).begin(), (x).end());
x.erase(unique((x).begin(), (x).end()), x.end());
;
for (long long(i) = 0; (i) < (N); (i)++)
X[i] = lower_bound((x).begin(), (x).end(), X[i]) - x.begin();
for (long long(i) = 0; (i) < (M); (i)++)
P[i] = lower_bound((x).begin(), (x).end(), P[i]) - x.begin();
for (long long(i) = 0; (i) < (N); (i)++)
seg.update(
X[i],
lower_bound((x).begin(), (x).end(), x[X[i]] + T[i] + 1) - x.begin(), 0,
0, n, make_pair(X[i], i));
for (long long(i) = 0; (i) < (M); (i)++) {
long long id = seg.getid(P[i]);
if (0 <= id && id < N) {
T[id] += B[i];
cnt[id]++;
seg.update(
X[id],
lower_bound((x).begin(), (x).end(), x[X[id]] + T[id] + 1) - x.begin(),
0, 0, n, make_pair(X[id], id));
while (1) {
multiset<pair<long long, long long> >::iterator it =
st.lower_bound(make_pair(x[X[id]], -1));
if (it == st.end() || it->first > x[X[id]] + T[id]) break;
T[id] += it->second;
cnt[id]++;
st.erase(it);
seg.update(X[id],
lower_bound((x).begin(), (x).end(), x[X[id]] + T[id] + 1) -
x.begin(),
0, 0, n, make_pair(X[id], id));
}
} else
st.insert(make_pair(x[P[i]], B[i]));
}
for (long long(i) = 0; (i) < (N); (i)++)
printf("%I64d %I64d\n", cnt[i], T[i]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int Q, N, K;
vector<pair<int, int> > G[5 << 17];
pair<long long, long long> dfs(int u, int p) {
vector<long long> A;
long long ret = 0;
for (const pair<int, int>& q : G[u]) {
if (q.first == p) continue;
pair<long long, long long> r = dfs(q.first, u);
ret += r.second + q.second;
A.push_back(r.first - r.second - q.second);
}
sort(A.begin(), A.end());
while (!A.empty() && A.back() >= 0) {
ret += A.back();
A.pop_back();
}
while (A.size() > K) {
ret += A.back();
A.pop_back();
}
if (A.size() < K)
return make_pair(ret, ret);
else
return make_pair(ret, ret + A.back());
}
int main() {
scanf("%d", &Q);
for (; Q--;) {
scanf("%d%d", &N, &K);
for (int i = 0; i < N; i++) G[i].clear();
for (int i = 1; i < N; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
u--, v--;
G[u].push_back(make_pair(v, w));
G[v].push_back(make_pair(u, w));
}
pair<long long, long long> p = dfs(0, -1);
printf("%lld\n", max(p.first, p.second));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double epsilon = 1e-9;
const bool indebug = false;
int main() {
if (indebug) freopen("bobi.in", "r", stdin);
int numTests = 1;
if (indebug) cin >> numTests;
for (int o = 0; o < numTests; o++) {
long long n, m, a, d;
cin >> n >> m >> a >> d;
vector<long long> x(m);
for (int i = 0; i < m; i++) cin >> x[i];
int answer;
if (indebug) cin >> answer;
sort(x.begin(), x.end());
long long k = d / a + 1;
long long prev = 0;
long long cnt = 0;
long long coveredUntil = 0;
for (int i = 0; i < m; i++) {
if (coveredUntil >= x[i]) continue;
if (x[i] < (prev + 1) * a) {
cnt++;
prev = ((x[i] + d) / a);
coveredUntil = x[i] + d;
continue;
}
long long num = max((x[i] - prev * a) / (k * a) - 1, 0LL);
if (num * k + prev <= n)
cnt += num;
else
cnt += max(0LL, (n - prev + k - 1) / k);
prev = prev + num * k;
if (x[i] >= (prev + 1) * a && x[i] <= (prev + 1) * a + d &&
prev + 1 <= n) {
cnt++;
coveredUntil = (prev + 1) * a + d;
prev = coveredUntil / a;
continue;
} else {
if (prev + 1 <= n) {
cnt++;
coveredUntil = (prev + 1) * a + d;
prev = ((prev + 1) * a + d) / a;
}
if (prev + 1 <= n && (prev + 1) * a < x[i]) {
cnt++;
coveredUntil = (prev + 1) * a + d;
prev = ((prev + 1) * a + d) / a;
} else {
cnt++;
prev = ((x[i] + d) / a);
coveredUntil = x[i] + d;
}
}
}
if (prev < n) {
cnt += (n - prev + k - 1) / k;
}
if (indebug) {
if (cnt != answer) {
cerr << "Failed test: " << o + 1 << " expected " << answer << " got "
<< cnt << endl;
}
}
cout << cnt << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int a, b, l, r;
bool operator<(const Edge& other) const { return r > other.r; }
};
Edge es[3100];
int fa[3100];
int Find(int x) {
while (fa[x] != x) {
x = fa[x];
}
return x;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i, j;
for (i = 0; i < m; ++i) {
scanf("%d%d%d%d", &es[i].a, &es[i].b, &es[i].l, &es[i].r);
}
sort(es, es + m);
int ans = 0;
for (i = 0; i < m; ++i) {
for (j = 1; j <= n; ++j) {
fa[j] = j;
}
for (j = 0; j < m; ++j) {
if (es[j].l <= es[i].l) {
int x = Find(es[j].a);
int y = Find(es[j].b);
if (x != y) {
fa[x] = y;
}
if (Find(1) == Find(n)) {
ans = max(ans, es[j].r - es[i].l + 1);
break;
}
}
}
}
if (ans == 0)
printf("Nice work, Dima!\n");
else
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> k;
vector<vector<int> > g;
vector<pair<long long, int> > f;
void dfs(int v, int p = -1) {
f[v] = pair<long long, int>(0, k[v]);
if (v != p) f[v].second--;
if (g[v].empty() || (g[v].size() == 1 && g[v][0] == p)) return;
vector<pair<long long, int> > d;
for (size_t i = 0; i < g[v].size(); i++) {
if (g[v][i] == p) continue;
dfs(g[v][i], v);
d.push_back(pair<long long, int>(f[g[v][i]]));
}
sort(d.begin(), d.end(), greater<pair<long long, int> >());
for (size_t i = 0; i < d.size() && f[v].second > 0; i++) {
f[v].first += d[i].first + 2;
f[v].second--;
}
for (size_t i = 0; i < d.size() && f[v].second > 0; i++) {
int w = min(f[v].second, d[i].second);
f[v].first += w * 2;
f[v].second -= w;
}
}
int main() {
int n;
cin >> n;
k.resize(n);
for (int i = 0; i < n; i++) cin >> k[i];
g.resize(n);
f.resize(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
int s;
cin >> s;
s--;
dfs(s, s);
cout << f[s].first << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
void choose(int x, int y) { printf("%d %d\n", x + 1, y + 1); }
int main() {
int w, h;
scanf("%d %d", &w, &h);
for (int x = 0; x < w / 2; x++) {
for (int y = 0; y < h; y++) {
choose(x, y);
choose(w - x - 1, h - y - 1);
}
}
if (w % 2 == 1) {
for (int y = 0; y < h; y++) {
choose(w / 2, y % 2 == 0 ? y / 2 : h - y / 2 - 1);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int daoskdoa[51], aodksao[51], dksaopdoa[51], dosakdosa[51];
vector<int> x, y;
struct edge {
int to, cap, rev;
};
int V;
vector<edge> G[2005];
int level[2005];
int iter[2005];
void add_edge(int from, int to, int cap) {
G[from].push_back((edge){to, cap, (int)G[to].size()});
G[to].push_back((edge){from, 0, (int)G[from].size() - 1});
}
void bfs(int s) {
memset(level, -1, sizeof(level));
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
int dfs(int v, int t, int f) {
if (v == t) return f;
for (int &i = iter[v]; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (level[v] < level[e.to] && e.cap > 0) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t) {
int flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0) return flow;
memset(iter, 0, sizeof(iter));
int f;
while ((f = dfs(s, t, 1000000000)) > 0) flow += f;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &daoskdoa[i], &dksaopdoa[i], &aodksao[i], &dosakdosa[i]);
aodksao[i]++;
dosakdosa[i]++;
x.push_back(daoskdoa[i]);
x.push_back(aodksao[i]);
y.push_back(dksaopdoa[i]);
y.push_back(dosakdosa[i]);
}
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
sort(y.begin(), y.end());
y.erase(unique(y.begin(), y.end()), y.end());
V = (int)x.size() + (int)y.size();
int s = (int)x.size() + (int)y.size() - 1, t = (int)x.size() + (int)y.size();
for (int i = 1; i < (int)x.size(); i++) add_edge(s, i, x[i] - x[i - 1]);
for (int i = 1; i < (int)y.size(); i++)
add_edge(i + (int)x.size() - 1, t, y[i] - y[i - 1]);
for (int i = 0; i < m; i++) {
int l1 = lower_bound(x.begin(), x.end(), daoskdoa[i]) - x.begin(),
r1 = lower_bound(x.begin(), x.end(), aodksao[i]) - x.begin();
int l2 = lower_bound(y.begin(), y.end(), dksaopdoa[i]) - y.begin(),
r2 = lower_bound(y.begin(), y.end(), dosakdosa[i]) - y.begin();
for (int i = l1 + 1; i <= r1; i++)
for (int j = l2 + 1; j <= r2; j++)
add_edge(i, (int)x.size() - 1 + j, 1000000000);
}
printf("%d\n", max_flow(s, t));
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int fin = 0, maxn = 1000010;
int n;
char s[maxn];
int left[maxn], st[maxn];
struct rec {
bool a[3];
rec() {}
rec(bool x, bool y, bool z) { a[0] = x, a[1] = y, a[2] = z; }
const bool& operator[](const int& x) { return a[x]; }
};
inline rec sol(int l, int r) {
if (l == r)
if (s[l] == '0')
return rec(1, 0, 0);
else if (s[l] == '1')
return rec(0, 1, 0);
else if (s[l] == '?')
return rec(0, 0, 1);
int p = s[r - 1] == ')' ? left[r - 1] - 1 : r - 2;
rec a = sol(l + 1, p - 1), b = sol(p + 1, r - 1);
if (s[p] == '&')
return rec(a[0] || b[0] || a[2] && b[2], a[1] && b[1],
a[1] && b[2] || a[2] && b[1] || a[2] && b[2]);
else if (s[p] == '|')
return rec(a[0] && b[0], a[1] || b[1] || a[2] && b[2],
a[0] && b[2] || a[2] && b[0] || a[2] && b[2]);
else
return rec(a[0] && b[0] || a[1] && b[1] || a[2] && b[2],
a[0] && b[1] || a[1] && b[0] || a[2] && b[2],
a[2] && (b[0] || b[1]) || (a[0] || a[1]) && b[2]);
}
int main() {
if (fin) {
freopen("t.in", "r", stdin);
freopen("t.out", "w", stdout);
}
int i;
scanf("%*d\n%s", s), n = strlen(s);
for (i = 0; i < n; ++i)
if (s[i] == '(')
st[++st[0]] = i;
else if (s[i] == ')')
left[i] = st[st[0]--];
rec ans = sol(0, n - 1);
puts(ans[2] ? "YES" : "NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
scanf("%d%d", &n, &m);
if (m != n)
printf("No\n");
else
printf("Yes\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, i, t;
cin >> n;
long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (a[0] == 0) a[0] = a[1];
if (n >= 2) {
if (a[n - 2] - a[0] < a[n - 1] - a[1])
t = a[n - 2] - a[0];
else
t = a[n - 1] - a[1];
cout << t;
} else
cout << 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s, r;
char p[1234567];
vector<string> v, ans;
int main() {
int n;
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
int temp = s[i] - '0', temp1 = 0, temp2 = 0;
if (temp > 0) {
temp = 10 - temp;
}
r = s;
for (int j = 0; j < n; j++) {
temp1 = temp + (int)(r[j] - '0');
if (temp1 > 9) temp1 = (temp1) % 10;
r[j] = '0' + temp1;
}
v.push_back(r);
}
int c = 0;
for (int i = 0; i < n; i++) {
c = 0;
r = v[i];
while (c < n) {
p[c] = r[(c + i) % n];
c++;
}
p[n] = '\0';
ans.push_back(p);
}
sort(ans.begin(), ans.end());
cout << ans[0] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
int dp[2005][2005];
int main() {
memset(dp, 0, sizeof(dp));
for (int i = 0; i < 1005; i++) dp[i][0] = 1;
for (int i = 1; i < 1005; i++)
for (int j = 1; j < 1005; j++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % 1000000007;
int n, m, k;
cin >> n >> m >> k;
long long a = dp[n - 1][2 * k];
long long b = dp[m - 1][2 * k];
cout << (a * b) % 1000000007 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
constexpr int lc = 20;
bool lines[lc][lc];
bool visited[lc];
bool dfs(int i) {
if (visited[i]) return false;
visited[i] = true;
for (int j = 0; j < lc; ++j)
if (lines[i][j] || lines[j][i]) dfs(j);
return true;
}
int main() {
using namespace std;
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
for (int i = 0; i < lc; ++i)
for (int j = 0; j < lc; ++j) lines[i][j] = false;
for (int i = 0; i < lc; ++i) visited[i] = false;
int n;
cin >> n;
string a, b;
cin >> a >> b;
for (int i = 0; i < n; ++i) {
int x = a[i] - 'a';
int y = b[i] - 'a';
lines[x][y] = true;
}
for (int i = 0; i < lc; ++i) lines[i][i] = false;
static unsigned predecessors[lc];
for (int i = 0; i < lc; ++i) {
predecessors[i] = 0u;
unsigned x = 1u;
for (int j = 0; j < lc; ++j, x <<= 1)
if (lines[j][i]) predecessors[i] |= x;
}
constexpr unsigned max_mask = 1u << lc;
static bool acyclic[max_mask];
acyclic[0] = true;
int bestSize = 0;
for (unsigned mask = 1; mask < max_mask; ++mask) {
acyclic[mask] = false;
unsigned x = 1u;
int currSize = 0;
for (int i = 0; i <= lc; ++i, x <<= 1)
if (x & mask) {
++currSize;
acyclic[mask] = acyclic[mask] ||
((mask & predecessors[i]) == 0 && acyclic[mask ^ x]);
}
if (acyclic[mask]) bestSize = max(bestSize, currSize);
}
int components = 0;
for (int i = 0; i < lc; ++i) components += dfs(i);
cout << (2 * lc - bestSize - components) << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename TYPE>
inline TYPE sqr(const TYPE& a) {
return (a) * (a);
}
const int INF = 1000 * 1000 * 1000;
const long double EPS = 1e-9;
const long double PI = 2 * acos(0.0);
const int N = 2100;
int to[N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < int(n); ++i) {
scanf("%d", to + i);
}
sort(to, to + n);
int j = n - 1;
int t = 0;
while (j >= 0) {
t += to[j] - 1;
j -= min(k, j + 1);
}
printf("%d\n", t * 2);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXINT = numeric_limits<int>::max();
const long long MAXLONGLONG = numeric_limits<long long>::max();
const double PI = 3.14159265;
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
string P;
int b[110];
int n;
void kmpPreprocess() {
int i = 0, j = -1;
b[0] = -1;
while (i < n) {
while (j >= 0 && P[i] != P[j]) j = b[j];
i++;
j++;
b[i] = j;
}
}
int main() {
cin >> n >> P;
int sol = 1;
int mx = 0;
for (int i = 1; i < n; i++) {
if (P[i] == P[0]) {
int j = 0;
int cn = 0;
while (j < i && P[i + j] == P[j]) {
j++;
cn++;
}
if (cn == i) {
mx = max(mx, i);
}
}
}
if (mx != 0)
cout << n - mx + 1;
else
cout << n;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int mat[110][110];
int n, m, q;
void cr(int k) {
int t = mat[k][m];
for (int i = m; i >= 2; i--) mat[k][i] = mat[k][i - 1];
mat[k][1] = t;
}
void cc(int k) {
int t = mat[n][k];
for (int i = n; i >= 2; i--) mat[i][k] = mat[i - 1][k];
mat[1][k] = t;
}
void print() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << mat[i][j] << " ";
cout << endl;
}
}
struct com {
int t;
int r, c;
int x;
} Q[(int)1e4 + 5];
int main() {
while (cin >> n >> m >> q) {
memset(mat, 0, sizeof(mat));
for (int i = 0; i < q; i++) {
int t;
cin >> t;
Q[i].t = t;
if (t == 1)
cin >> Q[i].r;
else if (t == 2)
cin >> Q[i].c;
else
cin >> Q[i].r >> Q[i].c >> Q[i].x;
}
for (int i = q - 1; i >= 0; i--) {
int t = Q[i].t;
if (t == 1)
cr(Q[i].r);
else if (t == 2)
cc(Q[i].c);
else
mat[Q[i].r][Q[i].c] = Q[i].x;
}
print();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n--;
string s1, s2;
cin >> s1 >> s2;
reverse(s1.begin(), s1.end());
for (int i = 0; i < n; i++)
if (s1[i] == 'E')
s1[i] = 'W';
else if (s1[i] == 'W')
s1[i] = 'E';
else if (s1[i] == 'N')
s1[i] = 'S';
else if (s1[i] == 'S')
s1[i] = 'N';
long long h1 = 0, h2 = 0, C = 1;
for (int i = 0; i < n; i++) {
h1 = h1 + C * (long long)s1[i];
h2 = h2 * 29 + (long long)s2[n - i - 1];
C *= 29;
if (h1 == h2) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tostr(const T& t) {
ostringstream os;
os << t;
return os.str();
}
const long long INF = 1000000000000000000LL;
long long T[2002], C[2002];
int main(int argc, char* argv[]) {
long long n, m, l, r, t, c, res = 0;
cin >> n >> m;
memset(T, 0x3f, sizeof(T));
memset(C, 0, sizeof(C));
for (int i = 0; i < m; ++i) {
cin >> l >> r >> t >> c;
for (int j = l; j <= r; ++j) {
if (t < T[j]) {
T[j] = t;
C[j] = c;
}
}
}
for (int i = 1; i <= n; ++i) res += C[i];
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e7) + 5;
int A[maxn], p[maxn], mark[maxn];
void pre() {
for (int i = 0; i < maxn; i++) p[i] = 1;
for (int i = 2; i < maxn; i++) {
if (p[i] == 1) {
for (int j = i * 2; j < maxn; j += i) p[j] = max(p[j], i);
}
}
}
void factorise(int v, vector<int>& A) {
if (v == 1) return;
int tmp = p[v];
if (tmp == 1) {
A.push_back(v);
return;
}
while (v % tmp == 0) v /= tmp;
A.push_back(tmp);
factorise(v, A);
}
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
pre();
set<int> cur;
int ptr = n;
for (int i = 0; i < n; i++) {
vector<int> fac;
factorise(A[i], fac);
bool rekt = 0;
for (auto it : fac) {
if (cur.find(it) != cur.end()) {
rekt = 1;
break;
}
}
if (rekt) {
ptr = i;
break;
} else {
for (auto it : fac) cur.insert(it);
}
}
mark[0] = mark[1] = 1;
for (auto it : cur) {
for (int j = it; j < maxn; j += it) mark[j] = 1;
}
int curv = A[ptr];
for (int i = ptr; i < n; i++) {
while (mark[curv]) curv++;
A[i] = curv++;
vector<int> tmp;
factorise(A[i], tmp);
for (auto it : tmp) {
for (int j = it; j < maxn; j += it) mark[j] = 1;
}
if (i == ptr) curv = 2;
}
for (int i = 0; i < n; i++) printf("%d ", A[i]);
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[5010];
int L[5010];
int R[5010];
int Ok[5010];
int D[5010];
int M[5010];
int RDp[5010][5010];
int LDp[5010][5010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (Ok[a[i]] == 0) {
L[a[i]] = i;
Ok[a[i]] = 1;
}
}
memset(Ok, 0, sizeof(Ok));
for (int i = n; i >= 1; i--) {
if (Ok[a[i]] == 0) {
M[i] = 1;
R[a[i]] = i;
Ok[a[i]] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (M[i] == 1) {
memset(Ok, 0, sizeof(Ok));
int l, r;
l = L[a[i]];
r = R[a[i]];
int Cur = 0;
bool tf = 0;
int st = l;
int ed = r;
int new_st = 1e9;
while (st <= ed) {
if (R[a[st]] > r) {
tf = 1;
break;
}
new_st = min(L[a[st]], new_st);
if (st == ed) {
if (new_st < L[a[st]]) {
ed = st - 1;
st = new_st;
}
}
st++;
}
if (tf == 1) {
D[i] = D[i - 1];
continue;
} else {
l = new_st;
for (int j = l; j <= r; j++) {
if (Ok[a[j]] == 0) {
{
Cur ^= a[j];
Ok[a[j]] = 1;
}
}
}
D[r] = max(D[r - 1], Cur + D[l - 1]);
}
} else {
D[i] = D[i - 1];
}
}
cout << D[n];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int p = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '-') {
if (p > 0) {
p--;
}
} else {
p++;
}
}
cout << p;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void ckmax(T& x, T y) {
x = (y > x ? y : x);
}
template <typename T>
inline void ckmin(T& x, T y) {
x = (y < x ? y : x);
}
const int MAXN = 2e5;
int n, m, q, inf;
map<pair<int, int>, bool> mp;
set<int> s0[MAXN + 5], s1[MAXN + 5];
struct SegmentTree {
int mn[MAXN * 4 + 5], mx[MAXN * 4 + 5];
bool ans[MAXN * 4 + 5];
void push_up(int p) {
ans[p] = (ans[p << 1] || ans[p << 1 | 1] || mn[p << 1] <= mx[p << 1 | 1]);
mn[p] = min(mn[p << 1], mn[p << 1 | 1]);
mx[p] = max(mx[p << 1], mx[p << 1 | 1]);
}
void build(int p, int l, int r) {
if (l == r) {
mx[p] = 0;
mn[p] = inf;
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
push_up(p);
}
void modify_min(int p, int l, int r, int pos, int v) {
if (l == r) {
mn[p] = v;
ans[p] = (mn[p] <= mx[p]);
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
modify_min(p << 1, l, mid, pos, v);
else
modify_min(p << 1 | 1, mid + 1, r, pos, v);
push_up(p);
}
void modify_max(int p, int l, int r, int pos, int v) {
if (l == r) {
mx[p] = v;
ans[p] = (mn[p] <= mx[p]);
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
modify_max(p << 1, l, mid, pos, v);
else
modify_max(p << 1 | 1, mid + 1, r, pos, v);
push_up(p);
}
SegmentTree() {}
} T;
int main() {
cin >> n >> m >> q;
inf = n * 2 + 1;
T.build(1, 1, m);
for (int tq = 1; tq <= q; ++tq) {
int x, y;
cin >> x >> y;
bool flag = x % 2;
if (mp[make_pair(x, y)]) {
mp[make_pair(x, y)] = 0;
x = (x + 1) / 2;
y = (y + 1) / 2;
if (flag == 1) {
s1[y].erase(x);
int v = (s1[y].empty() ? inf : *s1[y].begin());
T.modify_min(1, 1, m, y, v);
} else {
s0[y].erase(x);
int v = (s0[y].empty() ? 0 : *s0[y].rbegin());
T.modify_max(1, 1, m, y, v);
}
} else {
mp[make_pair(x, y)] = 1;
x = (x + 1) / 2;
y = (y + 1) / 2;
if (flag == 1) {
s1[y].insert(x);
T.modify_min(1, 1, m, y, *s1[y].begin());
} else {
s0[y].insert(x);
T.modify_max(1, 1, m, y, *s0[y].rbegin());
}
}
if (T.ans[1])
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int a[19000], b, c, n;
a[1] = 1;
int i = 2;
while (i <= 18257) {
a[i] = a[i - 1] + 12 * (i - 1);
i++;
}
while (scanf("%d", &n) != EOF) {
printf("%d\n", a[n]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mx2 = 505;
const int mx3 = 1005;
const int mx5 = 300005;
const int mx6 = 800005;
int _toggle(int N, int pos) { return N = N ^ (1 << pos); }
int _set(int N, int pos) { return N = N | (1 << pos); }
int _reset(int N, int pos) { return N = N & ~(1 << pos); }
bool _check(int N, int pos) { return (bool)(N & (1 << pos)); }
bool _upper(char a) { return a >= 'A' && a <= 'Z'; }
bool _lower(char a) { return a >= 'a' && a <= 'z'; }
bool _digit(char a) { return a >= '0' && a <= '9'; }
int dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, a;
long long w = 0, b = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
int x = a / 2, y = (a + 1) / 2;
if (i & 1) {
w += y, b += x;
} else {
w += x, b += y;
}
}
cout << min(w, b) << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, n, i, s, m;
long long a[1005] = {0};
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
s = 0;
for (i = 1; i <= 1000; i++)
if (a[i] > 0) s++;
m = a[1];
for (i = 2; i <= 1000; i++)
if (a[i] > m) m = a[i];
cout << m << " " << s << endl;
}
| 1 |
#include <bits/stdc++.h>
#define inf 0x3f3f3f3f
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#define rep(i, a, n) for(int i = a; i <= n; ++ i)
#define per(i, a, n) for(int i = n; i >= a; -- i)
//#define ONLINE_JUDGE
using namespace std;
typedef long long ll;
const int mod=1e9+7;
template<typename T>void write(T x)
{
if(x<0)
{
putchar('-');
x=-x;
}
if(x>9)
{
write(x/10);
}
putchar(x%10+'0');
}
template<typename T> void read(T &x)
{
x = 0;char ch = getchar();ll f = 1;
while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
int lcm(int a,int b){return a/gcd(a,b)*b;};
ll ksm(ll a,ll n){
ll ans=1;
while(n){
if(n&1) ans=(ans*a)%mod;
a=a*a%mod;
n>>=1;
}
return ans%mod;
}
//==============================================================
const int maxn=1e5+10;
int n,k,t,a[maxn];
int solve(){
if(k==0)return n;
set<int>s;
sort(a+1,a+1+n);
for(int i=1;i<=n;++i)s.insert(a[i]);
int pos=0;
int mx=a[n];
rep(i,1,n){
if(pos==a[i])pos++;
else break;
}
if(mx-pos>1){
s.insert(ceil((mx+pos)/2.0));
return s.size();
}
else if(pos>mx){
return s.size()+k;
}
else{
return s.size();
}
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("in.txt","r",stdin);
freopen("out.txt","w",stdout);
#endif
//clock_t c1 = clock();
//===========================================================
read(t);
while(t--){
read(n),read(k);
rep(i,1,n)read(a[i]);
write(solve());putchar('\n');
}
//===========================================================
//std::cerr << "Time:" << clock() - c1 << "ms" << std::endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int INF = 0x3f3f3f3f;
long long MOD = 1000000007;
long long binpow(long long a, long long b, long long c = 1e18) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res *= a;
res %= c;
}
a *= a;
a %= c;
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> nums(n);
for (long long i = 0; i < n; i++) {
long long a;
cin >> nums[i];
}
sort(nums.begin(), nums.end());
long long ans = 0;
long long currNum = 0;
for (long long i = n - 1; i >= 0; i--) {
long long it = nums[i];
currNum++;
if (it * currNum >= x) {
ans++;
currNum = 0;
}
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<long long> v(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> v[i];
}
string str;
cin >> str;
str = " " + str;
vector<long long> prefixA(n + 2, 0), prefixB(n + 2, 0);
vector<long long> suffixA(n + 2, 0), suffixB(n + 2, 0);
for (int i = 1; i <= n; ++i) {
if (str[i] == 'A') {
prefixA[i] = prefixA[i - 1] + v[i];
prefixB[i] = prefixB[i - 1];
} else {
prefixB[i] = prefixB[i - 1] + v[i];
prefixA[i] = prefixA[i - 1];
}
}
for (int i = n; i >= 1; --i) {
if (str[i] == 'A') {
suffixA[i] = suffixA[i + 1] + v[i];
suffixB[i] = suffixB[i + 1];
} else {
suffixB[i] = suffixB[i + 1] + v[i];
suffixA[i] = suffixA[i + 1];
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans = max(ans, prefixB[i] + suffixA[i + 1]);
}
for (int i = 1; i <= n; ++i) {
ans = max(ans, prefixA[i] + suffixB[i + 1]);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int N = 1e5 + 5;
const int inf = 1e9 + 5;
int dp[85][N];
int x[N], s[N];
int pmx[N];
int n, m;
int main(int argc, char const *argv[]) {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> x[i] >> s[i];
}
vi p(n);
iota(begin(p), end(p), 1);
sort(begin(p), end(p), [](int i, int j) {
return ii(x[i] + s[i], s[i] - x[i]) < ii(x[j] + s[j], s[j] - x[j]);
});
42;
fill(dp[0] + 1, dp[0] + N, inf);
for (int i = 1; i <= n; ++i) {
int xi = x[p[i - 1]], si = s[p[i - 1]];
fill(dp[i] + 1, dp[i] + N, inf);
pmx[0] = dp[i - 1][0];
for (int j = 1; j <= m; ++j) {
pmx[j] = min(pmx[j - 1], dp[i - 1][j - 1] - j);
}
for (int j = 1; j <= m; ++j) {
int atleast = max(0, j - (xi + si));
if (i == 2 and j == m) 42;
if (xi - si - atleast <= 1) {
dp[i][j] = min(dp[i - 1][j], atleast);
} else {
if (xi - si - atleast > j) {
dp[i][j] = min(dp[i - 1][j], xi - si + pmx[j]);
} else {
dp[i][j] = min(dp[i - 1][j], xi - si + pmx[xi - si - atleast]);
}
}
}
}
42;
cout << dp[n][m] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int x[110];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
int ans = 1;
for (int i = 1; i <= n; i++) {
if (i > 1 && x[i - 1] && x[i])
ans += 5;
else if (x[i])
ans++;
if (i > 1 && !x[i - 1] && !x[i]) {
ans = -1;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, a;
while (~scanf("%d%d", &n, &a)) {
if (a % 2 == 1)
printf("%d\n", a / 2 + 1);
else
printf("%d\n", (n + 2 - a) / 2);
}
return 0;
}
| 1 |
// Question Link:
#include<bits/stdc++.h>
#include<cmath>
#include<algorithm>
#include<string.h>
# define mod 1000000007
using namespace std;
typedef long long int lli;
void solve()
{
//write your code here
int n;
cin >> n;
vector<int>arr(n+1);
for(int i=0;i<n;i++)
{
int x;
cin >> x;
arr[x]++;
}
int ans=1;
for(int i=1;i<=n;i++)
{
ans=max(ans,arr[i]);
}
cout << ans << "\n";
}
int main()
{
#ifndef ONLINE_JUDGE
freopen ("A:/c++/inputf.in", "r", stdin);
freopen ("A:/c++/outputf.in", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while(t--)
{
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long a) {
if (a <= 1)
return false;
else if (a <= 3)
return true;
if (a % 2 == 0 || a % 3 == 0) return false;
for (long long i = 5; i * i <= a; i += 6) {
if (a % i == 0 || a % (i + 2) == 0) return false;
}
return true;
}
vector<unsigned long long> p;
void sieve(unsigned long long n, vector<unsigned long long>& v) {
bool a[n + 1];
memset(a, 0, sizeof(a));
v.push_back(2);
for (unsigned long long i = 3; i <= n; i += 2) {
if (a[i] == 0) {
v.push_back(i);
for (unsigned long long j = i * i; j <= n; j += i * 2) {
a[j] = 1;
}
}
}
}
void segSieve(unsigned long long l, unsigned long long h) {
unsigned long long n = floor(sqrt(h)) + 1;
vector<unsigned long long> v;
sieve(n, v);
unsigned long long m = h - l + 1;
bool b[m + 1];
memset(b, 0, sizeof(b));
for (unsigned long long i = 0; i < v.size(); i++) {
unsigned long long base = v[i] * v[i];
if (base < l) {
base = ((l + v[i] - 1) / v[i]) * v[i];
}
for (unsigned long long j = base; j <= h; j += v[i]) {
b[j - l] = 1;
}
}
for (unsigned long long i = l; i <= h; i++) {
if (b[i - l] == 0) {
if (i != 1) {
p.push_back(i);
}
}
}
}
int main() {
segSieve(1, 3010);
unsigned long long t;
cin >> t;
unsigned long long sum = 0;
for (unsigned long long i = 1; i <= t; i++) {
unsigned long long cnt = 0;
for (unsigned long long j = 0; j < p.size(); j++) {
if (i % p[j] == 0) {
cnt++;
}
if (cnt > 2 || p[j] > i) {
break;
}
}
if (cnt == 2) {
sum++;
}
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, num[100], cnt[200010];
long long a[200010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
long long temp = a[i];
while (temp && temp % 2 == 0) {
cnt[i]++;
temp /= 2;
}
num[cnt[i]]++;
}
int id = 0;
for (int i = 1; i <= 63; i++)
if (num[i] > num[id]) id = i;
printf("%d\n", n - num[id]);
for (int i = 1; i <= n; i++)
if (cnt[i] != id) printf("%lld ", a[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, t;
int main() {
scanf("%lld%lld", &n, &m);
if (m == 2 && n == 1)
printf("Yes\n");
else if (m == 1)
printf("Yes\n");
else if (n <= m)
printf("No\n");
else {
for (i = 2; i <= min(m, 1000000LL); i++) {
if (n % i == i - 1)
continue;
else
break;
}
if (i == min(m, 1000000LL) + 1)
printf("Yes\n");
else
printf("No\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> q;
while (q--) {
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
int x, y;
if (a % c == 0) {
x = a / c;
} else {
x = a / c + 1;
}
if (b % d == 0) {
y = b / d;
} else {
y = b / d + 1;
}
if (x + y > k) {
cout << -1 << '\n';
} else {
cout << x << ' ' << y << '\n';
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 300007;
int n, a[maxn];
static pair<int, int> tree[maxn << 2][20];
inline int min(int u, int v) { return u > v ? v : u; }
inline int max(int u, int v) { return u > v ? u : v; }
inline void pushup(int num, int val) {
tree[num][val] = {
min(tree[num << 1][val].first, tree[num << 1 | 1][val].first),
max(tree[num << 1][val].second, tree[num << 1 | 1][val].second)};
}
pair<int, int> query(int num, int l, int r, int val, int L, int R) {
if (L <= l && r <= R) {
return tree[num][val];
}
int md = (l + r) >> 1;
if (md >= L && md >= R) {
return query(num << 1, l, md, val, L, R);
}
if (md < R && md < L) {
return query(num << 1 | 1, md + 1, r, val, L, R);
}
if (md < R && md >= L) {
pair<int, int> tmp = query(num << 1, l, md, val, L, R),
tmp2 = query(num << 1 | 1, md + 1, r, val, L, R);
return {min(tmp.first, tmp2.first), max(tmp.second, tmp2.second)};
}
}
void build(int num, int l, int r, int val) {
if (l == r) {
if (!val) {
tree[num][0] = {max(l - a[l], 1), min(l + a[l], 3 * n)};
} else {
pair<int, int> rg = query(1, 1, 3 * n, val - 1, l, l);
tree[num][val] = query(1, 1, 3 * n, val - 1, rg.first, rg.second);
}
return;
}
int md = (l + r) >> 1;
build(num << 1, l, md, val);
build(num << 1 | 1, md + 1, r, val);
pushup(num, val);
}
inline int calc(int u) {
int ret = 0;
pair<int, int> cnt = {u, u};
for (int i = 16; i > -1; --i) {
pair<int, int> tmp = query(1, 1, 3 * n, i, cnt.first, cnt.second);
if (tmp.second - tmp.first < n - 1) {
ret += (1 << i);
cnt = tmp;
}
}
return ret;
}
int main() {
scanf("%d", &n);
if (n == 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i + n] = a[i + 2 * n] = a[i];
}
for (int i = 0; i < 17; ++i) {
build(1, 1, 3 * n, i);
}
for (int i = n + 1; i <= 2 * n; ++i) {
printf("%d ", calc(i) + 1);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
bool array[100];
memset(array, 1, 100);
while (n--) {
int r, ai;
cin >> r;
bool b[100];
memset(b, 0, 100);
for (int i = 0; i < r; ++i) cin >> ai, b[ai - 1] = 1;
for (int i = 0; i < 100; ++i)
if (!b[i]) array[i] = 0;
}
for (int i = 0; i < 100; ++i)
if (array[i]) cout << i + 1 << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2050, inf = ~0u >> 2;
struct tree {
int l, r, v;
tree *lc, *rc;
tree(int _l, int _r) : l(_l), r(_r), v(0), lc(0), rc(0) {}
void expand() {
if (l == r) return;
int m = (l + r) >> 1;
(lc = new tree(l, m))->expand();
(rc = new tree(m + 1, r))->expand();
}
void push() {
lc->v = max(lc->v, v);
rc->v = max(rc->v, v);
}
void paint(int ql, int qr, int nv) {
if (ql <= l && r <= qr) {
v = max(v, nv);
return;
}
int m = (l + r) / 2;
push();
if (ql <= m) lc->paint(ql, qr, nv);
if (qr > m) rc->paint(ql, qr, nv);
v = min(lc->v, rc->v);
}
int query(int ql, int qr) {
if (ql <= l && r <= qr) return v;
int m = (l + r) / 2, res = inf;
push();
if (ql <= m) res = min(res, lc->query(ql, qr));
if (qr > m) res = min(res, rc->query(ql, qr));
return res;
}
} * rt;
long long axis[N * N];
int acnt;
int dt[N][N], n, vx, vy, qcnt;
pair<int, pair<int, int> > que[N * N];
int main() {
scanf("%d%d%d", &n, &vx, &vy);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) scanf("%d", &dt[i][j]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
que[++qcnt] = make_pair(i * vx + j * vy, pair<int, int>(i, j));
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j) axis[++acnt] = i * vy - j * vx;
sort(axis + 1, axis + 1 + acnt);
acnt = unique(axis + 1, axis + 1 + acnt) - axis - 1;
sort(que + 1, que + 1 + qcnt);
(rt = new tree(1, acnt))->expand();
long long res = 0;
for (int _ = 1; _ <= qcnt; ++_) {
int x = que[_].second.first, y = que[_].second.second, sl(inf), sr(-inf);
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) {
int c = lower_bound(axis + 1, axis + 1 + acnt,
(x + i) * vy - (y + j) * vx) -
axis;
sl = min(sl, c);
sr = max(sr, c);
}
--sr;
int s = rt->query(sl, sr);
res += max(0, dt[x][y] - rt->query(sl, sr));
rt->paint(sl, sr, dt[x][y]);
}
printf("%I64d\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#include <string.h>
using namespace std;
#define KP \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define rep(i, a, b) for (int i = a; i < b; i++)
#define ll long long int
#define MIN -1e9
#define MAX 1e9
#define endl "\n"
#define vi vector<int>
#define pb push_back
#define all(v) v.begin(), v.end()
void solve()
{
ll n, d;
cin >> n >> d;
ll a[n], g = 0;
rep(i, 0, n)
{
cin >> a[i];
if (a[i] <= d)
g++;
}
sort(a, a + n);
ll t = a[0] + a[1];
if (t <= d || g == n)
cout << "YES" << endl;
else
{
cout << "NO" << endl;
}
}
int main()
{
KP;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll tt;
cin >> tt;
while (tt--)
solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
const int M = 405;
const int oo = 1e9 + 777;
vector<int> g[N];
int n, m;
int d[N];
int r[M][M];
bool kiemtra;
void enter() {
kiemtra = false;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
if ((u == 1 && v == n) || (u == n && v == 1)) kiemtra = true;
r[u][v] = 1;
r[v][u] = 1;
}
if (kiemtra == true) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (r[i][j] == 0) g[i].push_back(j);
} else {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (r[i][j] == 1) g[i].push_back(j);
}
for (int i = 1; i <= n; i++) g[i].push_back(0);
}
void dijkstra() {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
for (int i = 1; i <= n; i++) d[i] = oo;
d[1] = 0;
pq.push(pair<int, int>(0, 1));
while (!pq.empty()) {
int u = pq.top().second;
int du = pq.top().first;
pq.pop();
if (d[u] != du) continue;
for (int i = 0; int v = g[u][i]; i++)
if (du + 1 < d[v]) {
d[v] = du + 1;
pq.push(pair<int, int>(d[v], v));
}
}
}
int main() {
ios_base::sync_with_stdio(0);
enter();
dijkstra();
if (d[n] == oo)
cout << -1;
else
cout << d[n];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
template <class T>
void read(T &x) {
char c;
bool op = 0;
while (c = getchar(), c < '0' || c > '9')
if (c == '-') op = 1;
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
if (op) x = -x;
}
template <class T>
void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar('0' + x % 10);
}
int n, maxn = 0, cnt = 0;
int A[100050], b[100050], c[100050];
struct node {
int zt, x;
} e[2000010];
struct node2 {
int x, y;
bool operator<(const node2 &a) const { return a.x == x ? a.y < y : a.x < x; }
};
map<node2, int> a;
int printx, printy, ans = -INF;
int num[100005], cntt = 0;
void dfs1(int dep, int x, int y, int z, int sta) {
if (dep == maxn + 1) {
y -= x;
z -= x;
node2 temp;
temp.x = y;
temp.y = z;
if (a.find(temp) == a.end()) {
a[temp] = ++cnt;
e[cnt].zt = sta;
e[cnt].x = x;
} else {
if (e[a[temp]].x < x) {
e[a[temp]].x = x;
e[a[temp]].zt = sta;
}
}
return;
}
for (register int i = 0; i <= 2; i++) {
if (i == 0) dfs1(dep + 1, x + A[dep], y + b[dep], z, sta * 3);
if (i == 1) dfs1(dep + 1, x + A[dep], y, z + c[dep], sta * 3 + 1);
if (i == 2) dfs1(dep + 1, x, y + b[dep], z + c[dep], sta * 3 + 2);
}
}
void dfs2(int dep, int x, int y, int z, int sta) {
if (dep == maxn) {
y -= x;
z -= x;
y = -y;
z = -z;
node2 temp;
temp.x = y;
temp.y = z;
if (a.find(temp) != a.end()) {
if (e[a[temp]].x + x > ans) {
ans = e[a[temp]].x + x;
printx = e[a[temp]].zt;
printy = sta;
}
}
return;
}
for (register int i = 0; i <= 2; i++) {
if (i == 0) dfs2(dep - 1, x + A[dep], y + b[dep], z, sta * 3);
if (i == 1) dfs2(dep - 1, x + A[dep], y, z + c[dep], sta * 3 + 1);
if (i == 2) dfs2(dep - 1, x, y + b[dep], z + c[dep], sta * 3 + 2);
}
}
void print() {
cntt = 0;
for (register int i = 1; i <= maxn; i++) {
num[++cntt] = printx % 3;
printx /= 3;
}
for (register int i = cntt; i >= 1; i--) {
if (num[i] == 0) puts("LM");
if (num[i] == 1) puts("LW");
if (num[i] == 2) puts("MW");
}
cntt = 0;
for (register int i = maxn + 1; i <= n; i++) {
num[++cntt] = printy % 3;
printy /= 3;
}
for (register int i = 1; i <= cntt; i++) {
if (num[i] == 0) puts("LM");
if (num[i] == 1) puts("LW");
if (num[i] == 2) puts("MW");
}
}
int main() {
read(n);
for (register int i = 1; i <= n; i++) {
read(A[i]);
read(b[i]);
read(c[i]);
}
if (n % 2 == 0)
maxn = n / 2;
else
maxn = n / 2 + 1;
dfs1(1, 0, 0, 0, 0);
dfs2(n, 0, 0, 0, 0);
if (ans != -INF)
print();
else
puts("Impossible\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
int mod = 1e9 + 7;
long long dp[3000000];
int main() {
int t, n;
cin >> t;
dp[1] = 0;
dp[2] = 0;
for (int i = 3; i < maxn; ++i)
dp[i] = (dp[i - 1] + dp[i - 2] * 2 + (!(i % 3) ? 4 : 0)) % mod;
while (t--) {
scanf("%d", &n);
printf("%lld\n", dp[n]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 18) + 5;
long long a[maxn << 2], lz;
void build(int rt, int l, int r) {
if (l == r) {
cin >> a[rt];
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
a[rt] = a[rt << 1] + a[rt << 1 | 1];
}
void upd(int rt, int l, int r, int p, int v, int dep) {
if (l == r) {
a[rt] = v;
return;
}
int mid = (l + r) >> 1;
if (lz >> dep & 1) {
if (p <= mid)
upd(rt << 1 | 1, mid + 1, r, r - (mid - p + 1) + 1, v, dep - 1);
else
upd(rt << 1, l, mid, l + (p - mid) - 1, v, dep - 1);
} else {
if (p <= mid)
upd(rt << 1, l, mid, p, v, dep - 1);
else
upd(rt << 1 | 1, mid + 1, r, p, v, dep - 1);
}
a[rt] = a[rt << 1] + a[rt << 1 | 1];
}
long long query(int rt, int l, int r, int ll, int rr, int dep) {
if (ll == l && rr == r) {
return a[rt];
}
int mid = (l + r) >> 1;
long long res = 0;
if (lz >> dep & 1) {
if (rr <= mid)
return query(rt << 1 | 1, mid + 1, r, ll + (r - mid), rr + (r - mid),
dep - 1);
if (ll > mid)
return query(rt << 1, l, mid, ll - (r - mid), rr - (r - mid), dep - 1);
return query(rt << 1 | 1, mid + 1, r, r - (mid - ll + 1) + 1, r, dep - 1) +
query(rt << 1, l, mid, l, l + (rr - mid) - 1, dep - 1);
} else {
if (rr <= mid) return query(rt << 1, l, mid, ll, rr, dep - 1);
if (ll > mid) return query(rt << 1 | 1, mid + 1, r, ll, rr, dep - 1);
return query(rt << 1, l, mid, ll, mid, dep - 1) +
query(rt << 1 | 1, mid + 1, r, mid + 1, rr, dep - 1);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cout.tie(0), cin.tie(0);
int n, q, m;
cin >> n >> q;
m = n - 1;
n = 1 << n;
build(1, 1, n);
while (q--) {
int op, l, r;
cin >> op >> l;
if (op == 1) {
cin >> r;
upd(1, 1, n, l, r, m);
} else if (op == 2) {
lz ^= (1 << l) - 1;
} else if (op == 3) {
lz ^= (1 << l);
} else {
cin >> r;
cout << query(1, 1, n, l, r, m) << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, ans = "";
cin >> s;
int n = s.length(), flag = -1, cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
flag = i;
break;
}
}
if (flag >= 0) {
for (int i = 0; i < n; i++) {
if (i != flag) cout << s[i];
}
cout << "\n";
exit(0);
}
s.resize(n - 1);
cout << s << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
string a;
int main() {
cin >> n >> a;
for (int i = 0; i < n; i++)
if (a[i] == 'R' && a[i + 1] == 'U' || a[i] == 'U' && a[i + 1] == 'R')
a.replace(i, 2, "D");
cout << a.size();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200 + 10;
vector<int> adj[maxn], q;
int c[maxn], n, m[maxn];
bool mark[maxn], mark2[maxn];
void dfs(int v) {
mark[v] = true;
for (int i = 0; i < adj[v].size(); i++) {
int tmp = adj[v][i];
if (!mark[tmp]) dfs(tmp);
}
q.push_back(v);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
for (int j = 1; j <= k; j++) {
int x;
cin >> x;
adj[i].push_back(x);
}
}
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs(i);
for (int i = 1; i <= 3; i++) {
int com = i;
m[i] = n;
memset(mark2, 0, sizeof mark2);
for (int bomb = 0; bomb == 0; bomb += 0) {
for (int j = 0; j < q.size(); j++) {
int tmp = q[j];
if (c[tmp] == com && !mark2[tmp]) {
if (!adj[tmp].size()) mark2[tmp] = true;
for (int l = 0; l < adj[tmp].size(); l++) {
int tmp2 = adj[tmp][l];
if (!mark2[tmp2]) break;
if (l == adj[tmp].size() - 1) mark2[tmp] = true;
}
}
}
for (int j = 1; j <= n; j++) {
if (!mark2[j]) break;
if (j == n) bomb = 1;
}
if (bomb == 0) m[i]++;
com = (com + 1) % 3;
if (com == 0) com = 3;
}
}
for (int i = 2; i <= 3; i++) m[1] = min(m[1], m[i]);
cout << m[1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
bool f = 0;
char c = getchar();
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 2e5 + 5;
int n, k, d[N << 1];
char s[N];
signed main() {
read(n);
read(k);
scanf("%s", s);
for (int i = 0; i < n; i++)
if (s[i] != s[(i + 1) % n] && s[i] != s[(i - 1 + n) % n]) d[i] = 1e9;
for (int i = 0; i < n << 1; i++)
d[i % n] = min(d[(i - 1 + n) % n] + 1, d[i % n]);
for (int i = n * 2 - 1; ~i; i--) d[i % n] = min(d[(i + 1) % n] + 1, d[i % n]);
for (int i = 0; i < n; i++)
putchar(min(d[i], k) & 1 ? 'W' + 'B' - s[i] : s[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long OO = (long long)1e18;
const long long mod = (1e9) + 7;
const double PI = acos(-1.0);
const double EPS = 1e-8;
int dx[]{-1, -1, -1, 0, 0, 1, 1, 1};
int dy[]{-1, 0, 1, -1, 1, -1, 0, 1};
void file() {}
struct node {
int x, y;
};
bool operator<(node a, node b) {
if (a.x == b.x) return a.y > b.y;
return a.x < b.x;
}
int main() {
file();
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<long long> v(n);
long long point = 0;
for (int i = 0; i < n; i++) cin >> v[i];
map<long long, bool> mp;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
mp[x - 1] = 1;
}
vector<long long> ac;
for (int i = 0; i < n; i++) {
if (mp[i])
ac.push_back(v[i]);
else
point += v[i];
}
sort(((ac).rbegin()), ((ac).rend()));
for (int i = 0; i < m; i++) {
if (point > ac[i])
point *= 2;
else
point += ac[i];
}
cout << point << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > v[1000007];
long long int mills[1000007];
long long int is_mill[1000007];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int s, d, val, i, j, mini = 1e18, n, m, k, lim = 1e18;
cin >> n >> m >> k;
for (i = 0; i < m; i++) {
cin >> s >> d >> val;
v[s].push_back(make_pair(d, val));
v[d].push_back(make_pair(s, val));
}
for (i = 0; i < k; i++) {
cin >> mills[i];
is_mill[mills[i]] = 1;
}
for (i = 0; i < k; i++) {
for (j = 0; j < v[mills[i]].size(); j++) {
if (is_mill[v[mills[i]][j].first] != 1)
mini = min(v[mills[i]][j].second, mini);
}
}
if (mini == lim)
cout << "-1";
else
cout << mini;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int pow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res *= x;
y >>= 1;
x *= x;
}
return res;
}
struct Compare {
constexpr bool operator()(
pair<long long, pair<long long, long long> > const& a,
pair<long long, pair<long long, long long> > const& b) const noexcept {
return a.first < b.first ||
(a.first == b.first && a.second.first > b.second.first);
}
};
void prefix_function(string second, long long arr[]) {
long long border = 0;
arr[0] = 0;
for (long long i = 1; i < second.size(); i++) {
while (border > 0 && second[i] != second[border]) {
border = arr[border - 1];
}
if (second[i] == second[border]) {
border++;
} else {
border = 0;
}
arr[i] = border;
}
}
long long lpf[1000005];
long long vis[1000005];
void sieve() {
for (long long i = 2; i <= 1000001; i++) {
if (!vis[i]) {
for (long long j = i; j <= 1000001; j += i) {
vis[j] = 1;
lpf[j] = i;
}
}
}
}
int main() {
long long n;
cin >> n;
sieve();
long long x = lpf[n];
long long y = n - x;
long long ans = 1000000000;
for (long long i = y + 1; i <= n - 1; i++) {
if (i == lpf[i])
ans = min(ans, lpf[i]);
else {
ans = min(ans, i - lpf[i] + 1);
}
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[2000], used[1000], ans[1000], l, x, r, b[10000];
set<int> a1, a2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= 2 * n; i++) {
cin >> b[i];
a[b[i]]++;
}
for (int i = 10; i <= 99; i++)
if (a[i] >= 2) {
int t = 2;
used[i] = 1;
for (int j = 1; j <= 2 * n && t > 0; j++)
if (b[j] == i)
if (t == 2) {
ans[j] = 1;
a1.insert(i);
t--;
l++;
} else {
ans[j] = 2;
a2.insert(i);
t--;
r++;
}
a[i] -= 2;
}
for (int i = 10; i <= 99; i++)
if (a[i] == 1 && !used[i])
for (int j = 1; j <= 2 * n; j++)
if (b[j] == i)
if (a1.size() > a2.size()) {
ans[j] = 2;
a[i]--;
used[i] = 1;
a2.insert(i);
j = 10 * n;
r++;
} else {
ans[j] = 1;
a[i]--;
used[i] = 1;
a1.insert(i);
j = 10 * n;
l++;
}
for (int i = 1; i <= 2 * n; i++)
if (ans[i] == 0) {
if (l < r) {
ans[i] = 1;
l++;
} else {
ans[i] = 2;
r++;
}
}
cout << a1.size() * a2.size() << endl;
for (int i = 1; i <= 2 * n; i++) cout << ans[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int MAX = 1000000;
int MIN = -1000000;
int INF = 1000000000;
int x4[4] = {0, 1, 0, -1};
int y4[4] = {1, 0, -1, 0};
int x8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int y8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
int i, j, k;
int main() {
string str, tabel = "", temp;
vector<string> v;
while (cin >> str) {
tabel = tabel + str;
}
for (i = (0); i < (tabel.size()); i++) {
if (tabel[i] == '<') continue;
if (tabel[i] == '>') {
v.push_back(temp);
temp.clear();
} else
temp.push_back(tabel[i]);
}
int indx = 0, row[100000], coll[100000];
vector<int> hahaha;
memset((coll), (0), sizeof(coll));
;
memset((row), (0), sizeof(row));
;
for (i = (0); i < (v.size()); i++) {
if (v[i] == "table") indx++;
if (v[i] == "tr") row[indx]++;
if (v[i] == "td") coll[indx]++;
if (v[i] == "/table") {
hahaha.push_back(max(row[indx], coll[indx]));
row[indx] = 0;
coll[indx] = 0;
indx--;
}
}
sort(hahaha.begin(), hahaha.end());
for (i = (0); i < (hahaha.size()); i++) {
cout << hahaha[i];
if (i != hahaha.size() - 1)
cout << " ";
else
cout << endl;
}
{
fflush(stdin);
getchar();
};
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, len0, len1, vis[N], co;
int res, ans = (1 << 30);
bool flag;
struct node {
int to, w;
node() {}
node(const int To, const int W) {
to = To;
w = W;
}
};
vector<node> e[N];
vector<int> vec, v0, v1, v2;
void dfs(const int u, const int fa, const int color) {
if (flag) return;
vis[u] = color;
if (color == 0)
++len0, v0.push_back(u);
else
++len1, v1.push_back(u);
for (int i = 0; i < e[u].size(); ++i) {
int v = e[u][i].to;
if (v == fa) continue;
int Color = (vis[u] ^ e[u][i].w);
if (~vis[v]) {
if ((Color ^ co) != vis[v]) {
flag = 1;
return;
}
continue;
}
dfs(v, u, Color ^ co);
}
}
int main() {
int u, v;
char op;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d %d %c", &u, &v, &op);
if (op == 'R')
op = 1;
else
op = 0;
e[u].push_back(node(v, op));
e[v].push_back(node(u, op));
}
for (co = 0; co < 2; ++co) {
memset(vis, -1, sizeof vis);
v2.clear();
res = 0;
flag = 0;
for (int i = 1; i <= n; ++i)
if (vis[i] == -1) {
v0.clear(), v1.clear();
len0 = len1 = 0;
dfs(i, 0, 1);
if (flag) break;
res += min(len0, len1);
if (len0 < len1)
for (int j = 0; j < len0; ++j) v2.push_back(v0[j]);
else
for (int j = 0; j < len1; ++j) v2.push_back(v1[j]);
}
if (flag) continue;
if (ans > res) ans = res, vec = v2;
}
if (ans == (1 << 30))
puts("-1");
else {
printf("%d\n", ans);
for (int i = 0; i < vec.size(); ++i) printf("%d ", vec[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void gi(T &angka) {
angka = 0;
char input = getchar();
T kali = 1;
while (!(48 <= input && input <= 57)) {
if (input == '-') kali = -1;
input = getchar();
}
while (48 <= input && input <= 57)
angka = (angka << 3) + (angka << 1) + input - 48, input = getchar();
angka *= kali;
}
template <typename T1, typename T2>
void gi(T1 &angka1, T2 &angka2) {
gi(angka1);
gi(angka2);
}
const int MAXN = 200000;
const int MAXM = 200000;
int n, m;
int u[MAXM + 5], v[MAXM + 5], w[MAXM + 5];
void readInput() {
gi(n, m);
for (int i = 1; i <= m; ++i) {
gi(u[i], v[i]);
gi(w[i]);
}
}
set<pair<int, int> > path[MAXN + 5];
void initPath() {
for (int i = 1; i <= n; ++i) {
path[i].insert(make_pair(-1, 0));
}
}
int query(int idx, int newWeight) {
auto it = prev(path[idx].lower_bound(make_pair(newWeight, -1)));
return it->second + 1;
}
void update(int idx, int newWeight, int newLIS) {
auto it = prev(path[idx].upper_bound(make_pair(newWeight + 1, -1)));
if (it->second >= newLIS) {
return;
}
it = path[idx].insert(make_pair(newWeight, newLIS)).first;
while (next(it) != path[idx].end() && next(it)->second <= newLIS) {
path[idx].erase(next(it));
}
}
void solve() {
initPath();
int ans = 0;
for (int i = 1; i <= m; ++i) {
int lis = query(u[i], w[i]);
update(v[i], w[i], lis);
ans = max(ans, lis);
}
printf("%d\n", ans);
}
int main() {
int tc;
tc = 1;
while (tc--) {
readInput();
solve();
}
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 0;
const int MAXM = 0;
const int INF = 2000000000;
const int MOD = 1000000007;
using namespace std;
int n;
long long dp[2000];
long long k;
int main() {
dp[0] = 1;
dp[1] = 1;
scanf("%d", &n);
for (int i = 2; i <= n + 2; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
scanf("%I64d", &k);
for (int i = 1; i <= n; i++) {
if (k > dp[n - i]) {
k -= dp[n - i];
printf("%d %d ", i + 1, i);
i++;
} else {
printf("%d ", i);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, y = 1, x = 1, dir = 1;
vector<pair<int, int>> path;
int main() {
cin >> n >> m >> k;
while (x <= n) {
path.push_back(make_pair(x, y));
y += dir;
if (y == m + 1)
dir = -1, y = m, x++;
else if (y == 0)
dir = 1, y = 1, x++;
}
for (int i = 0; i < k - 1; i++)
cout << 2 << " " << path[2 * i].first << " " << path[2 * i].second << " "
<< path[2 * i + 1].first << " " << path[2 * i + 1].second << "\n";
cout << path.size() - 2 * (k - 1) << " ";
for (int i = 2 * (k - 1); i < path.size(); i++)
cout << path[i].first << " " << path[i].second << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007, N = 200010;
long long T, n, m, q[N], a[N], C, b[N], ms;
bool v[N];
map<long long, int> mp;
set<int> s[N];
int exgcd(long long a, long long b, long long &x, long long &y) {
int z;
return !b ? (x = 1, y = 0, a)
: (z = exgcd(b, a % b, y, x), y -= x * (a / b), z);
}
int main() {
scanf("%I64d%I64d", &T, &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
(a[i] += a[i - 1]) %= T;
}
C = a[n];
if (!C) C += T;
long long x, y, d, z;
d = exgcd(C, T, x, y);
C /= d, T /= d;
x = x % T + T;
for (int i = 1; i <= n; i++) {
q[i] = a[i] % d;
a[i] /= d;
b[i] = x * a[i] % T;
if (!mp[q[i]]) mp[q[i]] = ++ms;
q[i] = mp[q[i]];
if (s[q[i]].find(b[i]) != s[q[i]].end())
v[i] = 1;
else
s[q[i]].insert(b[i]);
}
for (int i = 1; i <= n; i++) {
if (v[i]) {
printf("0 ");
continue;
}
z = q[i];
auto it = s[z].find(b[i]);
auto tmp = it;
if ((++tmp) == s[z].end()) tmp = s[z].begin();
printf("%d ", ((*tmp) - b[i] + T - 1) % T + 1);
}
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.