solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long sx[4], sy[4], ex[4], ey[4], cnt, cnt1, a[4], b[4];
map<pair<long long, long long>, int> ch;
int main() {
for (int i = 0; i < 4; i++) {
cin >> sx[i] >> sy[i] >> ex[i] >> ey[i];
ch[make_pair(sx[i], sy[i])]++;
ch[make_pair(ex[i], ey[i])]++;
}
for (int i = 0; i < 4; i++) {
if (sx[i] != ex[i] && sy[i] != ey[i]) {
cout << "NO" << endl;
exit(0);
} else if (sx[i] == ex[i]) {
a[cnt] = i;
cnt++;
} else if (sy[i] == ey[i]) {
b[cnt1] = i;
cnt1++;
}
}
if (cnt != cnt1) {
cout << "NO" << endl;
exit(0);
}
for (int i = 0; i < 4; i++) {
if (ch[make_pair(sx[i], sy[i])] != 2) {
cout << "NO" << endl;
exit(0);
}
}
cout << "YES" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
long long n, m;
bool row[maxn], col[maxn];
int crow, ccol;
long long ans;
int main() {
scanf("%lld%lld", &n, &m);
ans = n * n;
for (int i = 0, x, y; i < m; i++) {
scanf("%d%d", &x, &y);
ans -= ((n - ccol) * (!row[x]) + (n - crow) * (!col[y])) -
((!row[x]) * (!col[y]));
printf("%lld%c", ans, " \n"[i == m - 1]);
if (!row[x]) {
row[x] = true;
crow++;
}
if (!col[y]) {
col[y] = true;
ccol++;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, M = 500005;
int n, Q;
int pos[N];
long long ans[M];
char s[N];
struct query {
int x, y, sgn, id;
bool operator<(const query &A) const { return x < A.x; }
} q[M * 2];
int rt, tot;
int ch[N][26], fa[N], fail[N], qu[N];
void ins(int ls, int id) {
int u = rt;
for (int i = 1; i <= ls; i++) {
int &v = ch[u][s[i] - 'a'];
if (!v) v = ++tot, fa[v] = u;
u = v;
}
pos[id] = u;
}
int cnte, ti;
int head[N], siz[N], dfn[N];
struct edge {
int v, nxt;
} e[N];
void ade(int u, int v) {
e[++cnte] = (edge){v, head[u]};
head[u] = cnte;
}
void dfs(int u) {
siz[u] = 1;
dfn[u] = ++ti;
for (int i = head[u]; i; i = e[i].nxt) dfs(e[i].v), siz[u] += siz[e[i].v];
}
void build() {
int hd = 0, tl = 0;
for (int i = 0; i < 26; i++) ch[0][i] = rt;
qu[++tl] = rt;
while (hd < tl) {
int u = qu[++hd];
for (int i = 0; i < 26; i++) {
int &v = ch[u][i];
if (v)
fail[v] = ch[fail[u]][i], qu[++tl] = v;
else
v = ch[fail[u]][i];
}
}
for (int i = 2; i <= tot; i++) ade(fail[i], i);
dfs(rt);
}
long long c[N];
void upd(int x) {
for (; x <= tot; x += x & (-x)) c[x]++;
}
long long qsum(int x) {
long long y = 0;
for (; x; x -= x & (-x)) y += c[x];
return y;
}
long long qsum(int l, int r) { return qsum(r) - qsum(l - 1); }
int main() {
scanf("%d%d", &n, &Q);
rt = tot = 1;
for (int i = 1; i <= n; i++) scanf("%s", s + 1), ins(strlen(s + 1), i);
build();
for (int i = 1; i <= Q; i++) {
int l, r, k;
scanf("%d%d%d", &l, &r, &k);
q[2 * i - 1] = (query){l - 1, k, -1, i};
q[2 * i] = (query){r, k, 1, i};
}
sort(q + 1, q + 2 * Q + 1);
for (int i = 1, r = 1; i <= 2 * Q; i++) {
while (r <= q[i].x) {
for (int u = pos[r]; u; u = fa[u]) upd(dfn[u]);
r++;
}
int v = pos[q[i].y];
ans[q[i].id] += q[i].sgn * qsum(dfn[v], dfn[v] + siz[v] - 1);
}
for (int i = 1; i <= Q; i++) printf("%lld\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long ori[22];
map<long long, int> prl[22];
vector<int> a[20];
vector<int> prime;
int isprime[2000000];
void getprime(int n) {
for (int i = 1; i <= n; ++i) {
long long cp = ori[i];
if (cp == -1) continue;
for (auto it : prime) {
while (cp % it == 0) {
cp /= it;
prl[i][it]++;
}
}
if (cp != 1 && cp) prl[i][cp]++;
}
}
void getprimelist(int t) {
memset(isprime, 1, sizeof(isprime));
isprime[1] = 0;
for (int i = 2; i <= t; ++i) {
if (isprime[i]) prime.push_back(i);
for (int j = 0; j < prime.size() && prime[j] * i <= t; ++j) {
isprime[prime[j] * i] = 0;
if (i % prime[j] == 0) break;
}
}
}
long long getans(int t, int *vis) {
long long cnt = 0;
double pro = 1;
vis[t] = 1;
if (a[t].empty()) {
for (auto it : prl[t]) cnt += it.second;
return (cnt == 1 ? 0 : cnt) + 1;
}
auto cpy = prl[t];
for (auto it : a[t]) {
pro *= ori[it];
cnt += getans(it, vis);
for (auto pt : prl[it]) {
cpy[pt.first] -= pt.second;
}
}
if (ori[t] == -1) return cnt + 1;
if (pro > ori[t] || ori[t] % (long long)pro != 0) return 0x3f3f3f3f;
for (auto it : cpy) {
cnt += it.second;
}
return cnt + 1;
}
long long bstans = 0x3f3f3f3f;
void dfs1(int t, int sum) {
if (t > sum) {
int vis[10];
memset(vis, 0, sizeof(vis));
long long cnt = 0, tans = 0;
for (int i = 1; i <= sum; ++i) {
if (!vis[i]) {
tans += getans(i, vis);
cnt++;
}
}
if (cnt > 1) tans++;
bstans = min(bstans, tans);
return;
}
for (int i = 1; i <= t; ++i) {
if (i != t) a[i].push_back(t);
dfs1(t + 1, sum);
if (i != t) a[i].pop_back();
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i, j, k, m, n;
getprimelist(1055550);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> ori[i];
}
sort(ori + 1, ori + n + 1);
reverse(ori + 1, ori + n + 1);
getprime(n);
dfs1(2, n);
cout << bstans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
const int maxn = (int)1e5 + 5;
int n;
long long k;
vector<int> g[maxn];
bool read() {
if (scanf("%d%lld", &n, &k) < 2) {
return false;
}
for (int i = 0; i < n; ++i) {
g[i].clear();
}
for (int i = 0; i < n - 1; ++i) {
int v, u;
scanf("%d%d", &v, &u);
--v;
--u;
g[v].push_back(u);
g[u].push_back(v);
}
return true;
}
int ts[maxn];
void getTs(int v, int p) {
ts[v] = 1;
for (int i = 0; i < ((int)(g[v]).size()); ++i) {
int u = g[v][i];
if (u == p) {
continue;
}
getTs(u, v);
ts[v] += ts[u];
}
}
int cnt[maxn];
int a[maxn];
vector<int> *vs[maxn];
priority_queue<pair<int, int>> pq;
vector<pair<int, int>> ans;
void dfs(int v, int p) {
for (int i = 0; i < ((int)(g[v]).size()); ++i) {
int u = g[v][i];
if (u == p) {
continue;
}
dfs(u, v);
}
while (!pq.empty()) {
pq.pop();
}
{
vs[v] = new vector<int>(1, v);
pq.push(make_pair(1, v));
}
int sum = 1;
for (int i = 0; i < ((int)(g[v]).size()); ++i) {
int u = g[v][i];
if (u == p) {
continue;
}
if (!vs[u]->empty()) {
pq.push(make_pair(((int)(*vs[u]).size()), u));
sum += ((int)(*vs[u]).size());
}
}
while (sum > a[v]) {
assert(!pq.empty());
int x = pq.top().second;
pq.pop();
assert(!pq.empty());
int y = pq.top().second;
pq.pop();
ans.push_back(make_pair(vs[x]->back(), vs[y]->back()));
vs[x]->pop_back();
vs[y]->pop_back();
sum -= 2;
if (!vs[x]->empty()) {
pq.push(make_pair(((int)(*vs[x]).size()), x));
}
if (!vs[y]->empty()) {
pq.push(make_pair(((int)(*vs[y]).size()), y));
}
}
if (!pq.empty()) {
int u = pq.top().second;
pq.pop();
while (!pq.empty()) {
int w = pq.top().second;
pq.pop();
for (int i = 0; i < ((int)(*vs[w]).size()); ++i) {
vs[u]->push_back((*vs[w])[i]);
}
delete vs[w];
}
vs[v] = vs[u];
}
}
void solve() {
getTs(0, -1);
long long cur = 0, mx = 0;
for (int i = 0; i <= n; ++i) {
cnt[i] = 0;
}
for (int i = 0; i < n; ++i) {
cur += (ts[i] & 1);
int x = min(ts[i], n - ts[i]);
mx += x;
++cnt[x];
}
if (k < cur || k > mx || (k & 1) != (cur & 1)) {
printf("NO\n");
return;
}
int c[2] = {n - (int)cur, (int)cur};
c[0] -= cnt[0];
c[1] -= cnt[1];
for (int i = 2; i <= n; ++i) {
if (cur + c[i & 1] * 2 >= k) {
a[0] = 0;
for (int v = 0; v < n; ++v) {
int val = ((ts[v] & 1) == (i & 1) ? i - 2 : i - 1);
val = min(val, min(ts[v], n - ts[v]));
a[v] = val;
}
int need = k - cur;
for (int v = 0; v < n && need; ++v) {
if ((ts[v] & 1) == (i & 1) && a[v] + 2 <= min(ts[v], n - ts[v])) {
a[v] += 2;
need -= 2;
}
}
break;
}
cur += c[i & 1] * 2;
c[i & 1] -= cnt[i];
}
ans.clear();
dfs(0, -1);
printf("YES\n");
for (int i = 0; i < ((int)(ans).size()); ++i) {
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
}
int main() {
precalc();
while (read()) {
solve();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
const double pi = 3.14159265358979323;
const double eps = 1e-8;
int h, m, n;
long long ans;
map<int, int> id;
int pat[200010], tot;
set<int> tree[200010];
int ord[200010];
vector<int> rec[200010];
int main() {
ios::sync_with_stdio(false);
char op;
int x, y;
cin >> h >> m >> n;
ans = 0;
tot = 0;
memset(pat, -1, sizeof(pat));
memset(ord, 0, sizeof(ord));
for (int i = (0); i < (h); i++)
if (pat[i] == -1) {
for (int j = i, t = 0; pat[j] == -1; j = (j + m) % h, t++) {
pat[j] = tot;
ord[j] = t;
rec[tot].push_back(j);
tree[tot].insert(t);
}
tot++;
}
while (n--) {
cin >> op;
if (op == '+') {
cin >> x >> y;
set<int>::iterator it = tree[pat[y]].lower_bound(ord[y]);
if (it == tree[pat[y]].end()) it = tree[pat[y]].begin();
int tmp = (*it);
if (ord[y] <= tmp)
ans += (tmp - ord[y]);
else {
int st = rec[pat[y]].size();
ans += st - ord[y] + tmp;
}
id[x] = rec[pat[y]][tmp];
tree[pat[y]].erase(it);
} else {
cin >> x;
int tmp = id[x];
tree[pat[tmp]].insert(ord[tmp]);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int L = 105, N = 55;
int dp[L][N][2], sum[L], way[L];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n, l = s.size();
cin >> n;
int stt = 1, plc = 0;
for (int i = 0; i < l; i++) {
way[i] = stt;
if (s[i] == 'F') {
plc += stt;
}
if (s[i] == 'T') {
stt *= -1;
}
sum[i + 1] = plc;
}
for (int i = 0; i <= l; i++) {
dp[i][0][0] = dp[i][0][1] = sum[l];
}
for (int i = 0; i <= n; i += 2) {
dp[l][i][0] = dp[l][i][0] = sum[l];
}
for (int i = l - 1; i >= 0; i--) {
for (int j = 1; j <= n; j++) {
if (l - i - 1 >= j) {
dp[i][j][0] = dp[i + 1][j][0];
dp[i][j][1] = dp[i + 1][j][1];
} else {
dp[i][j][0] = 1e9;
dp[i][j][1] = -1e9;
}
if (s[i] == 'F') {
dp[i][j][0] =
min(dp[i][j][0], sum[i] * 2 - (dp[i + 1][j - 1][1] - way[i]));
dp[i][j][1] =
max(dp[i][j][1], sum[i] * 2 - (dp[i + 1][j - 1][0] - way[i]));
}
if (s[i] == 'T') {
dp[i][j][0] =
min(dp[i][j][0], sum[i] * 2 - dp[i + 1][j - 1][1] + way[i]);
dp[i][j][1] =
max(dp[i][j][1], sum[i] * 2 - dp[i + 1][j - 1][0] + way[i]);
}
if (j >= 2) {
dp[i][j][0] = min(dp[i][j][0], dp[i][j - 2][0]);
dp[i][j][1] = max(dp[i][j][1], dp[i][j - 2][1]);
}
}
}
cout << max(-dp[0][n][0], dp[0][n][1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int E = 222222;
vector<int> adj[E];
pair<int, int> seg[E];
int ans[E];
void add(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void dfs(int u, int f = 1) {
ans[u] = f;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (!ans[v]) dfs(v, 3 - f);
}
}
void solve_E() {
int n;
gn(n);
for (int i = 0; i < n; i++) {
int L, R;
gn(L, R);
seg[i << 1] = pair<int, int>(L, i << 1);
seg[(i << 1) + 1] = pair<int, int>(R + 1, (i << 1) + 1);
add(i << 1, (i << 1) + 1);
}
sort(seg, seg + (n << 1));
for (int i = 0; i < n; i++) {
add(seg[i << 1].second, seg[(i << 1) + 1].second);
}
for (int i = 0; i < (n << 1); i++)
if (!ans[i]) dfs(i);
for (int i = 0; i < n; i++) printsp(ans[i << 1] - 1);
exit(0);
}
int main() {
solve_E();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int L = 110;
char ch[L] = {};
int l;
void insert(int pos, char c) {
copy(ch + pos, ch + l + 1, ch + pos + 1);
ch[pos] = c;
++l;
}
void erase(int pos) {
copy(ch + pos + 1, ch + l + 1, ch + pos);
ch[l--] = '\0';
}
bool is_ok() {
char tmp[L] = {};
reverse_copy(ch + 1, ch + l + 1, tmp + 1);
return equal(ch + 1, ch + l + 1, tmp + 1);
}
int main() {
cin >> (ch + 1);
l = strlen(ch + 1);
if (is_ok()) {
insert((l + 1) / 2, ch[l / 2 + 1]);
puts(ch + 1);
} else {
for (int i = 1; i <= l / 2; ++i)
if (ch[i] != ch[l + 1 - i]) {
if (ch[i] == ch[l - i]) {
insert(i, ch[l + 1 - i]);
if (is_ok()) {
puts(ch + 1);
break;
} else
erase(i);
}
if (ch[i + 1] == ch[l + 1 - i]) {
int p = l + 2 - i;
insert(p, ch[i]);
if (is_ok()) {
puts(ch + 1);
break;
} else
erase(p);
}
puts("NA");
break;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void conan() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
int a, ta, b, tb, h, m, c = 0, c2 = 0, x1, y1, y2;
cin >> a >> ta >> b >> tb;
scanf("%d:%d", &h, &m);
x1 = h * 60 + m;
y1 = x1 + ta;
for (int i = 300; i < min(y1, 1440); i += b) {
y2 = i + tb;
if (y2 > x1) c++;
}
cout << c;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, a[N], f[N], ans;
stack<int> s;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i > 0; i--) {
while (!s.empty() && a[s.top()] < a[i]) {
f[i] = max(f[i] + 1, f[s.top()]);
s.pop();
}
s.push(i);
ans = max(ans, f[i]);
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
const int MOD = 1000000007;
long long Get(int power) {
if (power == 0) return 1;
if (power == 1) return m;
long long tmp = Get(power / 2);
tmp = (tmp * tmp) % MOD;
if (power % 2 == 1) tmp = (tmp * m) % MOD;
return tmp;
}
void Main(const int cas) {
if (n < k || k == 1)
cout << Get(n) << endl;
else if (n == k)
cout << Get((n + 1) / 2) << endl;
else if (n > k) {
if (k % 2 == 0)
cout << m << endl;
else if (k % 2 == 1)
cout << m * m << endl;
}
}
int main() {
int cas = 1;
while (scanf("%d%d%d", &n, &m, &k) != EOF && (n || m || k)) {
Main(cas++);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10, pi = acos(-1.0);
int a[104];
int main() {
int t = 1;
while (t--) {
int n, x, y, s = 0, ans;
for (int i = 0; i < 5; i++) {
cin >> x;
s += x;
a[x]++;
}
ans = s;
for (int i = 100; i >= 1; i--)
if (a[i] >= 3) {
ans = min(ans, (s - (3 * i)));
} else if (a[i] >= 2) {
ans = min(ans, (s - (2 * i)));
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int f[1000000] = {0};
vector<int> v;
for (int i = n - 1; i >= 0; i--) {
if (!f[a[i]]) {
v.push_back(a[i]);
}
f[a[i]] = 1;
}
reverse(v.begin(), v.end());
int tmp = v.size();
cout << tmp << endl;
for (int i = 0; i < tmp; ++i) {
cout << v[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const long long Mod = 1e9 + 7;
template <class T>
T checkMax(T& r, T val) {
if (r < val) r = val;
return r;
}
template <class T>
T checkMin(T& r, T val) {
if (r > val) r = val;
return r;
}
int n, m, K;
int d[N];
long long sum[N];
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 0; i < n; ++i) scanf("%d", d + i);
sort(d, d + n);
for (i = 0; i < n; ++i) {
if (i == 0)
sum[0] = d[0];
else
sum[i] = d[i] + sum[i - 1];
}
long long res = 0;
for (i = 0; i < n; ++i) {
long long t = d[i] * (n - 1LL - i);
long long s = sum[n - 1] - sum[i];
res += s - t;
}
res = res * 2LL + sum[n - 1];
long long den = n;
long long g = gcd(res, n);
res /= g;
den /= g;
cout << res << " " << den << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n;
cin >> k;
for (int i = 0; i < k; i++) {
if ((n % 10) != 0) {
n--;
} else {
n /= 10;
}
}
cout << n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void swap(long long &a, long long &b) {
long long tmp = a;
a = b;
b = tmp;
}
int main(void) {
long long p, q, n, a[90], num, den, d;
int i;
cin >> p >> q >> n;
for (i = 0; i < n; i++) cin >> a[i];
if (a[n - 1] == 1) a[--n - 1]++;
for (i = 0; i < n && q && p / q == a[i]; i++) {
p %= q;
swap(p, q);
}
if (i == n && !(q % p))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int inf = 1e14;
long long int mod = 1e9 + 7;
char en = '\n';
struct TwoSAT {
static const int MAXV = 2e5 + 5;
int n, cnt;
vector<int> g[MAXV], rg[MAXV];
bool vis[MAXV];
int order[MAXV], color[MAXV];
void init(int curn) {
n = curn;
for (int i = 0; i < n; i++) {
g[i].clear();
rg[i].clear();
}
}
void add(int u, int v) {
g[u].push_back(v);
g[v].push_back(u);
}
void dfs(int u, int c) {
color[u] = c;
for (auto it : g[u])
if (color[it] == -1) dfs(it, c);
}
int solve(vector<int> &ans) {
int cl = 0;
memset(color, -1, sizeof(color));
for (int i = 0; i < n; i++)
if (color[i] == -1) dfs(i, cl++);
for (int i = 0; i < n; i += 2)
if (color[i] == color[i ^ 1]) return 0;
return 1;
}
} sat;
long long int arr[200005];
vector<long long int> arr2[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
sat.init(2 * m);
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
for (long long int i = 0; i < m; i++) {
long long int x;
cin >> x;
while (x--) {
long long int y;
cin >> y;
y--;
arr2[y].push_back(i);
}
}
for (long long int i = 0; i < n; i++) {
if (arr[i] == 0) {
long long int p0 = 2 * arr2[i][0], p1 = 2 * arr2[i][0] + 1;
long long int q0 = 2 * arr2[i][1], q1 = 2 * arr2[i][1] + 1;
sat.add(p0, q1);
sat.add(q0, p1);
} else {
long long int p0 = 2 * arr2[i][0], p1 = 2 * arr2[i][0] + 1;
long long int q0 = 2 * arr2[i][1], q1 = 2 * arr2[i][1] + 1;
sat.add(p0, q0);
sat.add(p1, q1);
}
}
vector<int> ans;
int val = sat.solve(ans);
if (val)
cout << "YES" << en;
else
cout << "NO" << en;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int leftCount = 0;
int rightCount = 0;
bool isPossible = true;
vector<int> solutions;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(')
leftCount++;
else if (s[i] == ')')
rightCount++;
else {
rightCount++;
solutions.push_back(1);
}
}
if (solutions.size()) solutions.back() += leftCount - rightCount;
if (solutions.size() && solutions.back() <= 0)
isPossible = false;
else {
int hashNumber = 0;
int leftCount = 0;
int rightCount = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(')
leftCount++;
else if (s[i] == ')')
rightCount++;
else {
rightCount += solutions[hashNumber++];
}
if (rightCount > leftCount) {
isPossible = false;
break;
}
}
if (leftCount != rightCount) isPossible = false;
}
if (isPossible) {
for (int i = 0; i < solutions.size(); i++) cout << solutions[i] << endl;
} else
cout << -1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long a[maxn], s[maxn];
long long n;
long long sum(long long l, long long r) {
r = min(r, n - 1);
return s[r] - s[l - 1];
}
int main() {
scanf("%I64d", &n);
for (int i = 0; i < n; ++i) scanf("%I64d", &a[i]);
sort(a, a + n);
reverse(a, a + n);
s[0] = a[0];
for (int i = 1; i < n; ++i) s[i] = a[i] + s[i - 1];
int q;
scanf("%d", &q);
long long ans1 = 0;
for (int i = 1; i < n; ++i) ans1 += a[i] * i;
while (q--) {
int k;
scanf("%d", &k);
if (k == 1) {
printf("%I64d ", ans1);
continue;
}
long long ans = 0;
long long sz = 1;
for (long long i = 1, j = 1; j < n; ++i, j += sz) {
sz *= k;
ans += sum(j, j + sz - 1) * i;
}
printf("%I64d ", ans);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007ll;
long long powmod(long long a, long long b) {
long long res = 1;
a %= MOD;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
template <typename t1, typename t2>
inline bool upmax(t1 &a, t2 b) {
if (a < (t1)b) {
a = (t1)b;
return true;
} else
return false;
}
template <typename t1, typename t2>
inline bool upmin(t1 &a, t2 b) {
if (a > (t1)b) {
a = (t1)b;
return true;
} else
return false;
}
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
inline T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
const int INF = 1000000404;
const long long LINF = 4000000000000000404ll;
const long double PI = acos(-1.0);
const long double EPS = 1e-9;
int SQ = 318;
int timer = 0;
void solve() {
long long maxx = 0;
int minx = INF;
long long n;
cin >> n;
long long m;
cin >> m;
long long s = 0;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
s += x;
upmax(maxx, x);
}
cout << max(maxx, (s + m + n - 1) / n) << ' ' << maxx + m << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
getchar();
getchar();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, b, x, k, a[105], input[50005], mod = 1000000007, ass[105];
long long go(long long base, long long po) {
if (po == 1) return base % x;
if (po == 0) return 1;
if (po % 2 == 0) {
long long p = go(base, po / 2) % x;
return (p * p) % x;
} else {
long long p = go(base, (po - 1) / 2);
p %= x;
p *= p;
p %= x;
return (p * base) % x;
}
}
void solve(long long b) {
if (b == 1) return;
if (b % 2 == 0) {
solve(b / 2);
long long cur[105];
memset(cur, 0, sizeof cur);
long long y = go(10, b / 2);
for (long long i = 0; i <= x; i++) {
long long ans = (i * y) % x;
for (long long j = 0; j <= x; j++) {
cur[(ans + j) % x] += (a[i] * a[j]) % mod;
cur[(ans + j) % x] %= mod;
}
}
for (long long i = 0; i <= x; i++) a[i] = cur[i];
} else {
solve((b - 1) / 2);
long long cur[105];
memset(cur, 0, sizeof cur);
long long y = go(10, (b - 1) / 2);
for (long long i = 0; i <= x; i++) {
long long ans = (i * y) % x;
for (long long j = 0; j <= x; j++) {
cur[(ans + j) % x] += (a[i] * a[j]) % mod;
cur[(ans + j) % x] %= mod;
}
}
for (long long i = 0; i <= x; i++) a[i] = cur[i];
memset(cur, 0, sizeof cur);
y = go(10, b - 1);
for (long long i = 0; i <= x; i++) {
long long ans = (i * y) % x;
for (long long j = 0; j <= x; j++) {
cur[(ans + j) % x] += (ass[i] * a[j]) % mod;
cur[(ans + j) % x] %= mod;
}
}
for (long long i = 0; i <= x; i++) a[i] = cur[i];
}
}
int main() {
cin >> n >> b >> k >> x;
memset(a, 0, sizeof a);
for (long long i = 1; i <= n; i++) {
cin >> input[i];
a[input[i] % x]++;
ass[input[i] % x]++;
}
solve(b);
cout << a[k];
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
int bp(int a, int b) {
a %= 1000000007;
int res = 1;
while (b > 0) {
if (b % 2) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b /= 2;
}
return res;
}
int n;
const int N = 1e4 + 1;
int a[N];
bool f(int r) {
vector<bitset<2048>> dp(2);
for (int x = 0; x <= r; x++) dp[1][x] = true;
for (int x = 0; x < n; x++) {
dp[x % 2] |= (dp[(x + 1) % 2] << a[x]);
dp[x % 2] |= (dp[(x + 1) % 2] >> a[x]);
for (int y = r + 1; y < 2048; y++) dp[x % 2][y] = false;
dp[((x + 1) % 2)].reset();
}
return dp[(n + 1) % 2].any();
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int x = 0; x < n; x++) cin >> a[x];
int g = -1;
for (int x = 10; x >= 0; x--) {
int fi = g + (1 << x);
if (!f(fi)) g = fi;
}
cout << g + 1 << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int N = 1000000 + 10, maxn = 50000 + 10, inf = 0x3f3f3f3f,
INF = 0x3f3f3f3f3f3f3f3f;
long long num[N], a[N];
long long quick(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 998244353;
a = a * a % 998244353;
b >>= 1;
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
num[0] = 1;
for (int i = 1; i <= n; i++)
num[i] = (num[i - 1] * 2 % 998244353 + quick(2, i - 1)) % 998244353;
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + a[i] % 998244353 * num[n - i - 1] % 998244353) % 998244353;
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 200000 + 100;
long long dp[maxn][2];
long long dif[maxn];
int n;
long long x, y;
vector<int> G[maxn];
void dfs(int u, int fa) {
int son = 0;
long long sum0 = 0;
long long Min = INF;
long long SecMin = INF;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v != fa) {
dfs(v, u);
son++;
sum0 += dp[v][0];
if (dif[v] < Min) {
SecMin = Min;
Min = dif[v];
} else if (dif[v] < SecMin) {
SecMin = dif[v];
}
}
}
if (son == 0) {
dp[u][1] = dp[u][0] = 0;
dif[u] = 0;
return;
}
dp[u][1] = sum0 + Min + x + y * (son - 1);
dp[u][0] = sum0 + y * (son - 1) + y;
dp[u][0] = min(dp[u][0], sum0 + y * (son - 1) + x + Min);
if (son >= 2) {
dp[u][0] = min(dp[u][0], sum0 + y * (son - 2) + 2 * x + Min + SecMin);
}
dif[u] = dp[u][1] - dp[u][0];
}
int degree[maxn];
int main() {
scanf("%d %lld %lld", &n, &x, &y);
memset(degree, 0, sizeof(degree));
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d %d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
degree[a]++;
degree[b]++;
}
if (n == 1) {
puts("0");
return 0;
}
if (x >= y) {
int cnt = 0;
for (int i = 1; i <= n; ++i)
if (degree[i] == 1) cnt++;
long long res;
if (cnt >= n - 1)
res = y * (n - 2) + x;
else
res = y * (n - 1);
printf("%lld\n", res);
return 0;
}
dfs(1, -1);
long long res = min(dp[1][0], dp[1][1]);
printf("%lld\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num_test_cases;
cin >> num_test_cases;
for (int tc = 0; tc < num_test_cases; tc++) {
int n;
cin >> n;
long long ans = 0;
for (long long i = 1; i <= n; i += 2) ans += (4 * (i - 1)) * (i / 2);
cout << ans << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int in[1005], vis[1005];
int n, k;
int dp[1005 * 2];
vector<int> v;
void bfs() {
queue<int> q;
for (int i = 0; i <= 1000; i++)
if (!vis[i] && in[i]) {
vis[i] = 1;
v.push_back(i - n);
int x = i - n + 1000;
dp[x] = 1;
q.push(x);
}
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 0; i < v.size(); i++) {
int nt = x + v[i];
if (nt >= 0 && nt <= 2000 && dp[nt] > dp[x] + 1) {
dp[nt] = dp[x] + 1;
q.push(nt);
}
}
}
}
int main() {
cin >> n >> k;
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
in[x] = 1;
}
bfs();
if (in[n])
cout << "1" << endl;
else if (dp[1000] == 0x3f3f3f3f)
cout << "-1" << endl;
else
cout << dp[1000] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, total = 0;
scanf("%d", &n);
int a[n], freq[2 * n];
memset(freq, 0, sizeof freq);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
freq[a[i]]++;
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (freq[a[i]] > 1) {
for (int j = 1; j <= n; j++) {
if (freq[a[i] + j] == 0) {
total += j;
freq[a[i] + j]++;
freq[a[i]]--;
break;
}
}
}
}
printf("%d\n", total);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int M = 1e5 + 5;
int n, m;
int col[M], bit[1 << 12], cnt[13][1 << 8];
char s[N][M];
int main() {
for (int i = 1; i < (1 << 12); i++) bit[i] = bit[i - (i & -i)] + 1;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
for (int j = 0; j < m; j++)
if (s[i][j] == '1') col[j] |= 1 << i;
}
int l = min(n, 12);
int r = n - l;
int ans = 1e9;
for (int i = 0; i < (1 << l); i++) {
memset(cnt, 0, sizeof(cnt));
for (int j = 0; j < m; j++) {
int v1 = col[j] & ((1 << l) - 1);
int v2 = col[j] >> l;
cnt[bit[i ^ v1]][v2]++;
}
for (int j = 0; j < (1 << r); j++) {
int res = 0;
for (int mask = 0; mask < (1 << r); mask++) {
for (int c = 0; c <= l; c++) {
int val = bit[mask ^ j] + c;
res += min(val, n - val) * cnt[c][mask];
}
}
ans = min(ans, res);
}
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int p[2 * 100003], pp[2 * 100003];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
int t = 0, l = 0, r = 0;
while (q--) {
char c;
int a;
cin >> c >> a;
if (c == 'L') {
l++;
p[a] = l;
pp[a] = -(l - 1);
} else if (c == 'R') {
r++;
p[a] = -(r - 1);
pp[a] = r;
} else {
cout << min(l - p[a], r - pp[a]) << '\n';
}
}
}
| 3 |
#include <bits/stdc++.h>
struct Star {
int v[(100001 * 2)], pre[(100001 * 2)], ind[100001], n;
void make_edge(int ui, int vi) {
int id = ++n;
v[id] = vi;
pre[id] = ind[ui];
ind[ui] = id;
}
} G;
int N, Q, inp[100001], oup[100001], _inp[(100001 * 2)], tim, ans[100001];
bool vis[100001];
void dfs(int n) {
if (vis[n]) return;
vis[n] = true;
inp[n] = ++tim;
_inp[tim] = n;
int m, mid;
for (mid = G.ind[n]; mid; mid = G.pre[mid]) {
m = G.v[mid];
dfs(m);
}
oup[n] = ++tim;
}
struct Node {
int n, m, cover;
void print() { printf("(%d/%d) cover=%d\n", m, n, cover); }
} node[(100001 * 2) * 3];
int TM, TN;
void upper(int id) {
if (node[id].cover == 0) {
if (id >= TM)
node[id].m = 0;
else
node[id].m = node[id << 1].m + node[id << 1 | 1].m;
} else
node[id].m = node[id].n;
}
void cng(int id, int v) {
node[id].cover += v;
upper(id);
}
void modify(int x, int y, int c) {
int i, j;
for (i = x + TM - 1, j = y + TM + 1; i ^ j ^ 1; i >>= 1, j >>= 1) {
if (~i & 1) cng(i ^ 1, c);
if (j & 1) cng(j ^ 1, c);
upper(i);
upper(j);
}
upper(j);
for (; i; i >>= 1) {
upper(i);
}
}
struct Cover {
int p, q, id;
Cover() {}
Cover(int pi, int qi, int oi) { p = pi, q = qi, id = oi; }
bool operator<(const Cover &B) const {
return (p == B.p) ? (q > B.q) : (p < B.p);
}
} cover[(100001 * 2)];
int ent[100001][2], stk[(100001 * 2)], sn;
void coveron(int eid, int v) {
int a = ent[eid][0], b = ent[eid][1];
modify(inp[a], oup[a], v);
modify(inp[b], oup[b], v);
}
void print(int eid) {
int a = ent[eid][0], b = ent[eid][1];
printf("[%d,%d] [%d,%d]\n", inp[a], oup[a], inp[b], oup[b]);
}
int main() {
int i, j, x, y;
scanf("%d%d", &N, &Q);
for (i = 1; i < N; i++) {
scanf("%d%d", &x, &y);
G.make_edge(x, y);
G.make_edge(y, x);
}
dfs(1);
TN = N * 2;
for (TM = 1; TM < TN + 2; TM <<= 1)
;
for (i = 1; i <= N; i++) node[inp[i] + TM].n = 1;
for (i = TM - 1; i > 0; i--) node[i].n = node[i << 1].n + node[i << 1 | 1].n;
for (i = 1; i <= Q; i++) {
scanf("%d%d", &x, &y);
ent[i][0] = x, ent[i][1] = y;
cover[(i << 1)] = Cover(inp[x], oup[x], i);
cover[(i << 1) - 1] = Cover(inp[y], oup[y], i);
}
std::sort(cover + 1, cover + Q * 2 + 1);
for (i = 1, j = 1; i <= TN; i++) {
while (j <= 2 * Q && cover[j].p == i) {
stk[sn++] = j;
coveron(cover[j].id, 1);
j++;
}
while (sn > 0 && cover[stk[sn - 1]].q == i) {
coveron(cover[stk[sn - 1]].id, -1);
sn--;
}
if (_inp[i]) {
ans[_inp[i]] = node[1].m - 1;
if (sn == 0) ans[_inp[i]] = 0;
}
}
for (i = 1; i <= N; i++) {
if (i > 1) putchar(' ');
printf("%d", ans[i]);
}
putchar('\n');
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i, j, k;
printf("%d\n", n + m - 1);
for (int i = (1); i <= (m); i++) {
printf("%d %d\n", 1, i);
}
for (i = 2; i <= n; i++) {
printf("%d %d\n", i, 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimze("Ofast")
using namespace std;
const int N = 1e5 + 5;
int n, m;
long long dung, res;
vector<int> a[N];
priority_queue<long long> hm;
long long r[N], c[N];
void nhap() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
a[i].push_back(0);
for (int j = 1; j <= m; j++) {
cin >> dung;
a[i].push_back(dung);
r[i] += dung;
c[j] += dung;
}
}
}
void xl1() {
if (min(n, m) <= 4) return;
for (int i = 1; i <= n; i++) {
long long kq = r[i];
for (int j = 1; j <= m; j++) {
hm.push(a[i][j] - c[j]);
if (hm.size() > 3) hm.pop();
}
while (!hm.empty()) {
kq += -hm.top();
hm.pop();
}
res = max(res, kq);
}
for (int i = 1; i <= m; i++) {
long long kq = c[i];
for (int j = 1; j <= n; j++) {
hm.push(a[j][i] - r[j]);
if (hm.size() > 3) hm.pop();
}
while (!hm.empty()) {
kq += -hm.top();
hm.pop();
}
res = max(res, kq);
}
}
void xl2() {
long long kq = 0;
for (int i = 1; i <= n; i++) {
hm.push(-r[i]);
if (hm.size() > 4) hm.pop();
}
while (!hm.empty()) {
kq += -hm.top();
hm.pop();
}
res = max(res, kq);
kq = 0;
for (int i = 1; i <= m; i++) {
hm.push(-c[i]);
if (hm.size() > 4) hm.pop();
}
while (!hm.empty()) {
kq += -hm.top();
hm.pop();
}
res = max(res, kq);
}
void xl3() {
if (min(n, m) <= 4) return;
if (n <= m) {
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
long long kq = r[i] + r[j];
for (int k = 1; k <= m; k++) {
hm.push(a[i][k] + a[j][k] - c[k]);
if (hm.size() > 2) hm.pop();
}
while (!hm.empty()) {
kq += -hm.top();
hm.pop();
}
res = max(res, kq);
}
}
} else {
for (int i = 1; i < m; i++) {
for (int j = i + 1; j <= m; j++) {
long long kq = c[i] + c[j];
for (int k = 1; k <= n; k++) {
hm.push(a[k][i] - a[k][j] - r[k]);
if (hm.size() > 2) hm.pop();
}
while (!hm.empty()) {
kq += -hm.top();
hm.pop();
}
res = max(res, kq);
}
}
}
}
void xuli() {
xl1();
xl2();
xl3();
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
nhap();
xuli();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)(1e18);
const long long inf = 1e9 + 7;
long double eps = 1e-10;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long mod = 998244853;
long long pows(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 1) return (a * pows(a, b - 1)) % mod;
if (b % 2 == 0) {
long long c = pows(a, b / 2);
return (c * c) % mod;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int k, l;
cin >> k >> l;
vector<int> a(n), b(m);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
if (a[k - 1] < b[m - l])
cout << "YES";
else
cout << "NO";
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int t;
int a[104];
int n;
int b[100004];
int main()
{
cin>>t;
while(t>0)
{
--t;
cin>>n;
bool ok=true;
for(int i=1; i<=n; ++i)
{
cin>>a[i];
int x=sqrt(a[i]);
if(x*x!=a[i])
{
ok=false;
}
}
if(ok)
cout<<"NO"<<'\n';
else
cout<<"YES"<<'\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int FixMod(int s, int k) { return (s % k + k) % k; }
enum dir {
DOWN = 0,
UP,
RIGHT,
LEFT,
DOWN_RIGHT,
DOWN_LEFT,
UP_RIGHT,
UP_LEFT
};
int dir_r[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dir_c[] = {0, 0, 1, -1, 1, -1, 1, -1};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, v;
cin >> n >> m >> v;
if (m > n * (n - 1) / 2 - (n - 2) || m < n - 1) return !(cout << -1);
int ok = -1;
for (int i = 1; i <= n && m; i++) {
if (i != v) {
ok = i;
cout << i << " " << v << '\n';
m--;
break;
}
}
for (int i = 1; i <= n && m > 0; i++) {
if (i == ok) continue;
for (int j = i + 1; j <= n && m > 0; j++) {
if (j == ok) continue;
cout << i << " " << j << '\n';
m--;
}
if (i == n - 1 && m) i = 1;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int d[400001], num[400001];
vector<pair<long long int, long long int> > vv;
int main() {
int i;
int t, m;
long long int n, k, p, o;
scanf("%d", &t);
while (t--) {
scanf("%I64d %d %I64d", &n, &m, &k), o = 0;
for (i = 0; i < m; i++) scanf("%I64d", &p), d[i] = p - o, o = p;
d[m++] = n - o, k += m;
long long int l = 1, r = n;
while (l < r) {
long long int mid = (l + r) / 2;
long long int c = 0;
for (i = 0; i < m; i++) c += (d[i] + mid - 1) / mid;
if (c > k)
l = mid + 1;
else
r = mid;
}
long long int e = r;
l = 1, r = n;
while (l < r) {
long long int mid = (l + r + 1) / 2;
long long int c = 0;
for (i = 0; i < m; i++) {
if (d[i] < mid) {
c = -1e18;
break;
} else
c += d[i] / mid;
}
if (c < k)
r = mid - 1;
else
l = mid;
}
long long int s = l;
for (i = 0; i < m; i++) {
long long int a = d[i] / s;
if ((d[i] + a - 1) / a > e)
vv.push_back(make_pair((d[i] + a - 1) / a - e, s - d[i] / (a + 1)));
}
if (vv.empty())
printf("%I64d\n", e - s);
else {
sort(vv.begin(), vv.end());
long long int ans = e - s + vv.back().first, ss = 0;
for (i = vv.size() - 1; i >= 0; i--) {
ss = max(ss, vv[i].second);
ans = min(ans, e - s + ((i == 0) ? 0 : vv[i - 1].first) + ss);
}
printf("%I64d\n", ans);
vv.clear();
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 7e4 + 4;
const int A = 10;
string w[N];
int code(char x) { return x - '0'; }
const int V = N * 9 * 10 / 2;
int to[V][A], tn;
int cnt[V], lst[V];
void add(string s, int id) {
int v = 0;
for (char cc : s) {
int c = code(cc);
if (!to[v][c]) {
to[v][c] = ++tn;
}
v = to[v][c];
if (lst[v] < id) {
++cnt[v];
lst[v] = id;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cerr << sizeof(to) / (1 << 20) << endl;
int n, m;
cin >> n;
for (int k = 1; k <= n; ++k) {
string s;
cin >> s;
w[k] = s;
for (int i = 0; i < 9; ++i) add(s.substr(i), k);
}
for (int k = 1; k <= n; ++k) {
string s = w[k];
string res = s;
for (int i = 0; i < 9; ++i) {
string t;
int v = 0;
for (int j = i; j < 9; ++j) {
t += s[j];
int c = code(s[j]);
v = to[v][c];
if (cnt[v] == 1) {
if (res.size() > t.size()) res = t;
break;
}
}
}
cout << res << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 47, mod = 1e9 + 7;
long long dp[MAXN][3][2];
long long n, m;
void read() {
cin >> n >> m;
dp[1][1][0] = dp[1][1][1] = 1;
dp[2][1][0] = dp[2][1][1] = 1;
dp[2][2][0] = dp[2][2][1] = 1;
for (long long i = 3; i < MAXN; i++) {
for (long long len = 1; len < 3; len++) {
for (long long frt = 0; frt < 2; frt++) {
dp[i][len][frt] += dp[i - len][1][frt ^ 1] + dp[i - len][2][frt ^ 1];
dp[i][len][frt] %= mod;
}
}
}
long long ans = 0;
for (long long len = 1; len < 3; len++)
for (long long frt = 0; frt < 2; frt++)
ans += dp[n][len][frt] + dp[m][len][frt];
ans = (ans - 2 + mod);
ans %= mod;
cout << ans << "\n";
}
void solve() {}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
read();
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, x, y;
cin >> x >> a >> y >> b;
for (;;) {
x = x < n ? (x + 1) : 1;
y = y == 1 ? n : y - 1;
if (x == y) {
cout << "YES\n";
return 0;
}
if (x == a || y == b) {
break;
}
}
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nxt, w;
} e[200005 << 1];
int n, cnt, Sz, Rt, Mn, ans1;
int val[200005], fir[200005], sz[200005];
bool vis[200005];
double ans2, sum, sumh;
double h[200005];
void add(int, int, int);
void get_rt(int, int);
void get_sz(int, int);
void divide(int);
void calc(int, int, int, int);
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", val + i);
for (int i = 2; i <= n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
ans2 = 9000000000000000000;
Sz = n;
Mn = n + 1;
get_sz(1, 0);
get_rt(1, 0);
divide(Rt);
printf("%d %.10lf\n", ans1, ans2);
return 0;
}
void add(int u, int v, int w) {
e[++cnt] = (edge){v, fir[u], w};
fir[u] = cnt;
return;
}
void get_sz(int u, int fa) {
sz[u] = 1;
for (int i = fir[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa || vis[v]) continue;
get_sz(v, u);
sz[u] += sz[v];
}
return;
}
void get_rt(int u, int fa) {
int mx = 0;
for (int i = fir[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa || vis[v]) continue;
mx = max(mx, sz[v]);
get_rt(v, u);
}
mx = max(mx, Sz - sz[u]);
if (mx < Mn) Mn = mx, Rt = u;
return;
}
void calc(int u, int fa, int rt, int dis) {
sum += pow(dis, 1.5) * val[u];
double tmp = 1.5 * val[u] * sqrt(dis);
sumh += tmp;
h[rt] += tmp;
for (int i = fir[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
calc(v, u, rt, dis + e[i].w);
}
return;
}
void divide(int u) {
if (vis[u]) return;
sum = sumh = 0;
vis[u] = true;
for (int i = fir[u]; i; i = e[i].nxt) {
int v = e[i].to;
h[v] = 0;
calc(v, u, v, e[i].w);
}
if (sum < ans2) ans1 = u, ans2 = sum;
for (int i = fir[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (sumh - h[v] * 2 < 0) {
Mn = n + 1;
get_sz(v, u);
Sz = sz[v];
get_rt(v, u);
divide(Rt);
break;
}
}
return;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
vector<long long int> adj[200015], ans[200015];
long long int mx = 0;
map<pair<long long int, long long int>, long long int> ma;
void dfs(long long int cur, long long int par, long long int not_allowed) {
long long int c = 1;
for (auto x : adj[cur]) {
if (x == par) continue;
if (c == not_allowed) {
c++;
}
long long int id = ma[{x, cur}];
ans[c].push_back(id);
dfs(x, cur, c);
mx = max(mx, c);
c++;
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n;
for (long long int i = 0; i < n - 1; ++i) {
long long int x, y;
cin >> x >> y;
ma[{y, x}] = i + 1LL;
ma[{x, y}] = i + 1LL;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, -1, 0);
cout << mx << "\n";
for (long long int i = 1; i <= mx; ++i) {
cout << ans[i].size() << " ";
for (auto x : ans[i]) cout << x << " ";
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 1e6 + 10, inf = 1e9 + 10;
const long long INF = 1e18 + 10, mod = 2147493647;
int main() {
int n;
scanf("%d", &n);
int m = (int)sqrt(n) + 0.0001;
for (int i = m; i >= 1; i--) {
if (n % i == 0) {
printf("%d %d\n", i, n / i);
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[20009][11];
int ans[20009];
int x, y, msg[11];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
msg[y - 1]++;
ans[x - 1]--;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] > 0) ans[i] += msg[j];
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main(void) {
long long int n, i, j, maxGlobal, temp;
scanf("%lld", &n);
long long int m[n], max[n];
long long int ans;
for (i = 0; i < n; i++) {
scanf("%lld", &m[i]);
for (j = 0, max[i] = 0; j < m[i]; j++) {
scanf("%lld", &temp);
if (temp > max[i]) max[i] = temp;
}
}
for (i = 0, maxGlobal = 0; i < n; i++) {
if (maxGlobal < max[i]) {
maxGlobal = max[i];
}
}
for (i = 0, ans = 0; i < n; i++) {
ans += (maxGlobal - max[i]) * m[i];
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int nm = 20;
int n, k;
char a[nm], kq[nm];
int main() {
scanf("%s%d", a, &k);
n = strlen(a);
int i, j, tg, u;
char x;
for (i = 0; i < n; ++i) {
tg = i;
for (j = i + 1; j <= i + k && j < n; ++j)
if (a[j] > a[tg]) tg = j;
x = a[tg];
for (u = tg; u > i; --u) a[u] = a[u - 1];
a[i] = x;
k -= tg - i;
}
printf("%s", a);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool check(long long int child, vector<long long int> adj[],
vector<long long int> &vis, vector<long long int> &c) {
vis[child] = 1;
for (long long int i = 0; i < adj[child].size(); i++) {
long long int y = adj[child][i];
if (!vis[y]) {
vis[y] = 1;
if (c[child] != c[y] || !check(y, adj, vis, c)) return false;
}
}
return true;
}
bool dfs(long long int child, vector<long long int> adj[],
vector<long long int> &vis, vector<long long int> &c) {
for (long long int i = 1; i < vis.size(); i++) vis[i] = 0;
vis[child] = 1;
for (long long int i = 0; i < adj[child].size(); i++) {
long long int y = adj[child][i];
if (!check(y, adj, vis, c)) return false;
}
return true;
}
int32_t main() {
long long int t = 0;
t = 1;
while (t--) {
long long int n = 0;
cin >> n;
vector<long long int> adj[n + 1];
vector<long long int> vis(n + 1, 0);
pair<long long int, long long int> edge[n + 1];
for (long long int i = 1; i < n; i++) {
long long int u = 0;
long long int v = 0;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
edge[i] = {u, v};
}
vector<long long int> c(n + 1, 0);
for (long long int i = 1; i <= n; i++) cin >> c[i];
long long int a = -1;
long long int b = -1;
long long int count = 0;
for (long long int i = 1; i < n; i++) {
long long int x = edge[i].first;
long long int y = edge[i].second;
if (c[x] != c[y]) {
if (count > 0 && !(a != x && a != y && b != x && b != y)) count--;
count++;
a = x;
b = y;
}
}
if (count == 0) {
cout << "YES" << endl;
cout << 1 << endl;
return 0;
} else if (count > 1) {
cout << "NO" << endl;
return 0;
} else if (dfs(a, adj, vis, c)) {
cout << "YES" << endl;
cout << a << endl;
return 0;
} else if (dfs(b, adj, vis, c)) {
cout << "YES" << endl;
cout << b << endl;
return 0;
} else
cout << "NO" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[30005];
bool vis[30005];
void dfs(int curr) {
if (vis[curr]) return;
vis[curr] = true;
for (int i = 0; i < adj[curr].size(); i++) dfs(adj[curr][i]);
cout << curr << " ";
}
int main() {
int n, m, u, v;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].push_back(v);
}
memset(vis, false, sizeof vis);
for (int i = 1; i < n + 1; i++)
if (!vis[i]) dfs(i);
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000 + 10;
int f[maxn][maxn];
int t[maxn], d[maxn];
int k, n;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d%d", &t[i], &d[i]);
int ans = 0;
f[0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int lim = min(i, k), j = 0; j <= lim; ++j) {
f[i][j] = max(f[i - 1][j], t[i]) + d[i];
if (j > 0 && f[i - 1][j - 1] < f[i][j]) f[i][j] = f[i - 1][j - 1];
if (t[i] - f[i - 1][j] > ans) ans = t[i] - f[i - 1][j];
}
for (int i = 0; i <= k; ++i)
if (86400 - f[n][i] + 1 > ans) ans = 86400 - f[n][i] + 1;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long arr[666666];
map<long long, long long> vis;
signed main() {
long long n, a, b;
cin >> n >> a >> b;
string str;
cin >> str;
long long cnt = 0;
long long sum = 0;
for (long long i = 0; i < n + 1; i++) {
if (str[i] == '.') {
sum++;
} else {
if (sum) arr[cnt++] = sum;
sum = 0;
}
}
if (!cnt) {
cout << "0";
return 0;
}
long long A = a;
long long B = b;
long long f = 0;
for (long long k = 0; k < cnt; k++) {
if (a > b)
f = 1;
else
f = 0;
long long cnt = 0;
for (long long i = 0; i < arr[k]; i++) {
cnt++;
if (f) {
if (cnt % 2 == 1 && a > 0) {
a--;
} else if (cnt % 2 == 0 && b > 0) {
b--;
}
} else {
if (cnt % 2 == 1 && b > 0) {
b--;
} else if (cnt % 2 == 0 && a > 0) {
a--;
}
}
}
}
long long ans = (A - a) + (B - b);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
enum { MOD0 = 1000000000, MOD7 = 1000000007, MOD9 = 1000000009 };
template <typename T>
ostream &operator<<(ostream &cout, vector<T> &a) {
for (size_t i = 0; i < a.size(); ++i) cout << a[i] << " ";
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, vector<vector<T> > &a) {
for (size_t i = 0; i < a.size(); ++i) cout << a[i] << endl;
return cout;
}
int a[200000];
int b[200000];
size_t nxt[200000];
size_t get_next(size_t index) {
size_t &ret = nxt[index];
if (b[ret] >= 0) {
return ret = get_next(ret);
} else {
return ret;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
size_t n, m;
cin >> n >> m;
for (size_t i = 0; i < n; ++i) {
cin >> a[i];
++b[a[i] % m];
}
const size_t norm = n / m;
for (size_t i = 0; i < m; ++i) {
b[i] -= norm;
nxt[i] = i + 1;
}
nxt[m - 1] = 0;
unsigned long long ans = 0;
for (size_t i = 0; i < n; ++i) {
size_t cur = a[i] % m;
if (b[cur] > 0) {
size_t chg = get_next(cur);
const size_t add = (m + chg - cur) % m;
a[i] += add;
ans += add;
--b[cur];
++b[chg];
}
}
cout << ans << '\n';
for (size_t i = 0; i < n; ++i) {
cout << a[i] << " ";
}
cout << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int n, m, k, len, le, nex[N], nex1[N], wen[N], wen1[N], hea1[N], hea[N], val[N],
bo[N], root;
struct arr {
int x, y;
} a[N];
bool cmp(arr xx, arr yy) { return xx.x < yy.x; }
void add(int x, int y) {
++len;
nex[len] = hea[x];
wen[len] = y;
hea[x] = len;
}
void dfs(int x, int y) {
val[x] = bo[x];
for (int i = hea[x]; i > 0; i = nex[i])
if (y != wen[i]) dfs(wen[i], x), val[x] += val[wen[i]];
}
void dfs1(int x, int y) {
if (bo[x] == 1) {
++le;
nex1[le] = hea1[k];
wen1[le] = x;
hea1[k] = le;
}
for (int i = hea[x]; i > 0; i = nex[i])
if (y != wen[i]) dfs1(wen[i], x);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
bo[x] = bo[y] = 1;
}
root = 1;
dfs(root, 0);
int boo;
do {
boo = 0;
for (int i = hea[root]; i > 0; i = nex[i])
if (val[wen[i]] > m) {
val[root] -= val[wen[i]];
val[wen[i]] = m * 2;
root = wen[i];
boo = 1;
break;
}
} while (boo);
printf("1\n%d\n", root);
for (int i = hea[root]; i > 0; i = nex[i])
if (val[wen[i]]) {
++k;
a[k].x = val[wen[i]];
a[k].y = k;
dfs1(wen[i], root);
}
sort(a + 1, a + k + 1, cmp);
for (int i = 1, j = k; m > 0; m--) {
if (i == j && m == 1 && a[i].x == 1) {
printf("%d %d %d\n", wen1[hea1[a[i].y]], root, root);
return 0;
}
--a[i].x;
--a[j].x;
printf("%d %d %d\n", wen1[hea1[a[i].y]], wen1[hea1[a[j].y]], root);
hea1[a[i].y] = nex1[hea1[a[i].y]];
hea1[a[j].y] = nex1[hea1[a[j].y]];
while (a[i].x == 0 && i < k) ++i;
if (a[j].x > 0 && a[j].x < a[i].x) swap(a[i], a[j]);
if (a[j - 1].x > a[j].x) --j;
if (a[j + 1].x > a[j].x) ++j;
while (a[j].x == 0 && j < k) ++j;
int jj = j;
if (i == j) {
++j;
while (a[j].x == 0 && j <= k) ++j;
if (j > k) j = jj;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T In() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <class T, class first>
inline bool checkbit(T a, first pos) {
T t = 1;
return ((a & (t << pos)) > 0);
}
template <class T, class first>
inline T setbit(T a, first pos) {
T t = 1;
return (a | (t << pos));
}
template <class T, class first>
inline T resetbit(T a, first pos) {
T t = 1;
return (a & (~(t << pos)));
}
template <class T, class first>
inline T togglebit(T a, first pos) {
T t = 1;
return (a ^ (t << pos));
}
template <typename T>
T POW(T base, T power) {
T ret = 1;
while (power) {
if (power & 1) ret = (ret * base);
base = (base * base);
power >>= 1;
}
return ret;
}
template <typename T>
T GCD(T a, T b) {
if (a < 0) return GCD(-a, b);
if (b < 0) return GCD(a, -b);
return (b == 0) ? a : GCD(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return a * (b / GCD(a, b));
}
template <typename T>
T EUCLIDE(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
long long Bigmod(long long base, long long power, long long _MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % _MOD;
base = (base * base) % _MOD;
power >>= 1;
}
return ret;
}
long long ModInverse(long long number, long long _MOD) {
return Bigmod(number, _MOD - 2LL, _MOD);
}
template <typename T>
double DIS(T x1, T y1, T x2, T y2) {
return sqrt((double)((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
}
template <typename T>
T ANGLE(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
long long isLeft(T a, T b, T c) {
return (c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y);
}
const double PI = 2 * acos(0);
double DEG(double x) { return (180.0 * x) / (PI * 1.0); }
double RAD(double x) { return (x * (PI * 1.0)) / (180.0); }
void P_ARR(int *ar, int a, int b) {
if (a > b) swap(a, b);
if (a <= b) cout << ar[a];
for (int i = a + 1; i <= b; i++) cout << " " << ar[i];
cout << endl;
}
template <class T>
inline void make_unique_vec(vector<T> &vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
template <class T>
inline void make_unique_arr(T *ar, int &n) {
sort(ar + 1, ar + n + 1);
n = unique(ar + 1, ar + n + 1) - ar - 1;
}
int main() {
long long n;
scanf("%lld", &n);
char ss;
cin >> ss;
long long tot = 0;
long long koto = (n - 1) / 4;
tot += koto * 4;
long long a = (n - 1) / 4;
a = a * 2 * 6;
tot += a;
if (n % 2 == 0)
tot += 7;
else
tot += 0;
if (ss == 'f') tot += 1;
if (ss == 'e') tot += 2;
if (ss == 'd') tot += 3;
if (ss == 'a') tot += 4;
if (ss == 'b') tot += 5;
if (ss == 'c') tot += 6;
printf("%lld\n", tot);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long ab(long long c) {
if (c < 0) return -c;
return c;
}
long long pow(long long a, long long b) {
long long p = a % mod, ans = 1;
while (b) {
if (b & 1) ans = (ans * p) % mod;
p = (p * p) % mod;
b >>= 1;
}
return ans;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long ans = 0, cnt = 0, p = a[0];
for (int i = 0; i < n; i++) {
if (i != 0 && p == a[i]) {
cnt++;
} else {
cnt = 1;
p = a[i];
}
if (ans < cnt) ans = cnt;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int main() {
int x;
for (int i = 0; i < 3; i++) cin >> x, a.push_back(x);
sort(a.begin(), a.end());
int dif = a[2] - a[1] - a[0] + 1;
printf("%d\n", max(dif, 0));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[2005], b[2005], n, sum;
cin >> n >> sum;
for (int i = 0; i < n; i++) cin >> a[i];
b[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) b[i] = max(b[i + 1], a[i]);
int ans = 0;
for (int i = 0; i < n; i++) ans = max(ans, (sum / a[i]) * (b[i] - a[i]));
ans += sum;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
map<int, int> val;
int p, k;
int main() {
int n;
scanf("%d%d%d", &n, &p, &k);
auto p4 = [](int x) -> int { return 1LL * x * x % p * x % p * x % p; };
long long ans = 0;
k = p - k;
while (n--) {
int x;
scanf("%d", &x);
int v = (p4(x) + 1LL * k * x) % p;
ans += val[v];
val[v]++;
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 71;
const long long MOD = 1e9 + 7;
const int oo = 1e9;
int n, m, k;
long long dp[N][N][N][N], a[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++)
for (int K = 0; K <= m; K++)
for (int d = 0; d <= k - 1; d++) dp[i][j][K][d] = -oo;
dp[1][0][0][0] = 0;
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int cnt = 0; cnt <= m / 2; cnt++)
for (int re = 0; re <= k - 1; re++)
dp[i][0][0][re] = max(dp[i][0][0][re], dp[i - 1][m][cnt][re]);
ans = max(ans, dp[i][0][0][0]);
for (int j = 1; j <= m; j++) {
for (int cnt = 0; cnt <= m / 2; cnt++)
for (int d = 0; d <= k - 1; d++) {
dp[i][j][cnt][d] = dp[i][j - 1][cnt][d];
if (cnt == 0) continue;
if (dp[i][j - 1][cnt - 1][(((d - a[i][j]) % k) + k) % k] != -oo)
dp[i][j][cnt][d] = max(
dp[i][j][cnt][d],
dp[i][j - 1][cnt - 1][(((d - a[i][j]) % k) + k) % k] + a[i][j]);
if (d == 0) ans = max(ans, dp[i][j][cnt][d]);
}
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
const int INF = 0x3f3f3f3f;
long long n, k, m;
vector<pair<long long, long long> > vec[MAXN];
long long cnt[MAXN << 2], sum[MAXN << 2];
void Build(int l, int r, int rt) {
if (l == r) {
cnt[rt] = sum[rt] = 0;
return;
}
int m = (l + r) >> 1;
Build(l, m, rt << 1);
Build(m + 1, r, rt << 1 | 1);
}
void PushUp(int rt) {
cnt[rt] = cnt[rt << 1] + cnt[rt << 1 | 1];
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void Update(long long pos, long long val, int l, int r, int rt) {
if (l == r) {
cnt[rt] += val;
sum[rt] += val * pos;
return;
}
int m = (l + r) >> 1;
if (pos <= m)
Update(pos, val, l, m, rt << 1);
else
Update(pos, val, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
long long Query(long long x, int l, int r, int rt) {
if (cnt[rt] <= x) return sum[rt];
if (l == r) return x * l;
int m = (l + r) >> 1;
if (cnt[rt << 1] >= x) return Query(x, l, m, rt << 1);
return Query(cnt[rt << 1], l, m, rt << 1) +
Query(x - cnt[rt << 1], m + 1, r, rt << 1 | 1);
}
int main() {
scanf("%lld%lld%lld", &n, &k, &m);
long long l, r, c, p, ans = 0, Max = 0;
for (int i = 1; i <= m; ++i) {
scanf("%lld%lld%lld%lld", &l, &r, &c, &p);
Max = max(Max, p);
vec[l].push_back(pair<long long, long long>(c, p));
vec[r + 1].push_back(pair<long long, long long>(-1 * c, p));
}
Build(1, Max, 1);
for (int i = 1; i <= n; ++i) {
for (auto& v : vec[i]) Update(v.second, v.first, 1, Max, 1);
ans += Query(k, 1, Max, 1);
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int mod = 1000000007;
const int gmod = 3;
const int inf = 1039074182;
const double eps = 1e-9;
const double pi = 3.141592653589793238462643383279;
const long long llinf = 2LL * inf * inf;
template <typename T1, typename T2>
inline void chmin(T1 &x, T2 b) {
if (b < x) x = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &x, T2 b) {
if (b > x) x = b;
}
inline void chadd(int &x, int b) {
x += b - mod;
x += (x >> 31 & mod);
}
template <typename T1, typename T2>
inline void chadd(T1 &x, T2 b) {
x += b;
if (x >= mod) x -= mod;
}
template <typename T1, typename T2>
inline void chmul(T1 &x, T2 b) {
x = 1LL * x * b % mod;
}
template <typename T1, typename T2>
inline void chmod(T1 &x, T2 b) {
x %= b, x += b;
if (x >= b) x -= b;
}
template <typename T>
inline T mabs(T x) {
return (x < 0 ? -x : x);
}
using namespace std;
using namespace std;
template <typename T>
ostream &operator<<(ostream &cout, const vector<T> &vec) {
cout << "{";
for (int i = 0; i < (int)vec.size(); i++) {
cout << vec[i];
if (i != (int)vec.size() - 1) cout << ',';
}
cout << "}";
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p) {
cout << "(" << p.first << ',' << p.second << ")";
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, set<T, T2> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, multiset<T, T2> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, queue<T> q) {
vector<T> t;
while (q.size()) {
t.push_back(q.front());
q.pop();
}
cout << t;
return cout;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &cout, map<T1, T2, T3> m) {
for (auto &x : m) {
cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
}
return cout;
}
template <typename T1, typename T2>
void operator+=(pair<T1, T2> &x, const pair<T1, T2> y) {
x.first += y.first;
x.second += y.second;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &x, const pair<T1, T2> &y) {
return make_pair(x.first + y.first, x.second + y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &x, const pair<T1, T2> &y) {
return make_pair(x.first - y.first, x.second - y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> x) {
return make_pair(-x.first, -x.second);
}
template <typename T>
vector<vector<T>> operator~(vector<vector<T>> vec) {
vector<vector<T>> v;
int n = vec.size(), m = vec[0].size();
v.resize(m);
for (int i = 0; i < m; i++) {
v[i].resize(n);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
v[i][j] = vec[j][i];
}
}
return v;
}
void print0x(int x) {
std::vector<int> vec;
while (x) {
vec.push_back(x & 1);
x >>= 1;
}
std::reverse(vec.begin(), vec.end());
for (int i = 0; i < (int)vec.size(); i++) {
std::cout << vec[i];
}
std::cout << ' ';
}
template <typename T>
void print0x(T x, int len) {
std::vector<int> vec;
while (x) {
std::cout << (x & 1);
x >>= 1;
len--;
}
while (len--) cout << 0;
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
using namespace std;
char a[2005];
char b[2005];
int n;
const int Basis = 1005;
struct Value {
int ways;
int tot;
Value() {}
Value(int a, int b) : ways(a), tot(b) {}
Value eat(int x) { return Value(ways, (1LL * ways * x + tot) % mod); }
Value &operator+=(const Value &oth) {
chadd(ways, oth.ways);
chadd(tot, oth.tot);
return (*this);
}
};
Value _dp[2005][2015];
Value &dp(int x, int y) { return _dp[x][y + Basis]; }
void solve() {
scanf("%d", &n);
scanf("%s%s", a, b);
for (int i = 0; i <= n; i++)
for (int j = -n / 2; j <= n / 2; j++) dp(i, j) = Value(0, 0);
dp(0, 0) = Value(1, 0);
for (int i = 0; i < n; i++) {
for (int j = -i; j <= i; j++) {
if (j < -n / 2 || j > n / 2) continue;
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
if (a[i] != '?' && a[i] != x + '0') continue;
if (b[i] != '?' && b[i] != y + '0') continue;
int sgn = (x - y);
if (i & 1) sgn *= -1;
dp(i + 1, j + sgn) += dp(i, j).eat(mabs(j));
}
}
}
}
cout << dp(n, 0).tot << endl;
}
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
int k[1005];
int HMF() {
int sum = 0;
for (int i = 1; i <= n; i = i + 1)
if (k[i] < 0) sum = sum + 1;
return sum;
}
int HMZ() {
int sum = 0;
for (int i = 1; i <= n; i = i + 1)
if (k[i] > 0) sum = sum + 1;
return sum;
}
int HM0() {
int sum = 0;
for (int i = 1; i <= n; i = i + 1)
if (k[i] == 0) sum = sum + 1;
return sum;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i = i + 1) cin >> k[i];
for (int i = 1; i <= n; i = i + 1)
if (k[i] > 0) cout << k[i] << " ";
int fs = HMF();
int zs = HMZ();
int zero = HM0();
if (fs == 1 && zs > 0) return 0;
if (fs == 1 && zs == 0) {
if (zero == 0)
cout << k[1];
else
cout << 0;
return 0;
}
if (fs % 2 == 0) {
for (int i = 1; i <= n; i = i + 1)
if (k[i] < 0) cout << k[i] << " ";
}
bool flag = 0;
if (fs % 2 == 1) {
int maxn = -1000000;
int MAX = -1;
for (int i = 1; i <= n; i = i + 1) {
if (k[i] < 0 && k[i] > maxn) {
maxn = k[i];
MAX = i;
}
}
for (int i = 1; i <= n; i = i + 1)
if (k[i] < 0 && i != MAX) cout << k[i] << " ";
}
if (zs == 0 && fs == 0) cout << 0;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct Matrix {
long long a, b, c, d;
Matrix(long long _a = 0, long long _b = 0, long long _c = 0,
long long _d = 0) {
a = _a;
b = _b;
c = _c;
d = _d;
}
void normalize(Matrix& mat) {
mat.a %= mod;
mat.b %= mod;
mat.c %= mod;
mat.d %= mod;
}
const Matrix operator+(const Matrix& mat) {
Matrix tmp(this->a + mat.a, this->b + mat.b, this->c + mat.c,
this->d + mat.d);
normalize(tmp);
return tmp;
}
const Matrix operator*(const Matrix& mat) {
Matrix tmp(
this->a * mat.a + this->b * mat.c, this->a * mat.b + this->b * mat.d,
this->c * mat.a + this->d * mat.c, this->c * mat.b + this->d * mat.d);
normalize(tmp);
return tmp;
}
bool operator==(const Matrix& mat) const {
if (this->a == mat.a && this->b == mat.b && this->c == mat.c &&
this->d == mat.d)
return true;
return false;
}
bool operator!=(const Matrix& mat) const { return !(*this == mat); }
void pprint() {
return;
cerr << "---------------------------" << endl;
cerr << this->a << " | " << this->b << endl;
cerr << this->c << " | " << this->d << endl;
cerr << "---------------------------" << endl;
}
};
class SegmentTree {
private:
vector<Matrix> A, st, lazy;
int n;
Matrix lazyId;
int left(int p) { return p << 1; }
int right(int p) { return (p << 1) + 1; }
void build(int p, int l, int r) {
if (r - l == 1) {
st[p] = A[l];
return;
}
int mid = (l + r) / 2;
build(left(p), l, mid);
build(right(p), mid, r);
st[p] = st[left(p)] + st[right(p)];
}
void apply(int p, int l, int r) {
st[p] = lazy[p] * st[p];
if (r - l > 1) {
lazy[left(p)] = lazy[p] * lazy[left(p)];
lazy[right(p)] = lazy[p] * lazy[right(p)];
}
lazy[p] = lazyId;
}
void lazyUpdate(int p, int l, int r, int i, int j, Matrix& val) {
if (lazy[p] != lazyId) apply(p, l, r);
if (j <= l || r <= i) return;
if (i <= l && r <= j) {
lazy[p] = lazy[p] * val;
apply(p, l, r);
return;
}
int mid = (l + r) / 2;
lazyUpdate(left(p), l, mid, i, j, val);
lazyUpdate(right(p), mid, r, i, j, val);
st[p] = st[left(p)] + st[right(p)];
}
Matrix query(int p, int l, int r, int i, int j) {
if (j <= l || r <= i) return Matrix();
if (lazy[p] != lazyId) apply(p, l, r);
if (i <= l && r <= j) return st[p];
int mid = (l + r) / 2;
Matrix uno = query(left(p), l, mid, i, j);
Matrix dos = query(right(p), mid, r, i, j);
return uno + dos;
}
public:
SegmentTree(vector<Matrix> v) {
A = v;
n = v.size();
st.assign(4 * n, Matrix());
lazyId = Matrix(1, 0, 0, 1);
lazy.assign(4 * n, lazyId);
build(1, 0, n);
}
void update(int i, int j, Matrix& val) { lazyUpdate(1, 0, n, i, j, val); }
Matrix query(int i, int j) { return query(1, 0, n, i, j); }
};
Matrix pot(Matrix b, int k) {
if (k == 0) return Matrix(1, 0, 0, 1);
if (k % 2 == 0) {
Matrix tmp = pot(b, k / 2);
return tmp * tmp;
} else {
return b * pot(b, k - 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n, m;
cin >> n >> m;
Matrix base = Matrix(1, 1, 1, 0);
vector<Matrix> vec;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
Matrix tmp = pot(base, a);
vec.push_back(tmp);
;
;
tmp.pprint();
}
SegmentTree st(vec);
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 1) {
int l, r, x;
cin >> l >> r >> x;
l--;
r--;
Matrix tmp = pot(base, x);
;
;
tmp.pprint();
st.update(l, r + 1, tmp);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
Matrix tmp = st.query(l, r + 1);
tmp.pprint();
long long res = tmp.c % mod;
cout << res << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct segment {
int l, r, val, delt, tot, tot2;
} a[1200100];
int n, pos[300100], num[300100];
long long ans;
void check(int p) {
if (a[p].delt == 0) return;
a[p * 2].delt += a[p].delt;
a[p * 2 + 1].delt += a[p].delt;
a[p * 2].val += a[p].delt;
a[p * 2 + 1].val += a[p].delt;
a[p].delt = 0;
}
void build_tree(int p, int l, int r) {
a[p].l = l;
a[p].r = r;
a[p].tot = r - l + 1;
int m = (l + r) / 2;
if (l == r) return;
build_tree(p * 2, l, m);
build_tree(p * 2 + 1, m + 1, r);
}
void update(int p, int l, int r, int x) {
if (a[p].l >= l && a[p].r <= r) {
a[p].val += x;
a[p].delt += x;
return;
}
check(p);
int m = (a[p].l + a[p].r) / 2;
if (l <= m) update(p * 2, l, r, x);
if (r > m) update(p * 2 + 1, l, r, x);
a[p].val = min(a[p * 2].val, a[p * 2 + 1].val);
a[p].tot = a[p * 2].tot * (a[p].val == a[p * 2].val) +
a[p * 2 + 1].tot * (a[p].val == a[p * 2 + 1].val);
a[p].tot2 = a[p * 2].tot * (a[p].val + 1 == a[p * 2].val) +
a[p * 2 + 1].tot * (a[p].val + 1 == a[p * 2 + 1].val);
a[p].tot2 += a[p * 2].tot2 * (a[p].val == a[p * 2].val) +
a[p * 2 + 1].tot2 * (a[p].val == a[p * 2 + 1].val);
}
void query(int p, int l, int r) {
if (a[p].l >= l && a[p].r <= r) {
ans += a[p].tot * (a[p].val <= 2) + a[p].tot2 * (a[p].val == 1);
return;
}
check(p);
int m = (a[p].l + a[p].r) / 2;
if (m >= l) query(p * 2, l, r);
if (m < r) query(p * 2 + 1, l, r);
}
int main() {
int i, x, y;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
pos[x] = i;
}
build_tree(1, 1, n);
for (i = n; i; i--) {
num[pos[i]] = i;
x = num[pos[i] - 1];
y = num[pos[i] + 1];
if (x > y) swap(x, y);
if (x) {
update(1, i, x - 1, 1);
update(1, y, n, -1);
} else if (y)
update(1, i, y - 1, 1);
else
update(1, i, n, 1);
query(1, i, n);
}
printf("%I64d\n", ans - n);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n = 0, i, j;
char s, a[9][9];
for (i = 0; i < 8; i++) {
scanf("%s", a[i]);
}
for (i = 0; i < 8; i++)
for (j = 1; j < 8; j++)
if (a[i][j] == a[i][j - 1]) n++;
if (n == 0)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500023;
bool vis[N];
vector<int> adj[N];
int indx = 0;
vector<long long int> order;
int par[N];
void euler(int curr) {
vis[curr] = 1;
order.push_back(curr);
for (int i : adj[curr]) {
if (!vis[i]) {
euler(i);
order.push_back(curr);
}
}
}
void bfs(int root) {
queue<int> q;
vis[root] = 1;
q.push(root);
par[root] = 0;
while (!q.empty()) {
int curr = q.front();
q.pop();
for (int i : adj[curr]) {
if (vis[i]) continue;
vis[i] = 1;
par[i] = curr;
q.push(i);
}
}
}
void solve() {
long long int n;
cin >> n;
long long int color[n + 1];
for (long long int i = 0; i < n; i++) {
long long int c;
cin >> c;
color[i + 1] = c;
}
for (long long int i = 0; i < n - 1; i++) {
long long int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
euler(1);
for (long long int i = 0; i < n + 1; i++) vis[i] = 0;
bfs(1);
vector<long long int> ans;
ans.push_back(order[0]);
for (int i = 1; i < order.size() - 1; i++) {
if (order[i + 1] == par[order[i]]) {
ans.push_back(order[i]);
color[order[i]] *= -1;
if (color[order[i]] == -1) {
color[order[i + 1]] *= -1;
color[order[i]] *= -1;
ans.push_back(order[i + 1]);
ans.push_back(order[i]);
}
} else {
ans.push_back(order[i]);
color[order[i]] *= -1;
}
}
for (int i : ans) cout << i << ' ';
if (color[1] == -1) cout << 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
int t = 0;
while (t++ < T) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void show(T a, int n) {
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
cout << endl;
}
template <class T>
void show(T a, int r, int l) {
for (int i = 0; i < r; ++i) show(a[i], l);
cout << endl;
}
const int N = 300010;
const int M = N * 4;
const int oo = 2000000000;
int n, m, V;
int mid;
inline void print(int v) {
if (v == mid)
printf("%d", V);
else if (v == V)
printf("%d", mid);
else
printf("%d", v);
}
void solve() {
int i, j, k;
if (m < n - 1) {
puts("-1");
return;
}
mid = n - 1;
int an = n - 1;
if (an < 10000 && (an * (an - 1)) / 2 + 1 < m) {
puts("-1");
return;
}
for (i = 1; i < n; ++i) {
print(i);
printf(" ");
print(i + 1);
printf("\n");
}
m = m - (n - 1);
for (i = 1; i <= mid; ++i) {
if (m == 0) break;
for (j = i + 2; j <= mid; ++j) {
if (m == 0) break;
--m;
print(i);
printf(" ");
print(j);
printf("\n");
}
}
}
int main() {
int i, j, cas = 0;
scanf("%d %d %d", &n, &m, &V);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define triple pair<pair<int,int>,int>
#define vpii vector<pii >
#define Graph vector<vector<int> >
#define WGraph vector<vector<pii>>
#define pli pair<ll,int>
#define pll pair<ll,ll>
#define xx first
#define yy second
#define sci1(a) scanf("%d",&a)
#define sci2(a,b) scanf("%d %d",&a,&b)
#define sci3(a,b,c) scanf("%d %d %d",&a,&b,&c)
#define scs(s) scanf("%s",s)
#ifndef GET_MACRO
#define GET_MACRO(__1,__2,__3,NAME,...) NAME
#endif // GET_MACRO
#define sci(...) GET_MACRO(__VA_ARGS__,sci3,sci2,sci1)(__VA_ARGS__)
#define read freopen("input.txt","r",stdin)
#define write freopen("output.txt","w",stdout)
#define infl 0xfffffffffffffffll
#define infi 2000000000
#define LSB(i) ((i)&(-(i)))
#define mp(a,b) make_pair(a,b)
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);
#define bound(i,j,n,m) ((i)<n&&(j)<m&&(i)>=0&&(j)>=0)
inline void debugMode()
{
#ifndef ONLINE_JUDGE
read;
//write;
#endif // ONLINE_JUDGE
}
int f(int a,int b)
{
int r=0;
while(a>0)
{
a/=b;
r++;
}
return r;
}
void solvecases(int cse)
{
int a,b;
cin>>a>>b;
int add=0;
int mn=1000000,tmp;
if(b==1)
{
b++;
add=1;
}
for(int i=0;i<100;i++)
{
tmp=f(a,b+i)+i;
mn=min(mn,tmp);
}
cout<<mn+add<<'\n';
}
void preprocess()
{
}
int main()
{
fastio;
debugMode();
//preprocess();
int t=1;
cin>>t;
for(int i=1;i<=t;i++)
{
solvecases(i);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
const int N = 2e5 + 10;
vector<int> ad[N];
int n, col[N], d[N];
void dfs(int v, int p, int h = 0) {
d[v] = h;
for (int u : ad[v]) {
if (u == p) continue;
if (col[u] == col[v])
dfs(u, v, h);
else
dfs(u, v, h + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", col + i);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
ad[x].push_back(y);
ad[y].push_back(x);
}
dfs(1, 0);
int a = 1, mx = 0;
for (int i = 1; i <= n; i++)
if (d[i] > mx) mx = d[i], a = i;
memset(d, 0, sizeof(d));
dfs(a, 0);
mx = 0;
for (int i = 1; i <= n; i++) mx = max(mx, d[i]);
printf("%d\n", (mx + 1) / 2);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int mod = 998244353;
int Head[N], vet[N << 1], Next[N << 1];
int siz[N], Pow[N], dp[N];
int n, u, v, edgenum, ans;
inline void addedge(int u, int v) {
edgenum++;
vet[edgenum] = v;
Next[edgenum] = Head[u];
Head[u] = edgenum;
}
void dfs(int u, int f) {
int res = 1;
siz[u] = 1;
for (int e = Head[u]; e; e = Next[e]) {
int v = vet[e];
if (v == f) continue;
dfs(v, u);
siz[u] += siz[v];
res = 1ll * res * (Pow[siz[v] - 1] + dp[v]) % mod;
}
dp[u] = (Pow[siz[u] - 1] - res + mod) % mod;
ans = (ans + 1ll * Pow[n - siz[u]] * dp[u]) % mod;
}
int main() {
scanf("%d", &n);
Pow[0] = 1;
for (int i = 1; i <= n; i++) Pow[i] = Pow[i - 1] * 2 % mod;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
dfs(1, 0);
printf("%d\n", ans * 2 % mod);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long la, lb, ra, rb, ta, tb;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long calc(long long la, long long ra, long long lb, long long rb) {
return max(0ll, min(ra, rb) - max(la, lb) + 1);
}
int main() {
while (scanf("%lld%lld%lld", &la, &ra, &ta) != EOF) {
scanf("%lld%lld%lld", &lb, &rb, &tb);
if (la > lb) {
swap(la, lb);
swap(ra, rb);
swap(ta, tb);
}
long long g = gcd(ta, tb);
long long gap = ra - la;
la += ((lb - la) / g) * g;
ra = la + gap;
printf("%lld\n", max(calc(la, ra, lb, rb), calc(la + g, ra + g, lb, rb)));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> b;
multiset<int>::iterator it;
int sia = 0;
long long ansa = 0, ansb = 0;
stack<int> sta;
int k[1000005];
int main() {
int n, ansk = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", k + i);
if (k[i] > i) {
b.insert(k[i] - i);
ansb += k[i] - i;
} else {
++sia;
ansa += i - k[i];
}
}
long long mi = ansa + ansb;
int co = 1;
for (int i = n; i > 1; --i) {
ansb -= b.size();
ansa += sia;
int t = b.size();
it = b.upper_bound(co);
b.erase(b.begin(), it);
t -= b.size();
sia += t;
if (k[i] > n + 1) {
b.erase(b.find(k[i] - n - 1 + co));
ansb -= k[i] - n + 1;
} else {
--sia;
ansa -= n + 1 - k[i];
}
if (k[i] > 1) {
b.insert(k[i] - 1 + co);
ansb += k[i] - 1;
} else {
++sia;
ansa += 1 - k[i];
}
++co;
if (mi > ansa + ansb) {
mi = ansa + ansb;
ansk = co - 1;
}
}
cout << mi << ' ' << ansk << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
long long n, p;
cin >> n >> p;
vector<long long> A(n), B(p);
long long i;
for (i = 0; i < n; i++) cin >> A[i];
for (i = 0; i < p; i++) {
cin >> B[i];
B[i]--;
}
sort(B.begin(), B.end());
long long minn = B[0], maxx = B[0] + 1;
for (i = 0; i < p - 1; i++) {
if (B[i] + 1 != B[i + 1]) {
sort(A.begin() + minn, A.begin() + maxx + 1);
minn = B[i + 1];
maxx = B[i + 1] + 1;
} else {
maxx = B[i + 1] + 1;
}
}
sort(A.begin() + minn, A.begin() + maxx + 1);
long long f = 0;
for (i = 0; i < n - 1; i++) {
if (A[i] > A[i + 1]) f = 1;
}
if (f == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int DBG = 0, INF = int(1e9);
string toString(long long k) {
stringstream ss;
ss << k;
string res;
ss >> res;
return res;
}
int toInt(string s) {
stringstream ss;
ss << s;
int res;
ss >> res;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cout.setf(ios::fixed);
int n;
cin >> n;
vector<int> s(n);
for (int _n = (n), i = 0; i < _n; ++i) cin >> s[i];
vector<int> V;
V.push_back(s[0]);
int res = 0;
for (int _b = (n - 1), i = (1); i <= _b; ++i) {
int a = s[i];
while (!V.empty() && V.back() < a) {
res = max(res, V.back() ^ a);
V.pop_back();
}
if (!V.empty()) res = max(res, V.back() ^ a);
V.push_back(a);
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long arr[100005], hash[100005] = {0}, mark[100005] = {0}, k = 1;
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
hash[arr[i]]++;
}
for (long long i = 0; i < n; i++) {
while (hash[k]) k++;
if (arr[i] <= n && mark[arr[i]] == 0) {
cout << arr[i] << " ";
mark[arr[i]] = 1;
} else {
cout << k << " ";
mark[k] = 1;
hash[k] = 1;
hash[arr[i]]--;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 25;
const int max_v = 4 * max_n * max_n;
const long long inf = 1111111111111LL;
struct edge {
int v, c, f, numr;
edge() {}
edge(int v, int c, int f, int numr) : v(v), c(c), f(f), numr(numr) {}
};
int last_res, n, m, k, k1, k2, x[2][max_v], y[2][max_v], t[2][max_v],
used[max_v];
long long last, dist[max_v][max_n][max_n];
string s[max_n];
vector<edge> g[max_v];
vector<long long> v;
void add_edge(int u, int v, int c) {
int rg1 = g[v].size();
int rg2 = g[u].size();
g[u].push_back(edge(v, c, 0, rg1));
g[v].push_back(edge(u, 0, 0, rg2));
}
bool dfs(int v, int t, int fl) {
if (v == t) {
return true;
}
if (used[v] == 1) {
return false;
}
used[v] = 1;
for (int i = 0; i < g[v].size(); ++i) {
if (g[v][i].c >= g[v][i].f + fl && dfs(g[v][i].v, t, fl)) {
g[v][i].f += fl;
g[g[v][i].v][g[v][i].numr].f -= fl;
return true;
}
}
return false;
}
bool check(long long x) {
int s = 2 * n * m + 2 * k;
int t = s + 1;
if (x <= last) {
for (int i = 0; i < max_v; ++i) {
g[i].clear();
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int num = 2 * (i * m + j);
add_edge(num, num + 1, 1);
}
}
for (int i = 0; i < k; ++i) {
add_edge(s, 2 * n * m + i, 1);
add_edge(2 * n * m + k + i, t, 1);
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w);
if (dist[i][j][w] > -1 && x >= dist[i][j][w]) {
add_edge(2 * n * m + i, num, 1);
}
}
}
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w) + 1;
if (dist[i + k][j][w] > -1 && x >= dist[i + k][j][w]) {
add_edge(num, 2 * n * m + k + i, 1);
}
}
}
}
} else {
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w);
if (dist[i][j][w] > -1 && x >= dist[i][j][w] &&
last < dist[i][j][w]) {
add_edge(2 * n * m + i, num, 1);
}
}
}
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w) + 1;
if (dist[i + k][j][w] > -1 && x >= dist[i + k][j][w] &&
last < dist[i + k][j][w]) {
add_edge(num, 2 * n * m + k + i, 1);
}
}
}
}
}
memset(used, 0, sizeof(used));
int res = 0;
if (x > last) {
res = last_res;
}
while (dfs(s, t, 1)) {
memset(used, 0, sizeof(used));
++res;
}
last = x;
last_res = res;
return res == k;
}
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
bool is_in(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
void bfs(int num, int poz) {
int stx = x[num][poz - num * k];
int sty = y[num][poz - num * k];
int tt = t[num][poz - num * k];
dist[poz][stx][sty] = 0;
queue<pair<int, int> > q;
q.push(make_pair(stx, sty));
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int x = p.first, y = p.second;
v.push_back(dist[poz][x][y]);
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (is_in(nx, ny) && s[nx][ny] == '.' && dist[poz][nx][ny] == -1) {
dist[poz][nx][ny] = dist[poz][x][y] + tt;
q.push(make_pair(nx, ny));
}
}
}
}
int main() {
cin >> n >> m >> k1 >> k2;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
int st1 = 0, st2 = 0;
if (k1 + 1 == k2) {
k = k2;
cin >> x[0][0] >> y[0][0] >> t[0][0];
st1 = 1;
} else if (k2 + 1 == k1) {
k = k1;
cin >> x[1][0] >> y[1][0] >> t[1][0];
st2 = 1;
} else {
cout << -1 << endl;
return 0;
}
for (int i = st1; i < k; ++i) {
cin >> x[0][i] >> y[0][i] >> t[0][i];
}
for (int i = st2; i < k; ++i) {
cin >> x[1][i] >> y[1][i] >> t[1][i];
}
memset(dist, -1, sizeof(dist));
for (int i = 0; i < k; ++i) {
--x[0][i];
--x[1][i];
--y[0][i];
--y[1][i];
bfs(0, i);
bfs(1, k + i);
}
sort(v.begin(), v.end());
last = inf + 1;
if (!check(inf)) {
cout << -1 << endl;
return 0;
}
long long l = -1, r = v.size() - 1;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (check(v[mid])) {
r = mid;
} else {
l = mid;
}
}
cout << v[r] << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void ratoneo() {
int n;
cin >> n;
vector<vector<int> > a(n, vector<int>(n));
int m = n * n;
int cnt = 0;
for (int mask = 0; mask < (1 << m); mask++) {
for (int bit = 0; bit < m; bit++) {
int r = bit / n;
int c = bit % n;
a[r][c] = (mask >> bit) & 1;
}
bool reflexive = true;
for (int x = 0; x < n; x++) {
if (a[x][x] == 0) reflexive = false;
}
if (reflexive) continue;
bool symmetric = true;
for (int x = 0; x < n; x++) {
for (int y = x + 1; y < n; y++) {
if (a[x][y] == 1 and a[y][x] == 0) symmetric = false;
if (a[x][y] == 0 and a[y][x] == 1) symmetric = false;
}
}
if (not symmetric) continue;
bool transitive = true;
for (int x = 0; x < n; x++) {
for (int y = 0; y < n; y++) {
for (int z = 0; z < n; z++) {
if (a[x][y] == 1 and a[y][z] == 1 and a[x][z] == 0) {
transitive = false;
}
}
}
}
if (not transitive) continue;
cnt += 1;
}
cout << cnt << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
const int mod = 1e9 + 7;
const int N = 4e3 + 10;
vector<vector<int> > dp(N, vector<int>(N, -1));
function<int(int, int)> stirling2 = [&](int n, int k) {
if (n == 0 and k == 0) return 1;
if (n == 0 or k == 0) return 0;
if (dp[n][k] != -1) return dp[n][k];
int add1 = (1LL * k * stirling2(n - 1, k)) % mod;
int add2 = stirling2(n - 1, k - 1);
int ret = add1 + add2;
if (ret >= mod) ret -= mod;
return dp[n][k] = ret;
};
long long ans = 0;
int n;
cin >> n;
for (int k = 1; k <= n; k++) {
int add = (1LL * k * stirling2(n, k)) % mod;
ans += add;
if (ans >= mod) ans -= mod;
}
cout << ans << '\n';
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int heights[100];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> heights[i];
}
while (true) {
bool insideFinish = false;
int start = -1, finish = -1;
int offset;
for (offset = 0; offset < n - 1; ++offset) {
if (heights[offset] > heights[offset + 1]) {
start = offset;
finish = offset + 1;
while (heights[finish - 1] > heights[finish] && finish < n) {
finish += 2;
}
break;
}
}
if (finish == -1) {
return 0;
}
finish -= 2;
for (int i = start; i < finish; i += 2) {
int aux = heights[i];
heights[i] = heights[i + 1];
heights[i + 1] = aux;
}
cout << start + 1 << " " << finish + 1 << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long n) {
long long res = 0;
while (n > 0) {
res += n % 2;
n /= 2;
}
return res;
}
signed main() {
long long n, p, ans = 1e9;
cin >> n >> p;
for (long long i = 0; i < 200000; i++) {
if (n <= 0) break;
if (f(n) <= i && n >= i) {
ans = min(ans, i);
}
n -= p;
}
if (ans != 1e9)
cout << ans;
else
cout << -1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, a2, a3, b1, b2, b3;
while (cin >> a1 >> b1 >> a2 >> b2 >> a3 >> b3) {
int ans = 0;
int x[] = {a2 + a3, a2 + b3, b2 + b3, b2 + a3};
int y[] = {max(b2, b3), max(b2, a3), max(a2, a3), max(a2, b3)};
for (int i = 0; i < 4; i++)
if (x[i] <= a1 && y[i] <= b1 || y[i] <= a1 && x[i] <= b1) ans = 1;
if (ans)
cout << "YES\n\n";
else
cout << "NO\n\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, b, y, n;
cin >> x >> b >> y;
if (x > 0 && y > 0) {
if (b < 0) {
cout << "NO\n";
return 0;
} else
n = (b - x) / y;
} else if (x < 0 && y < 0) {
if (b > 0) {
cout << "NO\n";
return 0;
} else
n = (b - x) / y;
} else if (y == 0) {
if (x == b) {
cout << "YES\n";
return 0;
} else {
cout << "NO\n";
return 0;
}
} else
n = (b - x) / y;
int s = n;
if (n == s && n >= 0)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, cnt[4];
char str[int(3e5 + 10)];
int main() {
scanf("%d", &N);
scanf("%s", str);
for (int i = 0; i < N; i++) {
cnt[str[i] - '0']++;
}
for (int i = 0; i < N && cnt[0] < N / 3; i++) {
if (str[i] != '0' && cnt[str[i] - '0'] > N / 3) {
cnt[str[i] - '0']--;
str[i] = '0';
cnt[0]++;
}
}
for (int i = N - 1; i >= 0 && cnt[2] < N / 3; i--) {
if (str[i] != '2' && cnt[str[i] - '0'] > N / 3) {
cnt[2]++;
cnt[str[i] - '0']--;
str[i] = '2';
}
}
int j = 0;
while (cnt[1] < N / 3 && cnt[2] > N / 3) {
if (str[j] == '2') {
str[j] = '1';
cnt[1]++;
cnt[2]--;
}
j++;
}
j = N - 1;
while (cnt[1] < N / 3 && cnt[0] > N / 3) {
if (str[j] == '0') {
str[j] = '1';
cnt[1]++;
cnt[0]--;
}
j--;
}
printf("%s\n", str);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
long long numCandy1 = 0, numCandy2 = 0;
numCandy1 += 2 * n + 3;
numCandy2 += 2 * n + 3;
double temp = double(8 * n + 8 * k + 9);
temp = sqrt(temp);
numCandy1 += temp;
numCandy2 -= temp;
numCandy1 /= 2;
numCandy2 /= 2;
if (numCandy2 < 0) {
cout << numCandy1;
} else {
cout << numCandy2;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, p, temp = 10000000, index;
scanf("%d", &n);
bool yes = false;
int meat[n], price[n];
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d %d", &meat[i], &price[i]);
if (i > 0 && price[i] > price[i - 1]) {
price[i] = price[i - 1];
sum = sum + price[i] * meat[i];
} else
sum = sum + price[i] * meat[i];
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, m, i, j, r, c, num = 0, k, b, e, d = 0;
char a[120][120];
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", &a[i]);
}
for (i = 0; i <= n; i++) {
for (j = 0; j <= m; j++) {
if (a[i][j] == 'B') {
if (d == 0) {
d = 1;
b = i + 1;
e = j + 1;
num++;
} else
num++;
}
}
if (d != 0) break;
}
r = num / 2 + b;
c = num / 2 + e;
printf("%d %d", r, c);
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef int ll;
ll n,m;
ll ff(ll x)
{
ll cnt=0;
for(ll i=1;i<=x;i++) if(x%i==0) cnt++;
return cnt;
}
ll check(ll x,ll opt)
{
vector<ll> gg;
ll xx=x;
for(ll i=2;i<=x;i++)
{
while(xx%i==0)
{
gg.push_back(i);
xx/=i;
}
}
xx=x;
for(ll i=0;i<gg.size();i++)
{
ll qq=xx/gg[i];
ll ok=1,oo;
if(gg[i]==2)
{
if(opt) printf("? %d %d %d %d %d %d\n",n,qq,1,1,1,qq+1);
else printf("? %d %d %d %d %d %d\n",qq,m,1,1,qq+1,1);
fflush(stdout);
scanf("%d",&oo);
ok&=oo;
}
else if(gg[i]==3)
{
if(opt) printf("? %d %d %d %d %d %d\n",n,qq,1,1,1,qq+1);
else printf("? %d %d %d %d %d %d\n",qq,m,1,1,qq+1,1);
fflush(stdout);
scanf("%d",&oo);
ok&=oo;
if(opt) printf("? %d %d %d %d %d %d\n",n,qq,1,qq*2+1,1,qq+1);
else printf("? %d %d %d %d %d %d\n",qq,m,qq*2+1,1,qq+1,1);
fflush(stdout);
scanf("%d",&oo);
ok&=oo;
}
else
{
if(opt) printf("? %d %d %d %d %d %d\n",n,gg[i]/2*qq,1,1,1,gg[i]/2*qq+1);
else printf("? %d %d %d %d %d %d\n",gg[i]/2*qq,m,1,1,gg[i]/2*qq+1,1);
fflush(stdout);
scanf("%d",&oo);
ok&=oo;
if(opt) printf("? %d %d %d %d %d %d\n",n,gg[i]/2*qq,1,1,1,(gg[i]/2+1)*qq+1);
else printf("? %d %d %d %d %d %d\n",gg[i]/2*qq,m,1,1,(gg[i]/2+1)*qq+1,1);
fflush(stdout);
scanf("%d",&oo);
ok&=oo;
if(opt) printf("? %d %d %d %d %d %d\n",n,gg[i]/2*qq,1,qq+1,1,(gg[i]/2+1)*qq+1);
else printf("? %d %d %d %d %d %d\n",gg[i]/2*qq,m,qq+1,1,(gg[i]/2+1)*qq+1,1);
fflush(stdout);
scanf("%d",&oo);
ok&=oo;
}
if(ok) xx/=gg[i];
}
return ff(x/xx);
}
int main(void)
{
scanf("%d%d",&n,&m);
printf("! %d",check(n,0)*check(m,1));
fflush(stdout);
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int h[N], lb[N], ls[N], rb[N], rs[N];
vector<int> jumps[N];
int dp[N];
const int INF = 1e9;
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i] = INF;
}
dp[0] = 0;
stack<pair<int, int> > st;
for (int i = 0; i < n; i++) {
while (!st.empty() && st.top().first < h[i]) st.pop();
if (st.empty())
lb[i] = -1;
else
lb[i] = st.top().second;
st.push({h[i], i});
}
st = stack<pair<int, int> >();
for (int i = n - 1; i >= 0; i--) {
while (!st.empty() && st.top().first < h[i]) st.pop();
if (st.empty())
rb[i] = -1;
else
rb[i] = st.top().second;
st.push({h[i], i});
}
st = stack<pair<int, int> >();
for (int i = 0; i < n; i++) {
while (!st.empty() && st.top().first > h[i]) st.pop();
if (st.empty())
ls[i] = -1;
else
ls[i] = st.top().second;
st.push({h[i], i});
}
st = stack<pair<int, int> >();
for (int i = n - 1; i >= 0; i--) {
while (!st.empty() && st.top().first > h[i]) st.pop();
if (st.empty())
rs[i] = -1;
else
rs[i] = st.top().second;
st.push({h[i], i});
}
for (int i = 0; i < n; i++) {
if (rb[i] != -1) jumps[i].push_back(rb[i]);
if (rs[i] != -1) jumps[i].push_back(rs[i]);
if (lb[i] != -1) jumps[lb[i]].push_back(i);
if (ls[i] != -1) jumps[ls[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
for (int to : jumps[i]) {
dp[to] = min(dp[to], dp[i] + 1);
}
}
cout << dp[n - 1] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[100001], x[100001], y[100001], dp[1001][1001];
int main() {
int n, d, i, j, k;
cin >> n >> d;
for (i = 2; i <= n - 1; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
cin >> x[i];
cin >> y[i];
}
a[n] = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == j)
dp[i][j] = 0;
else {
dp[i][j] = d * (abs(x[i] - x[j]) + abs(y[i] - y[j])) - a[i];
}
}
}
for (k = 1; k <= n; k++) {
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
}
}
cout << dp[1][n];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int M = 1e6 + 7;
int y, k, n, t;
int main() {
cin >> y >> k >> n;
int c = 1;
for (int i = 1;; ++i) {
if (k * i > y) {
c = k * i - y;
break;
}
}
for (int i = c;; i += k) {
if (i + y > n) {
break;
}
if ((i + y) % k == 0) {
cout << i << ' ';
t = 1;
}
}
if (!t) {
cout << -1;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, n;
scanf("%d%d", &d, &n);
vector<int> days(n, 0);
int ans = 0;
for (int i = 0; i < n; i++) scanf("%d", &days[i]);
for (int i = 0; i < n - 1; i++) {
if (d - days[i] != 0) ans += d - days[i];
};
printf("%d", ans);
cin.get();
cin.get();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n;
int main() {
long long area = 0, minx = INF, miny = INF, maxx = -INF, maxy = -INF;
cin >> n;
for (int i = 0; i < n; ++i) {
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
area += (x2 - x1) * (y2 - y1);
minx = min(minx, x1);
miny = min(miny, y1);
maxx = max(maxx, x2);
maxy = max(maxy, y2);
}
puts(maxx - minx == maxy - miny && area == (maxx - minx) * (maxy - miny)
? "YES"
: "NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
queue<int> que[30];
char a[400005];
int mark[400005];
int main() {
int n, k;
scanf("%d%d%s", &n, &k, a + 1);
for (int i = 1; i <= n; i++) que[a[i] - 'a'].push(i);
for (int i = 0; i < 30; i++) {
while (!que[i].empty() && k) {
mark[que[i].front()] = 1;
que[i].pop();
k--;
}
}
for (int i = 1; i <= n; i++)
if (!mark[i]) printf("%c", a[i]);
printf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int qmin(int a, int b) { return (a < b) ? a : b; }
int qmax(int a, int b) { return (a > b) ? a : b; }
int n, m, k;
int x[555], y[555];
int xl[555], xr[555], yl[555], yr[555];
set<int> stx, sty;
map<int, int> mpx;
int xpos[1010];
vector<int> l[1010], r[1010];
multiset<pair<int, int> > y_seg_l;
bool check(int now) {
for (int i = 0; i < 1001; i++) l[i].clear(), r[i].clear();
for (int i = 0; i < k; i++)
xl[i] = qmax(x[i] - now, 1), xr[i] = qmin(x[i] + now, n),
yl[i] = qmax(y[i] - now, 1), yr[i] = qmin(y[i] + now, m);
stx.clear(), sty.clear();
for (int i = 0; i < k; i++) stx.insert(xl[i]), stx.insert(xr[i] + 1);
stx.insert(1), stx.insert(n + 1);
int cnt = 0;
for (set<int>::iterator it = stx.begin(); it != stx.end(); it++, cnt++)
mpx[*it] = cnt, xpos[cnt] = *it;
for (int i = 0; i < k; i++)
l[mpx[xl[i]]].push_back(i), r[mpx[xr[i] + 1]].push_back(i);
y_seg_l.clear();
int xxl = n + 1, xxr = 0, yyl = m + 1, yyr = 0;
y_seg_l.insert(make_pair(0, 0));
y_seg_l.insert(make_pair(m + 1, m + 1));
for (int i = 0; i < cnt - 1; i++) {
for (int j = 0; j < (int)r[i].size(); j++) {
multiset<pair<int, int> >::iterator it =
y_seg_l.lower_bound(make_pair(yl[r[i][j]], yr[r[i][j]]));
y_seg_l.erase(it);
}
for (int j = 0; j < (int)l[i].size(); j++)
y_seg_l.insert(make_pair(yl[l[i][j]], yr[l[i][j]]));
int nr = 0;
int nyl = m + 1, nyr = 0;
for (set<pair<int, int> >::iterator it = y_seg_l.begin();
it != y_seg_l.end(); it++) {
if (it->first > nr + 1)
nyl = qmin(nyl, nr + 1), nyr = qmax(nyr, it->first - 1);
nr = qmax(nr, it->second);
}
if (nyr > 0) {
xxl = qmin(xxl, xpos[i]);
xxr = qmax(xxr, xpos[i + 1] - 1);
}
yyl = qmin(yyl, nyl);
yyr = qmax(yyr, nyr);
}
if (xxr == 0) return 1;
return ((xxr - xxl + 1) <= (now + now + 1)) &&
((yyr - yyl + 1) <= (now + now + 1));
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) cin >> x[i] >> y[i];
int lb = 0, ub = 1e9;
while (lb <= ub) {
int mid = (lb + ub) >> 1;
if (check(mid))
ub = mid - 1;
else
lb = mid + 1;
}
cout << lb << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
long long modulo(long long a, long long b) { return a < b ? a : a % b; }
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const double eps = 1e-6;
typedef struct {
double x, y;
} point, geovector;
typedef struct {
double a, b, c;
} line;
typedef struct {
double r;
point c;
} circle;
bool issame(double x, double y) { return fabs(x - y) < eps - eps / 100.0; }
double dist(point p, point q) {
return sqrt(((p.x - q.x) * (p.x - q.x)) + ((p.y - q.y) * (p.y - q.y)));
}
long long power(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
long long ret = power(a, b >> 1);
(ret *= ret) %= (long long)(1e4 + 7 + eps);
if (b & 1) (ret *= a) %= (long long)(1e4 + 7 + eps);
return ret;
}
long long im(long long a, long long n) {
long long i = n, v = 0, d = 1;
long long x;
while (a > 0) {
long long t = i / a;
x = a;
a = i % x;
i = x;
x = d;
d = v - t % x;
v = x;
}
v %= n;
if (v < 0) v = (v + n) % n;
return v;
}
struct node {
int a;
int b;
int c;
int d;
int h;
};
int main() {
vector<node> a(1000);
node b;
b.a = 0;
b.b = 0;
b.c = 1;
b.d = 0;
b.h = 1;
a[0] = b;
int dir = 0;
for (int i = 1; i < 1000; i++) {
dir = dir % 4;
a[i].a = a[i - 1].c;
a[i].b = a[i - 1].d;
a[i].c = a[i - 1].c;
a[i].d = a[i - 1].d;
if (dir == 0) {
a[i].d = a[i - 1].b + a[i - 1].h;
a[i].h = a[i - 1].h + 1;
} else if (dir == 1) {
a[i].c = a[i].a - a[i - 1].h;
a[i].h = a[i - 1].h;
} else if (dir == 2) {
a[i].d = a[i].b - a[i - 1].h;
a[i].h = a[i - 1].h;
} else if (dir == 3) {
a[i].c = a[i].a + a[i - 1].h + 1;
a[i].h = a[i - 1].h + 1;
}
dir++;
}
int n, m;
cin >> n >> m;
for (int i = 0, _n = (int)(a).size(); i < _n; i++) {
node p = a[i];
if ((p.a == n && p.b == m) || (p.c == n && p.d == m)) {
cout << i << endl;
return 0;
} else if (min(p.a, p.c) <= n && n <= max(p.a, p.c) && min(p.b, p.d) <= m &&
m <= max(p.b, p.d)) {
cout << i << endl;
return 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using db = double;
const db eps = 1e-9;
int sgn(db a, db b = 0) {
a -= b;
return (a > eps) - (a < -eps);
}
struct poi {
db x, y;
void r() { cin >> x >> y; }
poi operator-(poi p) { return {x - p.x, y - p.y}; }
poi operator+(poi p) { return {x + p.x, y + p.y}; }
poi operator*(db d) { return {x * d, y * d}; }
db dot(poi p) { return x * p.x + y * p.y; }
db cross(poi p) { return x * p.y - y * p.x; }
poi proj(poi a, poi b) {
db s = (*this - a).dot(b - a) / (b - a).dot(b - a);
return a + (b - a) * s;
}
};
db xmul(poi a, poi b, poi c) { return (b - a).cross(c - a); }
bool inter1(poi a, poi b, poi p, poi q) {
if (sgn(xmul(a, b, p)) * sgn(xmul(a, b, q)) >= 0) return false;
db t = (p - a).cross(q - p) / (b - a).cross(q - p);
return sgn(t) > 0 && sgn(t, 1) < 0;
}
bool inter2(poi a, poi b, poi p, poi q) {
if (sgn(xmul(a, b, p)) * sgn(xmul(a, b, q)) > 0) return false;
if (sgn((b - a).cross(q - p)) == 0) {
db s = (p - a).dot(b - a) / (b - a).dot(b - a);
db t = (q - a).dot(b - a) / (b - a).dot(b - a);
if (s > t) swap(s, t);
if (sgn(s, 1) > 0 || sgn(t) < 0) return false;
return true;
}
db t = (p - a).cross(q - p) / (b - a).cross(q - p);
return sgn(t) > 0 && sgn(t, 1) < 0;
}
int main() {
ios ::sync_with_stdio(false);
poi p1, p2, w1, w2, m1, m2;
p1.r();
p2.r();
w1.r();
w2.r();
m1.r();
m2.r();
if ((!inter2(p1, p2, m1, m2) || sgn((m2 - m1).cross(p2 - p1)) == 0) &&
!inter2(p1, p2, w1, w2))
cout << "YES\n";
else if (sgn(xmul(m1, m2, p1)) * sgn(xmul(m1, m2, p2)) > 0) {
poi proj = p1.proj(m1, m2);
poi sym = proj + proj - p1;
db t = (sym - m1).cross(p2 - sym) / (m2 - m1).cross(p2 - sym);
poi ref = m1 + (m2 - m1) * t;
if (sgn(t) >= 0 && sgn(t, 1) <= 0 && !inter2(p1, ref, w1, w2) &&
!inter2(ref, p2, w1, w2))
cout << "YES\n";
else
cout << "NO\n";
} else
cout << "NO\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
template <typename... T>
void input(T&... t) {
((cin >> t), ...);
}
template <typename T>
void printV(T vec) {
for (long long i = 0; i < (long long)vec.size(); i++)
cout << vec[i] << " " << flush;
}
bool isPrime(long long n) {
if (n == 2 or n == 3 or n == 5 or n == 7) return true;
if (n % 2 == 0 or n % 3 == 0 or n % 5 == 0 or n % 7 == 0) return false;
int count = 0;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) count++;
}
if (count == 0)
return true;
else
return false;
}
long long g(long long a, long long b) {
if (b == 0) return a;
return g(b, a % b);
}
long long gcd(vector<long long> vec) {
long long t = vec[0];
for (long long i = 1; i < (long long)vec.size(); i++) {
t = g(t, vec[i]);
}
return t;
}
int main() {
cout << setprecision(16);
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
if (isPrime(n))
cout << n << endl;
else {
vector<long long> fact;
for (long long i = 2; i <= sqrt(n); i++) {
if (i * i == n)
fact.push_back(i);
else if (n % i == 0) {
fact.push_back(i);
fact.push_back(n / i);
}
}
fact.push_back(n);
sort(fact.begin(), fact.end());
long long g = gcd(fact);
if (g == 1)
cout << 1 << endl;
else
cout << fact[0] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m[10000005];
int main() {
int a;
cin >> a;
for (int i = 1; i <= a; i++) {
int x;
cin >> x;
int y;
cin >> y;
x *= 100000;
x += y;
m[x]++;
}
int mx = INT_MIN;
for (int i = 0; i <= 100; i++) {
mx = max(mx, m[i]);
}
for (int i = 100000; i <= 10000000; i++) {
mx = max(mx, m[i]);
}
cout << mx;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> m;
int n, p, a[300003], b[300003];
long long res = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p;
for (int i = 1; i <= n; ++i) {
int u, v;
cin >> u >> v;
a[u]++;
a[v]++;
b[u]++;
b[v]++;
if (u > v) swap(u, v);
m[{u, v}]++;
}
sort(b + 1, b + n + 1);
for (int i = n; i >= 1; --i) {
int pos = lower_bound(b + 1, b + i + 1, p - b[i]) - b;
if (pos < i) res += i - pos;
}
map<pair<int, int>, int>::iterator it;
for (it = m.begin(); it != m.end(); ++it) {
int u = it->first.second;
int v = it->first.first;
int t = it->second;
if (a[u] + a[v] >= p && a[u] + a[v] - t < p) res--;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, x, a, z, b, d, r = LLONG_MAX, m = 0;
cin >> n >> x;
vector<pair<long long, long long> > arr(n);
for (long long i = 0; i < n; i++) {
cin >> a >> b;
arr[i] = {a, b};
m = max(a, m);
}
if (x <= m)
r = 1;
else {
for (long long i = 0; i < n; i++) {
a = arr[i].first;
b = arr[i].second;
d = a - b;
if (d <= 0) continue;
z = max(0ll, x - m) / d + bool(abs(x - m) % d) + 1;
r = min(r, z);
}
}
if (r == LLONG_MAX) r = -1;
cout << r << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int MaxN = 100005, NA = -1, MaxC = 0x3F3F3F3F;
int a[MaxN];
int n;
multiset<int, greater<int> > s;
deque<int> d;
int main(void) {
int i, v;
multiset<int>::iterator it;
while (scanf(" %d", &n) != EOF) {
for (i = 0; i < n; i++) scanf(" %d", &a[i]);
s.clear();
for (i = 0; i < n; i++) s.insert(a[i]);
d.clear();
it = s.begin();
d.push_back(*it);
s.erase(it);
for (i = 1; i < n; i++)
if (d.front() > d.back()) {
v = d.front();
it = s.find(v + 1);
if (it != s.end()) {
d.push_front(*it);
s.erase(it);
} else {
it = s.find(v - 1);
if (it != s.end()) {
d.push_front(*it);
s.erase(it);
} else
break;
}
} else {
v = d.back();
it = s.find(v + 1);
if (it != s.end()) {
d.push_back(*it);
s.erase(it);
} else {
it = s.find(v - 1);
if (it != s.end()) {
d.push_back(*it);
s.erase(it);
} else
break;
}
}
if ((int)d.size() == n && abs(d.front() - d.back()) == 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dp[200005][3];
vector<int> adj[200005];
void dfs(int x, int p) {
int min2 = 1e6;
for (int y : adj[x]) {
if (y == p) continue;
dfs(y, x);
dp[x][0] += dp[y][1];
dp[x][2] += min(dp[y][0], dp[y][2]);
min2 = min(min2, dp[y][0] - min(dp[y][0], dp[y][2]));
}
dp[x][0] += 1;
dp[x][1] = min(dp[x][2], dp[x][0]);
dp[x][2] += min2;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int sol = 0;
for (int x : adj[1]) {
dfs(x, 1);
sol += dp[x][0] - 1;
}
cout << sol;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.