solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795;
const long double eps = 1e-9;
long long int a[100001];
long long int store[50] = {0};
int main() {
int n, i;
long long int ans = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
int m = 0;
for (i = 0; i < n; i++) {
ans = 0;
while (a[i]) {
ans += (a[i] % 2);
a[i] = a[i] / 2;
}
store[ans]++;
if (ans > m) m = ans;
}
ans = 0;
for (i = 1; i <= m; i++) ans += store[i] * (store[i] - 1) / 2;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long infl = 1LL << 60;
char buf[1000000];
string nextLine() {
scanf("%[^\n]", buf);
scanf("%*c");
return string(buf);
}
string next() {
scanf("%s", buf);
return string(buf);
}
int nextInt() {
int tmp;
scanf("%d", &tmp);
return tmp;
}
const int MAXM = 100100, MAXN = 100100;
pair<int, int> edges[MAXM];
vector<int> con[MAXN];
int mindist[MAXN];
bool vis[MAXN];
set<pair<int, int> > s;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
int main() {
int N = nextInt(), M = nextInt();
int x = 0;
for (int i = 0, _i = (M); i < _i; ++i) {
int a = nextInt() - 1;
int b = nextInt() - 1;
int c = nextInt();
pair<int, int> e1 = pair<int, int>(a, c);
pair<int, int> e2 = pair<int, int>(b, c);
edges[x] = e1;
edges[x + 1] = e2;
con[a].push_back(x + 1);
con[b].push_back(x);
x += 2;
}
for (int i = 0, _i = (N); i < _i; ++i) {
int k = nextInt();
for (int j = 0, _j = (k); j < _j; ++j) {
int a = nextInt();
pair<int, int> p = pair<int, int>(a, i);
s.insert(p);
}
}
for (int i = 0, _i = (N); i < _i; ++i) {
mindist[i] = inf;
}
pq.push(pair<int, int>(0, 0));
while (((int)(pq).size())) {
pair<int, int> p = pq.top();
pq.pop();
int &loc = p.second;
int &dist = p.first;
if (vis[loc]) continue;
vis[loc] = true;
if (loc == N - 1) break;
while (s.find(p) != s.end()) {
dist++;
}
for (__typeof((con[loc]).begin()) eP = (con[loc]).begin(),
_eP = (con[loc]).end();
eP != _eP; ++eP) {
pair<int, int> &p = edges[*eP];
int to = p.first;
int d = dist + p.second;
if (d < mindist[to]) {
mindist[to] = d;
pair<int, int> p = pair<int, int>(d, to);
pq.push(p);
}
}
}
int ans = mindist[N - 1];
if (ans == inf) ans = -1;
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
long long a, b, c, n;
cin >> a >> b >> c >> n;
long long sum = a + b + c + n;
if (sum % 3 == 0) {
sum = sum / 3;
if (a <= sum && b <= sum && c <= sum) {
cout << "YES\n";
} else {
cout << "NO\n";
}
} else {
cout << "NO\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[200005], scnt;
long long s[200005], ans = ~(1LL << 63);
map<int, int> mp;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
mp[a[i]]++;
s[i] = s[i - 1] + a[i];
}
for (auto i : mp) {
int x = i.first, cnt = i.second;
if (cnt >= k) return puts("0"), 0;
int l = k - cnt;
long long f1 = 1LL * (x - 1) * scnt - s[scnt];
long long f2 = (s[n] - s[scnt + cnt]) - 1LL * (x + 1) * (n - scnt - cnt);
if (scnt >= l) ans = min(ans, f1 + l);
if (n - scnt - cnt >= l) ans = min(ans, f2 + l);
ans = min(ans, l + f1 + f2);
scnt += cnt;
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void idea() {
int n = 5;
vector<int> aa;
for (int i = 1; i <= n; i++) {
aa.push_back(i);
}
do {
printf("(%d", aa[0]);
for (int i = 1; i < n; i++) {
printf(", %d", aa[i]);
}
printf(") ");
int ans = 0;
for (int i = 0; i < n; i++) {
int minv = n + 100;
for (int j = i; j < n; j++) {
minv = min(minv, aa[j]);
ans += minv;
}
}
printf("%d\n", ans);
} while (next_permutation(aa.begin(), aa.end()));
}
long long f[60];
vector<int> solve(int n, long long m) {
if (n == 0) {
return vector<int>();
}
vector<int> ans;
int i;
for (i = 1; i < n; i++) {
if (m > f[n - i - 1]) {
m -= f[n - i - 1];
} else {
break;
}
}
vector<int> sub = solve(n - i, m);
ans.push_back(i);
for (int j = 0; j < sub.size(); j++) {
ans.push_back(sub[j] + i);
}
for (int j = i - 1; j >= 1; j--) {
ans.push_back(j);
}
return ans;
}
int main() {
int n;
long long m;
f[0] = 1;
for (int i = 1; i < 60; i++) {
f[i] = f[i - 1] * 2;
}
cin >> n >> m;
vector<int> ans = solve(n, m);
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int W_LEN = sizeof(unsigned int) * 8;
const int SHIFT_LEN = (W_LEN == 32 ? 5 : 6);
const int MAX_N = 50000 + 10;
void AlgB(int m, int n, const char* a, const char* b, int* ll) {
static unsigned int bit[128][(MAX_N >> SHIFT_LEN) + 2];
static unsigned int dp[(MAX_N >> SHIFT_LEN) + 2];
int N = m;
int M = n;
int nbits = (N + W_LEN - 1) >> SHIFT_LEN;
for (int i = 0; i < N; i++)
bit[a[i]][i >> SHIFT_LEN] |= static_cast<unsigned int>(1)
<< (i & (W_LEN - 1));
memset(dp, 0, nbits * sizeof(unsigned int));
unsigned int top_bit, carry, t, x, y, *bit_s;
for (int i = 0; i < M; i++) {
top_bit = 1;
bit_s = bit[b[i]];
for (int j = carry = 0; j < nbits; j++) {
x = dp[j] | bit_s[j];
t = dp[j] >> (W_LEN - 1);
y = (dp[j] << 1) | top_bit;
top_bit = t;
dp[j] = x & ((x - y - carry) ^ x);
carry = (x < y + carry) ? 1 : 0;
}
}
int sum = 0;
for (int i = 0; i < N; i++) {
if (dp[i >> SHIFT_LEN] & (1 << (i & (W_LEN - 1)))) ++sum;
ll[i] = sum;
bit[a[i]][i >> SHIFT_LEN] = 0;
}
}
int Lcs(int m, int n, const char* a, const char* b, char* c) {
if (n <= 0 || m <= 0) {
return 0;
} else if (m == 1) {
for (int i = 0; i < n; ++i) {
if (a[0] == b[i]) {
c[0] = a[0];
return 1;
}
}
return 0;
}
static char ra[MAX_N], rb[MAX_N];
static int ll1[MAX_N], ll2[MAX_N];
int i = (m - 1) >> 1;
memcpy(ra, a, m);
memcpy(rb, b, n);
reverse(ra, ra + m);
reverse(rb, rb + n);
AlgB(n, i + 1, b, a, ll1);
AlgB(n, m - i - 1, rb, ra, ll2);
int l1 = 0, l2 = ll2[n - 1], k = -1;
for (int j = 0; j < n - 1; ++j) {
if (ll1[j] + ll2[n - j - 2] > l1 + l2) {
l1 = ll1[j];
l2 = ll2[n - j - 2];
k = j;
}
}
if (ll1[n - 1] > l1 + l2) {
l1 = ll1[n - 1];
l2 = 0;
k = n - 1;
}
if (l1 > 0) Lcs(i + 1, k + 1, a, b, c);
if (l2 > 0) Lcs(m - i - 1, n - k - 1, a + i + 1, b + k + 1, c + k + 1);
memmove(c + l1, c + k + 1, l2);
return l1 + l2;
}
char a[MAX_N], b[MAX_N], c[MAX_N];
void Print(const char* s, int n) {
if (n <= 100) {
for (int i = 0; i < n; ++i) {
printf("%c", s[i]);
}
} else {
if (n % 2 == 0) {
for (int i = (n - 100) / 2; i < (n - 100) / 2 + 100; ++i) {
printf("%c", s[i]);
}
} else {
for (int i = (n - 100) / 2; i < (n - 100) / 2 + 101; ++i) {
if (i == (n / 2)) {
continue;
}
printf("%c", s[i]);
}
}
}
printf("\n");
}
int main() {
scanf("%s", a);
int n = strlen(a);
strcpy(b, a);
reverse(b, b + n);
int clen = Lcs(n, n, a, b, c);
Print(c, clen);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, c;
char ans[111][111];
inline bool ok(int i, int j) { return (i >= 0 && j >= 0 && i < n && j < m); }
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
inline void putc(int i, int j) {
for (int let = 'a'; let <= 'z'; ++let) {
bool can = 1;
for (int(first) = 0; (first) < (2); ++(first))
for (int(second) = 0; (second) < (2); ++(second))
for (int(k) = 0; (k) < (4); ++(k))
if (ok(i + first + dx[k], j + second + dy[k]) &&
ans[i + first + dx[k]][j + second + dy[k]] == let)
can = 0;
if (can) {
for (int(first) = 0; (first) < (2); ++(first))
for (int(second) = 0; (second) < (2); ++(second))
ans[i + first][j + second] = let;
--c;
return;
}
}
}
inline void puta(int i, int j) {
for (int let = 'a'; let <= 'z'; ++let) {
bool can = 1;
for (int(second) = 0; (second) < (2); ++(second))
for (int(k) = 0; (k) < (4); ++(k))
if (ok(i + dx[k], j + second + dy[k]) &&
ans[i + dx[k]][j + second + dy[k]] == let)
can = 0;
if (can) {
for (int(second) = 0; (second) < (2); ++(second))
ans[i][j + second] = let;
--a;
return;
}
}
}
inline void putb(int i, int j) {
for (int let = 'a'; let <= 'z'; ++let) {
bool can = 1;
for (int(first) = 0; (first) < (2); ++(first))
for (int(k) = 0; (k) < (4); ++(k))
if (ok(i + first + dx[k], j + dy[k]) &&
ans[i + first + dx[k]][j + dy[k]] == let)
can = 0;
if (can) {
for (int(first) = 0; (first) < (2); ++(first))
for (int(second) = 0; (second) < (2); ++(second))
ans[i + first][j] = let;
--b;
return;
}
}
}
int main() {
cin >> n >> m >> a >> b >> c;
if ((n & 1 && m & 1) || (n & 1 && m / 2 > a) || (m & 1 && n / 2 > b)) {
cout << "IMPOSSIBLE\n";
return 0;
}
a = (n & 1) * (m / 2) + (((a - (n & 1) * (m / 2)) >> 1) << 1);
b = (m & 1) * (n / 2) + (((b - (m & 1) * (n / 2)) >> 1) << 1);
if (2 * a + 2 * b + 4 * c < n * m) {
cout << "IMPOSSIBLE\n";
return 0;
}
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j)) ans[i][j] = '0';
if (n & 1) {
for (int(j) = 0; (j) < (m); ++(j)) {
puta(0, j);
j++;
}
}
if (m & 1) {
for (int(i) = 0; (i) < (n); ++(i)) {
putb(i, 0);
i++;
}
}
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j))
if (ans[i][j] == '0') {
if (c)
putc(i, j);
else if (b)
putb(i, j);
else
puta(i, j);
}
for (int(i) = 0; (i) < (n); ++(i)) {
for (int(j) = 0; (j) < (m); ++(j)) cout << ans[i][j];
cout << endl;
}
}
| 6 |
#include <bits/stdc++.h>
int n, m, A[1000][1000];
int prel[1000][1000];
int dpl(int i, int j) {
if (j == 0) {
prel[i][j] = 0;
return 0;
}
if (prel[i][j] >= 0)
return A[i][j] ? 0 : prel[i][j];
else {
prel[i][j] = dpl(i, j - 1);
if (A[i][j - 1]) prel[i][j]++;
if (A[i][j])
return 0;
else
return prel[i][j];
}
}
int prer[1000][1000];
int dpr(int i, int j) {
if (j == m - 1) {
prer[i][j] = 0;
return 0;
}
if (prer[i][j] >= 0)
return A[i][j] ? 0 : prer[i][j];
else {
prer[i][j] = dpr(i, j + 1);
if (A[i][j + 1]) prer[i][j]++;
if (A[i][j])
return 0;
else
return prer[i][j];
}
}
int pret[1000][1000];
int dpt(int i, int j) {
if (i == 0) {
pret[i][j] = 0;
return 0;
}
if (pret[i][j] >= 0)
return A[i][j] ? 0 : pret[i][j];
else {
pret[i][j] = dpt(i - 1, j);
if (A[i - 1][j]) pret[i][j]++;
if (A[i][j])
return 0;
else
return pret[i][j];
}
}
int preb[1000][1000];
int dpb(int i, int j) {
if (i == n - 1) {
preb[i][j] = 0;
return 0;
}
if (preb[i][j] >= 0)
return A[i][j] ? 0 : preb[i][j];
else {
preb[i][j] = dpb(i + 1, j);
if (A[i + 1][j]) preb[i][j]++;
if (A[i][j])
return 0;
else
return preb[i][j];
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &A[i][j]);
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
preb[i][j] = prer[i][j] = pret[i][j] = prel[i][j] = -1;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum += dpl(i, j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum += dpr(i, j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum += dpb(i, j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum += dpt(i, j);
}
}
printf("%d\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 1e6;
const int MAX = 1e5 + 10;
struct event {
long long a, b, c;
};
bool cmp(event e1, event e2) {
if (e1.a != e2.a) return e1.a < e2.a;
if (e1.b != e2.b) return e1.b < e2.b;
return e1.c < e2.c;
}
template <class T>
struct SegTree {
const T ID = 0;
int n;
vector<T> seg;
T comb(T a, T b) { return a + b; }
SegTree(int _n) {
n = _n;
seg.assign(2 * n, ID);
}
void pull(int p) { seg[p] = comb(seg[2 * p], seg[2 * p + 1]); }
void update(int idx, T val) {
seg[idx += n] += val;
for (idx /= 2; idx; idx /= 2) pull(idx);
}
T query(int l, int r) {
T lnode = ID, rnode = ID;
for (l += n, r += n + 1; l < r; l /= 2, r /= 2) {
if (l & 1) lnode = comb(lnode, seg[l++]);
if (r & 1) rnode = comb(seg[--r], rnode);
}
return comb(lnode, rnode);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
SegTree<int> seg(LIM + 10);
vector<event> events;
long long ans = 1;
for (int i = 0; i < n; i++) {
int y, l, r;
cin >> y >> l >> r;
events.push_back({l, -1, y});
events.push_back({r, LIM + 1, y});
if (l == 0 && r == LIM) ans++;
}
for (int i = 0; i < m; i++) {
int x, l, r;
cin >> x >> l >> r;
events.push_back({x, l, r});
if (l == 0 && r == LIM) ans++;
}
sort(events.begin(), events.end(), cmp);
for (event e : events) {
if (e.b == -1)
seg.update(e.c, 1);
else if (e.b == LIM + 1)
seg.update(e.c, -1);
else
ans += seg.query(e.b, e.c);
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, i;
cin >> n;
long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
long int ans = 0;
for (i = 0; i < n - 1; i++) {
if (a[i] != 0) {
ans += a[i];
cout << ans << endl;
long int var = pow(2, floor(log2(n - i + -1)));
a[i + var] += a[i];
a[i] = 0;
} else {
cout << ans << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double n, r;
long long b[1010];
long long a[3010];
double ans[1010];
double cal(long long x, long long y) {
if (x == -1 || y == -1) {
return r;
}
double xx = (4.0 * r * r) - (abs(b[x] - b[y]) * abs(b[x] - b[y]));
return sqrt(xx) + ans[x];
}
double calc(long long x) {
double z = 0;
for (long long i = 0; i <= r; i++) {
z = max(z, max(cal(a[b[x] - i], x), cal(a[b[x] + i], x)));
}
return z;
}
void fil(long long x) {
for (long long i = 0; i <= r; i++) {
a[b[x] + i] = x;
a[b[x] - i] = x;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(7);
memset(a, -1, sizeof a);
cin >> n >> r;
for (long long i = 0; i < n; i++) {
cin >> b[i];
b[i] += 1000;
}
for (long long i = 0; i < n; i++) {
ans[i] = calc(i);
fil(i);
}
for (long long i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
fastio();
int t;
cin >> t;
while (t--) {
long long x, tpow = 1, ans = 0, w;
cin >> x;
while (1) {
tpow *= 2;
w = tpow - 1;
w = w * (w + 1) * 0.5;
if (x >= w)
ans++;
else
break;
x -= w;
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int k, m, n, x, y, ind;
char a[15][15][15];
int p[1100];
int size[1100];
int par(int u) {
if (p[u] == u) return u;
return p[u] = par(p[u]);
}
void add(int u, int v) {
u = par(u);
v = par(v);
if (u != v) {
p[u] = v;
size[v] += size[u];
}
}
int main() {
ios ::sync_with_stdio(false);
cin >> k >> n >> m;
for (int l = 0; l < k; l++)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[l][i][j];
cin >> x >> y;
x--;
y--;
for (int i = 0; i < k * m * n; i++) {
p[i] = i;
size[i] = 1;
}
for (int l = 0; l < k; l++)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (a[l][i][j] == '.') {
if (i > 0 && a[l][i - 1][j] == '.') {
add(l * n * m + i * m + j, l * n * m + (i - 1) * m + j);
}
if (i + 1 < n && a[l][i + 1][j] == '.') {
add(l * n * m + i * m + j, l * n * m + (i + 1) * m + j);
}
if (j > 0 && a[l][i][j - 1] == '.') {
add(l * n * m + i * m + j, l * n * m + i * m + j - 1);
}
if (j + 1 < m && a[l][i][j + 1] == '.') {
add(l * n * m + i * m + j, l * n * m + i * m + j + 1);
}
if (l > 0 && a[l - 1][i][j] == '.') {
add(l * n * m + i * m + j, (l - 1) * n * m + i * m + j);
}
if (l + 1 < k && a[l + 1][i][j] == '.') {
add(l * n * m + i * m + j, (l + 1) * n * m + i * m + j);
}
}
}
ind = par(x * m + y);
cout << size[ind] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
int n, k;
int a[N];
int ch[N][2], siz[N], tot = 1;
int num[21];
int ans[N], nowans[N], now[N * 10];
int dongtot = 0;
bool Fa = false;
void Ins(int x) {
for (int i = 20; i >= 1; i--) {
num[i] = (x & 1);
x >>= 1;
}
int now = 1;
siz[now]++;
for (int i = 1; i <= 20; i++) {
if (!ch[now][num[i]]) ch[now][num[i]] = (++tot);
now = ch[now][num[i]];
siz[now]++;
}
if (siz[now] >= 2) {
Fa = true;
}
}
inline int Min(int A, int B) { return (A > B) ? B : A; }
int Qmin(int posi, int x, int qian) {
if (!qian) return 0;
int topos = ((x & qian) ? 1 : 0);
if (ch[posi][topos])
return Qmin(ch[posi][topos], x, qian >> 1);
else
return (qian) + Qmin(ch[posi][!topos], x, qian >> 1);
}
int Qmax(int posi, int x, int qian) {
if (!qian) return 0;
int topos = ((x & qian) ? 1 : 0);
if (ch[posi][!topos])
return (qian) + Qmax(ch[posi][!topos], x, qian >> 1);
else
return Qmax(ch[posi][topos], x, qian >> 1);
}
void Solve(int posi, int qian) {
if (siz[posi] < 2) {
for (int i = 0; i < qian; i++) nowans[i] = 2147483647;
return;
}
int hahaha = (qian >> 1);
int L = dongtot + 1;
dongtot += qian;
for (int i = 0; i < qian; i++) now[L + i] = 2147483647;
Solve(ch[posi][0], hahaha);
for (int i = 0; i < (hahaha); i++) {
now[L + i] = Min(now[L + i], nowans[i]);
now[L + i + (hahaha)] = Min(now[L + i + (hahaha)], nowans[i]);
}
Solve(ch[posi][1], hahaha);
for (int i = 0; i < (hahaha); i++) {
now[L + i] = Min(now[L + i], nowans[i]);
now[L + i + (hahaha)] = Min(now[L + i + (hahaha)], nowans[i]);
}
if (!ch[posi][0] || !ch[posi][1]) {
for (int i = 0; i < qian; i++) {
nowans[i] = now[L + i];
ans[i] = Min(ans[i], nowans[i]);
}
return;
}
for (int i = 0; i < (hahaha); i++) {
int Md1 = Qmin(ch[posi][1], i, hahaha >> 1);
int Md2 = Qmax(ch[posi][0], i, hahaha >> 1);
now[L + i] = Min(now[L + i], Md1 - Md2 + (hahaha));
}
for (int i = (hahaha); i < qian; i++) {
int Md1 = Qmin(ch[posi][0], i ^ (hahaha), hahaha >> 1);
int Md2 = Qmax(ch[posi][1], i ^ (hahaha), hahaha >> 1);
now[L + i] = Min(now[L + i], Md1 - Md2 + (hahaha));
}
for (int i = 0; i < qian; i++) {
nowans[i] = now[L + i];
ans[i] = Min(ans[i], nowans[i]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
Ins(a[i]);
}
if (Fa) {
for (int i = 0; i < (1 << k); i++) printf("0 ");
return 0;
}
for (int i = 0; i < (1 << k); i++) ans[i] = 2147483647;
Solve(1, (1 << 20));
for (int i = 0; i < (1 << k); i++) printf("%d ", ans[i]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a == 0 && b == 0) {
cout << "NO";
return 0;
}
if (abs(a - b) > 1)
cout << "NO";
else
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, a[N], b[N], c[N] = {0};
int main() {
scanf("%d", &n);
int vt, fi;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
if (b[i] == 0) vt = i;
}
if (b[0] == 0) {
for (int i = 0; i < n; i++)
if (a[i] == b[1]) vt = i;
int k = 1;
for (int i = vt; i < n; i++)
if (a[i] != 0) c[k++] = a[i];
for (int i = 0; i < vt; i++)
if (a[i] != 0) c[k++] = a[i];
for (int i = 0; i < n; i++)
if (c[i] != b[i]) {
printf("NO");
return 0;
}
printf("YES");
return 0;
}
for (int i = 0; i < n; i++)
if (a[i] == b[0]) fi = i;
c[vt] = 0;
int k = 0;
for (int i = fi; i < n; i++)
if (k == vt) {
k++;
i--;
} else if (a[i] != 0)
c[k++] = a[i];
for (int i = 0; i < fi; i++)
if (k == vt) {
k++;
i--;
} else if (a[i] != 0)
c[k++] = a[i];
for (int i = 0; i < n; i++)
if (b[i] != c[i]) {
printf("NO");
return 0;
}
printf("YES");
}
| 2 |
#include <bits/stdc++.h>
int main() {
int t, i, h, m, x = 0, y = 0;
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%d%d", &h, &m);
x = 23 - h;
y = 60 - m;
printf("%d\n", (x * 60) + y);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, n, cnt = 0, lft = 0;
char str[1000000];
int ar[26] = {0};
scanf("%s", str);
n = strlen(str);
if (n < 26)
printf("-1\n");
else {
for (i = 0; i < 26; i++) {
if (str[i] == '?')
lft++;
else if (ar[str[i] - 'A'] > 0) {
ar[str[i] - 'A']++;
} else {
ar[str[i] - 'A']++;
cnt++;
}
}
i = 25;
long long int j = 0;
if (lft + cnt != 26) {
for (i = 26; i < n; i++) {
if (str[j] == '?')
lft--;
else {
ar[str[j] - 'A']--;
if (ar[str[j] - 'A'] == 0) cnt--;
}
if (str[i] == '?')
lft++;
else if (ar[str[i] - 'A'] > 0)
ar[str[i] - 'A']++;
else {
ar[str[i] - 'A']++;
cnt++;
}
if (lft + cnt == 26) break;
j++;
}
}
if (i == n)
printf("-1\n");
else {
j = 0;
long long int l;
for (l = i - 25; l <= i; l++) {
if (str[l] == '?') {
while (ar[j] != 0) j++;
str[l] = j + 'A';
j++;
}
}
for (i = 0; i < n; i++)
if (str[i] == '?')
printf("%c", 'A');
else
printf("%c", str[i]);
printf("\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int n, m;
int x[maxn], p[maxn];
int c[maxn];
map<long long, int> pp;
long long dp[maxn][maxn];
long long pre[maxn];
int opt[maxn];
long long dist(int i, int j) { return llabs(x[i] - p[j]); }
long long cost(int a, int b) { return pre[b] - (a > 0 ? pre[a - 1] : 0); }
void compute(int i, int jmin = 0, int jmax = n - 1, int kmin = 0,
int kmax = n) {
int j = jmin + jmax >> 1;
int bk = j - 1;
for (int k = kmin; k <= min(kmax, j + 1); k++) {
if (j - k + 1 <= c[i] &&
dp[(i + 1) & 1][j + 1] > dp[i & 1][k] + cost(k, j)) {
dp[(i + 1) & 1][j + 1] = dp[i & 1][k] + cost(k, j);
bk = k;
}
}
if (jmin < j) compute(i, jmin, j - 1, kmin, bk > -1 ? bk : kmax);
if (j < jmax) compute(i, j + 1, jmax, bk > -1 ? bk : kmin, kmax);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < m; i++) {
int p, c;
cin >> p >> c;
pp[p] += c;
}
m = 0;
int tot = 0;
for (auto it : pp) tot += it.second, p[m] = it.first, c[m] = it.second, m++;
if (tot < n) return cout << -1 << endl, 0;
sort(x, x + n);
for (int i = 0; i < 2; i++)
for (int j = 1; j <= n; j++) dp[i][j] = 1ll << 60;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) pre[j] = dist(j, i) + (j > 0 ? pre[j - 1] : 0);
compute(i);
}
long long ans = dp[m & 1][n];
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool f = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return f ? -x : x;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
putchar('\n');
}
void writep(long long x) {
write(x);
putchar(' ');
}
long long const N = 1e6 + 3;
long long n, m, a[4][N], f[N][2][2][2];
char s[N];
signed main() {
n = read();
m = read();
if (n >= 4 && m >= 4) return puts("-1"), 0;
if (n > m) {
for (long long i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (long long j = 1; j <= m; j++) a[j][i] = s[j] ^ 48;
}
swap(n, m);
} else {
for (long long i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (long long j = 1; j <= m; j++) a[i][j] = s[j] ^ 48;
}
}
if (n == 1) return puts("0"), 0;
if (n == 2) {
memset(f, 0x3f, sizeof(f));
for (long long i = 0; i <= 1; i++)
for (long long j = 0; j <= 1; j++)
f[1][i][j][0] = (a[1][1] != i) + (a[2][1] != j);
for (long long i = 2; i <= m; i++)
for (long long j = 0; j <= 1; j++)
for (long long k = 0; k <= 1; k++)
for (long long p = 0; p <= 1; p++)
for (long long l = 0; l <= 1; l++)
if ((j + k + p + l) & 1)
f[i][j][k][0] =
min(f[i][j][k][0],
f[i - 1][p][l][0] + (j != a[1][i]) + (k != a[2][i]));
long long ans = 1e9;
for (long long i = 0; i <= 1; i++)
for (long long j = 0; j <= 1; j++) ans = min(ans, f[m][i][j][0]);
writeln(ans);
return 0;
}
if (n == 3) {
memset(f, 0x3f, sizeof(f));
for (long long i = 0; i <= 1; i++)
for (long long j = 0; j <= 1; j++)
for (long long k = 0; k <= 1; k++)
f[1][i][j][k] = (a[1][1] != i) + (a[2][1] != j) + (a[3][1] != k);
for (long long i = 2; i <= m; i++)
for (long long j = 0; j <= 1; j++)
for (long long k = 0; k <= 1; k++)
for (long long p = 0; p <= 1; p++)
for (long long l = 0; l <= 1; l++)
for (long long h = 0; h <= 1; h++)
for (long long g = 0; g <= 1; g++)
if (((j + k + l + h) & 1) && ((k + p + h + g) & 1))
f[i][j][k][p] =
min(f[i][j][k][p], f[i - 1][l][h][g] + (a[1][i] != j) +
(a[2][i] != k) + (a[3][i] != p));
long long ans = 1e9;
for (long long i = 0; i <= 1; i++)
for (long long j = 0; j <= 1; j++)
for (long long k = 0; k <= 1; k++) ans = min(ans, f[m][i][j][k]);
writeln(ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int dp[N][N], pre[N], cnt[N];
char a[N], b[N];
int main() {
scanf("%s%s", a, b);
int n = strlen(a), m = strlen(b);
memset(pre, -1, sizeof(pre));
for (int i = 0; i < n; ++i) {
int k = i;
int j = 0;
while (k < n && j < m) {
if (a[k] == b[j]) ++j;
++k;
}
if (j == m) pre[k] = i, cnt[k] = k - i - m;
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j < i; ++j) {
dp[i][j] = dp[i - 1][j];
if (j) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1]);
if (pre[i] != -1 && cnt[i] <= j) {
if (pre[i] >= j - cnt[i])
dp[i][j] = max(dp[i][j], dp[pre[i]][j - cnt[i]] + 1);
}
}
for (int i = 0; i <= n; ++i) printf("%d ", dp[n][i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int arr[n + 1];
arr[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
arr[i] += arr[i - 1];
}
int q, l, r;
cin >> q;
while (q--) {
cin >> l >> r;
printf("%d\n", (arr[r] - arr[l - 1]) / 10);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, a1, a2, b, b1, b2, p[10], ma[10], br;
int main() {
scanf("%d %d %d %d %d %d", &a, &b, &a1, &b1, &a2, &b2);
p[1] = a1 + a2;
p[2] = a1 + b2;
p[3] = b1 + a2;
p[4] = b1 + b2;
ma[1] = max(b1, b2);
ma[2] = max(b1, a2);
ma[3] = max(a1, b2);
ma[4] = max(a1, a2);
for (int i = (1); i < int(5); i++) {
if ((p[i] <= a && ma[i] <= b) || ((p[i] <= b && ma[i] <= a))) {
printf("YES");
br = 1;
break;
}
}
if (!br) {
printf("NO");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
double eps = 1e-8;
double pi = atan(1) * 4;
long long mod = 1000000007;
long long F[1000001];
struct vect2D {
double x, y;
double ang;
int rep;
vect2D() { x = y = 0; }
vect2D(double _x, double _y) { x = _x, y = _y; }
vect2D operator+(vect2D u) { return vect2D(x + u.x, y + u.y); }
vect2D operator-(vect2D u) { return vect2D(x - u.x, y - u.y); }
vect2D to(vect2D& u) { return vect2D(u.x - x, u.y - y); }
vect2D operator*(double u) { return vect2D(x * u, y * u); }
vect2D operator/(double u) { return vect2D(x / u, y / u); }
bool operator==(vect2D that) {
return abs(x - that.x) + abs(y - that.y) < eps;
}
double dotProd(vect2D u) { return x * u.x + y * u.y; }
double crossProd(vect2D u) { return x * u.y - y * u.x; }
double len() { return sqrt(x * x + y * y); }
double len2() { return x * x + y * y; }
double dist() { return sqrt(x * x + y * y); }
double signedAngleRad(vect2D u) {
if (dotProd(u) < 0) return pi - asin(crossProd(u) / (len() * u.len()));
return asin(crossProd(u) / (len() * u.len()));
}
double signedAngleDeg(vect2D u) { return signedAngleRad(u) / pi * 180; }
vect2D resize(double u) { return (*this) * (u / len()); }
vect2D normalize() { return resize(1); }
vect2D projectTo(vect2D u) { return u.resize(dotProd(u.normalize())); }
vect2D tangentTo(vect2D u) { return (*this) - projectTo(u); }
friend ostream& operator<<(ostream& os, const vect2D& v) {
return os << "(" << v.x << ", " << v.y << ")";
}
bool operator<(vect2D that) const {
if (abs(x - that.x) < eps) {
return y < that.y;
}
return x < that.x;
}
} P[1001];
vector<vect2D> mids;
bool dircmp(vect2D A, vect2D B) {
if (A.to(B).len() < eps) return A.ang < B.ang;
return A < B;
}
int MAIN() {
F[0] = 1;
F[1] = 2;
for (int i = 2; i <= 1000000; i++) F[i] = (F[i - 1] * 2) % mod;
cin >> n;
for (int i = 1; i <= n; i++) {
double a, b, c, d;
cin >> a >> b >> c >> d;
P[i].x = a / b;
P[i].y = c / d;
P[i] = P[i].resize(100 / P[i].len());
}
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
vect2D mid = (P[i] + P[j]) / 2;
vect2D dir = P[i].to(P[j]);
if (abs(dir.x) < eps) {
if (dir.y < 0) dir.y *= -1;
} else {
if (dir.x < 0) {
dir.x *= -1;
dir.y *= -1;
}
}
mid.ang = atan2(dir.y, dir.x);
mid.rep = 1;
mids.push_back(mid);
}
sort(mids.begin(), mids.end(), dircmp);
int last = 0, rep = 1, thisCase = 0;
long long ans = 0;
long long muls = 1;
vector<vect2D> setAns;
for (int i = 0; i < mids.size(); i++) {
if (i > 1 && (mids[i] - mids[i - 1]).len() < eps &&
(mids[i].ang - mids[i - 1].ang) < eps)
setAns[setAns.size() - 1].rep++;
else
setAns.push_back(mids[i]);
}
for (int i = 0; i < setAns.size(); i++) {
int j = i;
long long sum = setAns[j].rep;
long long mul = setAns[j].rep + 1;
while (j + 1 < setAns.size() && (setAns[j + 1] - setAns[i]).len() < eps) {
j++;
sum += setAns[j].rep;
mul *= setAns[j].rep + 1;
mul %= mod;
}
ans += mul;
ans -= sum;
ans -= 1;
ans %= mod;
i = j;
}
ans %= mod;
ans += mod;
ans %= mod;
cout << ans << endl;
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long INF = (long long)1e18;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int N = 100100;
string second;
bool ok;
int main() {
cin >> second;
string t, S;
int cnt = 0, ix = -1;
if (second[0] == '-') ok = 1;
bool was = 0;
for (int i = ok; i < (int)second.size(); ++i) {
if (second[i] == '.') {
was = 1;
}
if (was) {
t += second[i];
cnt++;
if (cnt == 3) break;
} else {
S += second[i];
}
}
while (cnt < 3 && was) {
cnt++;
t += "0";
}
if (!was) {
t = ".00";
}
reverse(S.begin(), S.end());
second = "";
for (int i = 0; i < (int)S.size(); ++i) {
if (i && i % 3 == 0) {
second += ",";
}
second += S[i];
}
reverse(second.begin(), second.end());
second += t;
if (ok)
t = "($";
else
t = "$";
t += second;
if (ok) t += ")";
cout << t << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double PI = 3.1415926536;
int dX[] = {1, -1, 0, 0};
int dY[] = {0, 0, 1, -1};
bool isVowel(char c) {
return c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U' || c == 'Y';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
double dp[500001] = {}, tmp = 0, res = 0;
cin >> s;
for (int i = (1); i < ((int)s.size() + 1); i++) dp[i] = dp[i - 1] + 1.0 / i;
for (int i = (0); i < ((int)s.size() - i); i++) {
tmp += dp[(int)s.size() - i] - dp[i];
if (isVowel(s[i])) res += tmp;
if ((int)s.size() - 1 - i != i && isVowel(s[(int)s.size() - 1 - i]))
res += tmp;
}
cout << fixed << setprecision(6) << res << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int bitct(long long r) { return r == 0 ? 0 : (bitct(r >> 1) + (r & 1)); }
long long gcd(long long x, long long y) { return x ? gcd(y % x, x) : y; }
template <typename T>
ostream& operator<<(ostream& o, vector<T> v) {
o << "{";
int i = 0, s = v.size();
for (; i + 1 < s; i++) o << v[i] << ", ";
if (s) o << v[i];
o << "}";
return o;
}
long long choose(long long n, long long q) {
if (n == 0 || q == 0) return 1;
if (q == 1)
return n;
else
return (choose(n, q - 1) * (n - q + 1) / q);
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
vector<long long> ta, tc;
set<pair<int, int>> reachable;
vector<long long> moves;
int k;
long long h;
void make_reach() {
reachable.clear();
vector<long long> r(k, -1);
r[0] = 0;
priority_queue<long long, vector<long long>, greater<long long>> Q;
Q.push(0);
while (Q.size()) {
long long me = Q.top();
Q.pop();
for (long long i : moves) {
long long nm = (i + me) % k;
long long nv = i + r[me];
if (nv > h) continue;
if (-1 == r[nm % k] || nv < r[nm % k]) {
r[nm % k] = nv;
Q.push(nm % k);
}
}
}
for (int i = 0; i < ta.size(); i++)
if (r[ta[i] % k] != -1 && r[ta[i] % k] <= ta[i])
if (tc[i]) {
reachable.insert(make_pair(tc[i], -i));
}
}
int main() {
int n, m;
cin >> h >> n >> m >> k;
for (int i = 0; i < n; i++) {
long long a, c;
cin >> a >> c;
ta.push_back(a - 1);
tc.push_back(c);
}
make_reach();
for (int xx = 0; xx < m; xx++) {
int typ = 0;
cin >> typ;
if (typ == 1) {
long long x;
cin >> x;
moves.push_back(x);
make_reach();
} else if (typ == 2) {
int x, y;
cin >> x >> y;
x--;
int has = (reachable.end() != reachable.find(make_pair(tc[x], -x)));
if (has) reachable.erase(make_pair(tc[x], -x));
tc[x] -= y;
if (has && tc[x] != 0) reachable.insert(make_pair(tc[x], -x));
} else {
if (reachable.size()) {
cout << reachable.rbegin()->first << endl;
int z = -reachable.rbegin()->second;
tc[z] = 0;
reachable.erase(*reachable.rbegin());
} else
cout << 0 << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int vr, sl, ob;
};
int n, v, t, xx[500000], m, x, y, k, obr[500000], st[500000], mar[500000],
yy[500000], sz[500000], ish[500000], a[500000];
vector<edge> ed[200000];
void dfs(int x) {
for (st[x]; st[x] < ed[x].size(); st[x]++) {
int j = st[x];
int to = ed[x][j].vr;
int in = ed[x][j].sl;
if (mar[in] == 1) continue;
mar[in] = 1;
dfs(to);
}
t++;
xx[t] = x;
}
void add_edge(int x, int y) {
v++;
xx[v] = x;
yy[v] = y;
ed[x].push_back({y, v, 0});
ed[y].push_back({x, v, 1});
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
add_edge(x, y);
sz[x]++;
sz[y]++;
}
for (int i = 1; i <= n; i++) {
if (sz[i] % 2 == 1) {
k++;
a[k] = i;
}
}
for (int i = 1; i <= k; i += 2) add_edge(a[i], a[i + 1]);
if (v % 2 == 1) add_edge(1, 1);
dfs(1);
cout << v << "\n";
for (int i = 1; i <= t - 1; i++)
if (i % 2 == 0)
cout << xx[i] << " " << xx[i + 1] << "\n";
else
cout << xx[i + 1] << " " << xx[i] << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct st {
int x, y;
} p[1001];
int x, y;
void inti() {
p[0].x = 0;
p[0].y = 0;
p[1].x = 1;
p[1].y = 0;
p[2].x = 1;
p[2].y = 1;
int k = 3;
int flag = 0, len = 2;
while (k <= 1000) {
if (!flag) {
p[k].x = p[k - 1].x - len;
p[k].y = p[k - 1].y;
k++;
p[k].x = p[k - 1].x;
p[k].y = p[k - 1].y - len;
k++;
flag = 1;
len++;
} else {
p[k].x = p[k - 1].x + len;
p[k].y = p[k - 1].y;
k++;
p[k].x = p[k - 1].x;
p[k].y = p[k - 1].y + len;
k++;
flag = 0;
len++;
}
}
}
int f1(int i) {
int px = x - p[i - 1].x, py = y - p[i - 1].y;
int qx = p[i].x - p[i - 1].x, qy = p[i].y - p[i - 1].y;
if (px * qy - qx * py == 0) return 1;
return 0;
}
int f2(int i) {
int px = p[i - 1].x - x, py = p[i - 1].y - y;
int qx = p[i].x - x, qy = p[i].y - y;
if (px * qx + qy * py <= 0) return 1;
return 0;
}
int main() {
inti();
while (~scanf("%d %d", &x, &y)) {
for (int i = 1; i < 40005; i++) {
if (f1(i) && f2(i)) {
printf("%d\n", i - 1);
break;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int a[300005];
std::vector<int> g[300005];
int vis[600005], count[600005];
int p[600005];
int find(int u) {
if (p[u] == u)
return u;
else
return p[u] = find(p[u]);
}
void merge(int u, int v) {
int x = find(u), y = find(v);
if (x != y) {
if (x > y) {
p[y] = x;
count[x] += count[y];
count[y] = 0;
} else {
p[x] = y;
count[y] += count[x];
count[x] = 0;
}
}
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%1d", &a[i]);
for (int i = 1; i <= k; i++) {
int c;
scanf("%d", &c);
while (c--) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
p[i] = i;
p[i + k] = i + k;
count[i] = 0, count[i + k] = 1;
}
int ans = 0;
int True = 2 * k + 1;
p[True] = True;
count[True] = 0;
for (int i = 1; i <= n; i++) {
if ((int)g[i].size() != 0) {
if (g[i].size() == 1) {
int u = g[i][0];
int x = find(u), y = find(u + k);
if (x != True && y != True) {
if (vis[x]) vis[x] = 0, ans -= count[x];
if (vis[y]) vis[y] = 0, ans -= count[y];
ans -= count[True];
if (a[i] != 0)
merge(x, True);
else
merge(y, True);
vis[True] = 1;
ans += count[True];
}
} else {
int u = g[i][0], v = g[i][1];
int x0 = find(u), y0 = find(u + k), x1 = find(v), y1 = find(v + k);
if (vis[x0]) vis[x0] = 0, ans -= count[x0];
if (vis[y0]) vis[y0] = 0, ans -= count[y0];
if (vis[x1]) vis[x1] = 0, ans -= count[x1];
if (vis[y1]) vis[y1] = 0, ans -= count[y1];
if (a[i] != 0) {
merge(x0, x1);
merge(y0, y1);
} else {
merge(x0, y1);
merge(x1, y0);
}
int x = find(u), y = find(u + k);
if (x == True || y == True) {
vis[True] = 1;
ans += count[True];
} else {
int t = count[x] < count[y] ? x : y;
vis[t] = 1;
ans += count[t];
}
}
}
printf("%d\n", ans);
}
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int Read() {
char c;
while (c = getchar(), (c != '-') && (c < '0' || c > '9'))
;
bool neg = (c == '-');
int ret = (neg ? 0 : c - 48);
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + c - 48;
return neg ? -ret : ret;
}
const int MAXN = 85;
int N, n;
int loc[MAXN * 2], l[MAXN], r[MAXN], tot[MAXN];
double ans[MAXN], f[MAXN][MAXN], g[MAXN][MAXN];
void init() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
l[i] = Read(), r[i] = Read(), tot[i] = r[i] - l[i];
loc[i + i - 1] = l[i], loc[i + i] = r[i];
}
sort(loc + 1, loc + N + N + 1),
n = unique(loc + 1, loc + N + N + 1) - loc - 1;
for (int i = 1; i <= N; i++)
l[i] = lower_bound(loc + 1, loc + n + 1, l[i]) - loc,
r[i] = lower_bound(loc + 1, loc + n + 1, r[i]) - loc;
}
void work() {
for (int i = 1; i <= N; i++) {
memset(ans, 0, sizeof(ans)), memset(g, 0, sizeof(g));
for (int j = l[i]; j <= r[i] - 1; j++) {
memset(f, 0, sizeof(f)), f[0][0] = (double)(loc[j + 1] - loc[j]) / tot[i];
for (int k = 1; k <= N; k++)
if (i != k) {
double p1 =
(j >= r[k]
? 1.0
: (j < l[k] ? 0.0
: (double)(loc[j] - loc[l[k]]) / tot[k])),
p2 = (l[k] <= j && j < r[k]
? (double)(loc[j + 1] - loc[j]) / tot[k]
: 0.0);
int m = k - (k > i);
for (int p = m; p >= 0; p--)
for (int q = m - p; q >= 0; q--) {
f[p][q] *= (1.0 - p1 - p2);
if (p) f[p][q] += f[p - 1][q] * p1;
if (q) f[p][q] += f[p][q - 1] * p2;
}
}
for (int p = 0; p <= N - 1; p++)
for (int q = 0; q <= N - 1 - p; q++) g[p][q] += f[p][q];
}
for (int p = 0; p <= N - 1; p++)
for (int q = 0; q <= N - p - 1; q++)
for (int k = 0; k <= q; k++) ans[p + k + 1] += g[p][q] / (q + 1);
for (int j = 1; j <= N; j++)
printf("%.10f%c", (double)ans[j], j < N ? ' ' : '\n');
}
}
int main() {
init();
work();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int t, cas = 1;
int a[5], b[5];
int n, i, j, q, x, y, z, sum, mx, mn;
int maxi(int a[], int b[]) {
return min(a[0], b[1]) + min(a[1], b[2]) + min(a[2], b[0]);
}
int main() {
cin >> n;
mn = INT_MAX;
for (i = 0; i < 3; i++) cin >> a[i];
for (i = 0; i < 3; i++) cin >> b[i];
mx = maxi(a, b);
pair<int, int> aa[7];
aa[0] = {0, 0};
aa[1] = {0, 2};
aa[2] = {1, 0};
aa[3] = {1, 1};
aa[4] = {2, 1};
aa[5] = {2, 2};
for (i = 0; i < 720; i++) {
int tem_a[5], tem_b[5];
for (j = 0; j < 3; j++) tem_a[j] = a[j], tem_b[j] = b[j];
for (j = 0; j < 6; j++) {
z = min(tem_a[aa[j].first], tem_b[aa[j].second]);
tem_a[aa[j].first] -= z;
tem_b[aa[j].second] -= z;
}
sum = maxi(tem_a, tem_b);
mn = min(sum, mn);
next_permutation(aa, aa + 6);
}
cout << mn << " " << mx;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct Tquery {
int first, second;
int result;
bool done;
} q[maxn + 1];
struct Tinfo {
int len;
vector<int> pos;
vector<int> qid;
} info[maxn * 4 + 1];
char olds[maxn + 1];
string s;
int best[maxn * 4 + 1];
int yh[maxn + 1][4 + 1];
int n, ge;
unordered_map<string, int> id;
int idnum;
int hou[maxn + 1], qian[maxn + 1];
void init() {
int i, j;
bool ky;
string sub;
scanf("%s", olds);
scanf("%d", &ge);
n = strlen(olds);
s = olds;
idnum = 0;
for (i = 0; i < n; ++i) {
for (j = 1; (j <= 4) && (i + j <= n); ++j) {
sub = s.substr(i, j);
if (id.find(sub) == id.end()) id[sub] = (++idnum);
info[id[sub]].len = j;
info[id[sub]].pos.push_back(i);
yh[i][j] = id[sub];
}
}
for (i = 1; i <= ge; ++i) {
ky = true;
scanf("%s", olds);
sub = olds;
if (id.find(sub) == id.end())
ky = false;
else
q[i].first = id[sub];
scanf("%s", olds);
sub = olds;
if (id.find(sub) == id.end())
ky = false;
else
q[i].second = id[sub];
info[q[i].first].qid.push_back(i);
if (q[i].first != q[i].second) info[q[i].second].qid.push_back(i);
if (!ky) {
q[i].result = -1;
q[i].done = true;
} else
q[i].done = false;
}
}
int da(int a, int b) {
if (a > b)
return a;
else
return b;
}
int merge(vector<int> &a, int lena, vector<int> &b, int lenb) {
int i = 0, j = 0;
int result = n, tmp;
while ((i < a.size()) && (j < b.size())) {
if (a[i] < b[j]) {
tmp = da(a[i] + lena - 1, b[j] + lenb - 1) - a[i] + 1;
if (tmp < result) result = tmp;
++i;
} else if (a[i] > b[j]) {
tmp = da(a[i] + lena - 1, b[j] + lenb - 1) - b[j] + 1;
if (tmp < result) result = tmp;
++j;
} else {
result = lena;
if (lenb > result) result = lenb;
return result;
}
}
return result;
}
void work() {
int i, j, k, p, w, tmp, sq, T;
sq = sqrt(ge);
if (sq == 0) sq = 1;
T = n / sq;
if (T < 1) T = 1;
for (i = 1; i <= ge; ++i)
if (!q[i].done)
if ((info[q[i].first].pos.size() <= T) &&
(info[q[i].second].pos.size() <= T)) {
q[i].done = true;
q[i].result = merge(info[q[i].first].pos, info[q[i].first].len,
info[q[i].second].pos, info[q[i].second].len);
}
for (i = 1; i <= idnum; ++i)
if (info[i].pos.size() > T) {
for (j = 1; j <= idnum; ++j) best[j] = n;
for (j = 0; j < n; ++j) hou[j] = qian[j] = -1;
for (j = 0; j < info[i].pos.size(); ++j)
hou[info[i].pos[j]] = qian[info[i].pos[j]] = info[i].pos[j];
for (j = 1; j < n; ++j)
if ((qian[j] == -1) && (qian[j - 1] != -1)) qian[j] = qian[j - 1];
for (j = n - 2; j >= 0; --j)
if ((hou[j] == -1) && (hou[j + 1] != -1)) hou[j] = hou[j + 1];
for (j = 0; j < n; ++j)
for (k = 1; k <= 4; ++k)
if (j + k <= n) {
if (qian[j] != -1) {
tmp = da(qian[j] + info[i].len - 1, j + k - 1) - qian[j] + 1;
if (tmp < best[yh[j][k]]) best[yh[j][k]] = tmp;
}
if (hou[j] != -1) {
tmp = da(hou[j] + info[i].len - 1, j + k - 1) - j + 1;
if (tmp < best[yh[j][k]]) best[yh[j][k]] = tmp;
}
}
for (j = 0; j < info[i].qid.size(); ++j) {
k = info[i].qid[j];
if (!q[k].done) {
q[k].done = true;
if (i == q[k].first)
q[k].result = best[q[k].second];
else
q[k].result = best[q[k].first];
}
}
}
}
void output() {
int i;
for (i = 1; i <= ge; ++i) printf("%d\n", q[i].result);
}
int main() {
init();
work();
output();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool visit[1000005];
int main() {
int n;
cin >> n;
vector<int> x;
int MAX = INT_MIN;
int y;
for (int i = 0; i < n; i++) {
cin >> y;
x.push_back(y);
MAX = max(y, MAX);
}
int c = 0;
int i = 0;
int dirC = 0;
bool increOn = true;
bool justStart = true;
while (c < n) {
if ((x[i] == 0 || x[i] <= c) && !visit[i]) {
c++;
visit[i] = true;
}
if (i == x.size() - 1) increOn = false;
if (i == 0) increOn = true;
if (i == 0 && justStart == true) {
i++;
justStart = false;
continue;
}
if ((i == 0 || i == x.size() - 1) && c < n) {
dirC++;
}
if (increOn)
i++;
else
i--;
}
cout << dirC;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > g[int(1e5)];
int main() {
int n, m, k;
cin >> n >> m >> k;
int x = 0;
for (int i = 1; i <= n; i++) {
if (i & 1) {
for (int j = 1; j <= m; j++) {
if (g[x].size() == 2 && x < k - 1) x++;
g[x].push_back({i, j});
}
} else {
for (int j = m; j > 0; j--) {
if (g[x].size() == 2 && x < k - 1) x++;
g[x].push_back({i, j});
}
}
}
for (int i = 0; i < k; i++) {
cout << g[i].size() << " ";
for (int j = 0; j < g[i].size(); j++) {
cout << g[i][j].first << " " << g[i][j].second << " ";
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
const int mod = 1000000007;
const int N = 3e5, M = N;
vector<int> g[N];
int a[N];
void solve() {
int i = 0, j = 0, n, m, k, flag = 0, ans = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = 0; i < 3002; i++) {
if (i == 0) continue;
if (a[i - 1] != i) {
ans = i;
break;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long poww(long long a, long long b) {
long long res = 1;
a %= 1000000007;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "Mahmoud" << '\n';
} else {
cout << "Ehab" << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
long long ar[n];
for (long long i = 0; i < n; i++) {
cin >> ar[i];
}
map<long long, long long> mp1, mp2;
for (long long i = 0; i < n; i++) {
mp2[ar[i]]++;
}
mp1[ar[0]]++;
mp2[ar[0]]--;
long long ans = 0;
for (long long i = 1; i < n - 1; i++) {
mp2[ar[i]]--;
if (ar[i] % k == 0) ans += mp1[ar[i] / k] * mp2[ar[i] * k];
mp1[ar[i]]++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
const int INF = INT_MAX;
const long long INFLL = (long long)1e18;
const double PI = acos(-1.0);
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int N = (int)2e5 + 5;
const int P = 1 << 18;
long long n;
int main() {
ios::sync_with_stdio(false);
cout.setf(ios::fixed | ios::showpoint);
cout.precision(8);
cin >> n;
long long sum = 1ll;
long long cnt = 1ll;
if (n == 1ll) return !printf("1\n");
for (long long i = 2;; i *= 2) {
sum += i;
cnt++;
if (sum >= n) return !printf("%I64d\n", cnt);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int cmp(double x) {
if (fabs(x) < eps) return 0;
if (x > 0) return 1;
return -1;
}
int cmp(double x, double y) { return cmp(x - y); }
inline double sqr(double x) { return x * x; }
struct point {
double x, y;
point() {}
point(double a, double b) : x(a), y(b) {}
friend point operator+(const point &a, const point &b) {
return point(a.x + b.x, a.y + b.y);
}
friend point operator-(const point &a, const point &b) {
return point(a.x - b.x, a.y - b.y);
}
friend bool operator==(const point &a, const point &b) {
return cmp(a.x - b.x) == 0 && cmp(a.y - b.y) == 0;
}
friend bool operator<(const point &a, const point &b) {
if (cmp(a.x - b.x) < 0) return true;
if (cmp(a.x - b.x) > 0) return false;
return cmp(a.y - b.y) < 0;
}
friend point operator*(const point &a, const double &b) {
return point(a.x * b, a.y * b);
}
friend point operator*(const double &a, const point &b) {
return point(a * b.x, a * b.y);
}
friend point operator/(const point &a, const double &b) {
return point(a.x / b, a.y / b);
}
friend istream &operator>>(istream &fin, point &a) {
fin >> a.x >> a.y;
return fin;
}
double norm() { return sqrt(sqr(x) + sqr(y)); }
};
double det(const point &a, const point &b) { return a.x * b.y - a.y * b.x; }
double dot(const point &a, const point &b) { return a.x * b.x + a.y * b.y; }
double dist(const point &a, const point &b) { return (a - b).norm(); }
point rorate_point(const point &p, double A) {
double tx = p.x, ty = p.y;
return point(tx * cos(A) - ty * sin(A), tx * sin(A) + ty * cos(A));
}
struct line {
point a, b;
line(point x, point y) : a(x), b(y) {}
};
double dis_point_segment(const point p, const point s, const point t) {
if (cmp(dot(p - s, t - s)) < 0) return (p - s).norm();
if (cmp(dot(p - t, s - t)) < 0) return (p - t).norm();
return fabs(det(s - p, t - p) / dist(s, t));
}
void PointProjLine(const point p, const point s, const point t, point &cp) {
double r = dot((t - s), (p - s)) / dot(t - s, t - s);
cp = s + r * (t - s);
}
bool PointOnSegment(point p, point s, point t) {
return cmp(det(p - s, t - s)) == 0 && cmp(dot(p - s, p - t)) <= 0;
}
bool parallel(line a, line b) { return !cmp(det(a.a - a.b, b.a - b.b)); }
bool line_make_point(line a, line b, point &res) {
if (parallel(a, b)) return false;
double s1 = det(a.a - b.a, b.b - b.a);
double s2 = det(a.b - b.a, b.b - b.a);
res = (s1 * a.b - s2 * a.a) / (s1 - s2);
return true;
}
double multiply(point sp, point ep, point op) {
return ((sp.x - op.x) * (ep.y - op.y) - (ep.x - op.x) * (sp.y - op.y));
}
bool intersect(line u, line v) {
return ((max(u.a.x, u.b.x) >= min(v.a.x, v.b.x)) &&
(max(v.a.x, v.b.x) >= min(u.a.x, u.b.x)) &&
(max(u.a.y, u.b.y) >= min(v.a.y, v.b.y)) &&
(max(v.a.y, v.b.y) >= min(u.a.y, u.b.y)) &&
(multiply(v.a, u.b, u.a) * multiply(u.b, v.b, u.a) >= 0) &&
(multiply(u.a, v.b, v.a) * multiply(v.b, u.b, v.a) >= 0));
}
const int maxn = 10001;
struct polygon {
int n;
point a[maxn];
double perimeter() {
double sum = 0;
a[n] = a[0];
for (int i = 0; i < n; i++) sum += (a[i + 1] - a[i]).norm();
return sum;
}
double area() {
double sum = 0;
a[n] = a[0];
for (int i = 0; i < n; i++) sum += det(a[i + 1], a[i]);
return sum / 2.;
}
int Point_In(point t) {
int num = 0, i, d1, d2, k;
a[n] = a[0];
for (int i = 0; i < n; i++) {
if (PointOnSegment(t, a[i], a[i + 1])) return 2;
k = cmp(det(a[i + 1] - a[i], t - a[i]));
d1 = cmp(a[i].y - t.y);
d2 = cmp(a[i + 1].y - t.y);
if (k > 0 && d1 <= 0 && d2 > 0) num++;
if (k < 0 && d2 <= 0 && d1 > 0) num++;
}
return num & 1;
}
};
struct polygon_convex {
vector<point> P;
polygon_convex(int Size = 0) { P.resize(Size); }
};
bool comp_less(const point &a, const point &b) {
return cmp(a.x - b.x) < 0 || cmp(a.x - b.x) == 0 && cmp(a.y - b.y) < 0;
}
polygon_convex convex_hull(vector<point> a) {
polygon_convex res(2 * a.size() + 5);
sort(a.begin(), a.end(), comp_less);
a.erase(unique(a.begin(), a.end()), a.end());
int m = 0;
for (int i = 0; i < a.size(); ++i) {
while (m > 1 &&
cmp(det(res.P[m - 1] - res.P[m - 2], a[i] - res.P[m - 2])) <= 0)
--m;
res.P[m++] = a[i];
}
int k = m;
for (int i = int(a.size()) - 2; i >= 0; --i) {
while (m > k &&
cmp(det(res.P[m - 1] - res.P[m - 2], a[i] - res.P[m - 2])) <= 0)
--m;
res.P[m++] = a[i];
}
res.P.resize(m);
if (a.size() > 1) res.P.resize(m - 1);
return res;
}
int containOlogn(const polygon_convex &a, const point &b) {
int n = a.P.size();
point g = (a.P[0] + a.P[n / 3] + a.P[2 * n / 3]) / 3.0;
int l = 0, r = n;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (cmp(det(a.P[l] - g, a.P[mid] - g)) > 0) {
if (cmp(det(a.P[l] - g, b - g)) >= 0 && cmp(det(a.P[mid] - g, b - g)) < 0)
r = mid;
else
l = mid;
} else {
if (cmp(det(a.P[l] - g, b - g)) < 0 && cmp(det(a.P[mid] - g, b - g)) >= 0)
l = mid;
else
r = mid;
}
}
r %= n;
int z = cmp(det(a.P[r] - b, a.P[l] - b)) - 1;
if (z == -2) return 1;
return z;
}
bool containOn(const polygon_convex &a, const point &b) {
int n = a.P.size();
int sign = 0;
for (int i = 0; i < n; ++i) {
int x = cmp(det(a.P[i] - b, a.P[((i + 1) % n)] - b));
if (x) {
if (sign) {
if (sign != x) return false;
} else
sign = x;
}
}
return true;
}
bool inaline(line a, line b) {
if (!parallel(a, b)) return false;
if (cmp(det(a.a - a.b, a.a - b.a)) == 0) return true;
return false;
}
const double INF = 10000;
inline double cross(complex<double> a, complex<double> b) {
return (conj(a) * b).imag();
}
inline double dot(complex<double> a, complex<double> b) {
return (conj(a) * b).real();
}
inline double satisfy(complex<double> a,
pair<complex<double>, complex<double> > p) {
return cmp(cross(a - p.first, p.second - p.first)) <= 0;
}
complex<double> crosspoint(const pair<complex<double>, complex<double> > &a,
const pair<complex<double>, complex<double> > &b) {
double k = cross(b.first - b.second, a.first - b.second);
k = k / (k - cross(b.first - b.second, a.second - b.second));
return a.first + (a.second - a.first) * k;
}
bool cmpp(const pair<complex<double>, complex<double> > &a,
const pair<complex<double>, complex<double> > &b) {
int res = cmp(arg(a.second - a.first) - arg(b.second - b.first));
return res == 0 ? satisfy(a.first, b) : res < 0;
}
vector<complex<double> > HalfplaneIntersection(
vector<pair<complex<double>, complex<double> > > v) {
sort(v.begin(), v.end(), cmpp);
deque<pair<complex<double>, complex<double> > > q;
deque<complex<double> > ans;
q.push_back(v[0]);
for (int i = 1; i < v.size(); ++i) {
if (cmp(arg(v[i].second - v[i].first) -
arg(v[i - 1].second - v[i - 1].first)) == 0) {
continue;
}
while (ans.size() > 0 && !satisfy(ans.back(), v[i])) {
ans.pop_back();
q.pop_back();
}
while (ans.size() > 0 && !satisfy(ans.front(), v[i])) {
ans.pop_front();
q.pop_front();
}
ans.push_back(crosspoint(q.back(), v[i]));
q.push_back(v[i]);
}
while (ans.size() > 0 && !satisfy(ans.back(), q.front())) {
ans.pop_back();
q.pop_back();
}
while (ans.size() > 0 && !satisfy(ans.front(), q.back())) {
ans.pop_front();
q.pop_front();
}
ans.push_back(crosspoint(q.back(), q.front()));
return vector<complex<double> >(ans.begin(), ans.end());
}
vector<complex<double> > convexIntersection(vector<complex<double> > v1,
vector<complex<double> > v2) {
vector<pair<complex<double>, complex<double> > > h;
for (int i = 0; i < v1.size(); ++i)
h.push_back(pair<complex<double>, complex<double> >(
v1[i], v1[(i + 1) % v1.size()]));
for (int i = 0; i < v2.size(); ++i)
h.push_back(pair<complex<double>, complex<double> >(
v2[i], v2[(i + 1) % v2.size()]));
return HalfplaneIntersection(h);
}
point Pointtopoint(complex<double> p) { return point(p.real(), p.imag()); }
complex<double> pointtoPoint(point p) { return complex<double>(p.x, p.y); }
int main() {
double w, h;
double a;
cin >> w >> h >> a;
a = a * 2 * M_PI / 360;
vector<complex<double> > c1, c2;
complex<double> p1(w / 2, h / 2), p2(-w / 2, h / 2), p3(-w / 2, -h / 2),
p4(w / 2, -h / 2);
c1.push_back(p1);
c1.push_back(p2);
c1.push_back(p3);
c1.push_back(p4);
c2.push_back(pointtoPoint(rorate_point(Pointtopoint(p1), a)));
c2.push_back(pointtoPoint(rorate_point(Pointtopoint(p2), a)));
c2.push_back(pointtoPoint(rorate_point(Pointtopoint(p3), a)));
c2.push_back(pointtoPoint(rorate_point(Pointtopoint(p4), a)));
vector<complex<double> > c3 = convexIntersection(c1, c2);
polygon pp;
pp.n = c3.size();
for (int i = 0; i < c3.size(); ++i) pp.a[i] = Pointtopoint(c3[i]);
printf("%.8f", fabs(pp.area()));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec;
int n;
vector<int> a, b, res;
bool possible(int t) {
int tinit = t;
vector<int> aux = a, bux = b;
if (aux[0] < t) {
return false;
}
bux[1] += aux[0] - t;
for (int i = 1; i < 41; i++) {
if (bux[i] > t) {
return false;
}
if (aux[i] > t) {
bux[i + 1] += aux[i] - t;
} else if (aux[i] < t) {
bux[i] -= t - aux[i];
bux[i] = max(bux[i], 0);
t = aux[i];
}
bux[i + 1] += bux[i];
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
a.resize(42);
b.resize(42);
for (int i = 0; i < 42; i++) {
a[i] = 0;
b[i] = 0;
}
int pot = 0;
for (int i = 0; i < vec.size(); i++) {
while (vec[i] > (1LL << pot)) {
pot++;
}
if (vec[i] == (1LL << pot)) {
a[pot]++;
} else {
b[pot]++;
}
}
res.clear();
for (int i = 1; i <= n; i++) {
if (possible(i)) {
res.push_back(i);
}
}
if (res.empty()) {
cout << -1 << endl;
} else {
for (int i = 0; i < res.size(); i++) {
if (i == res.size() - 1) {
cout << res[i] << endl;
} else {
cout << res[i] << " ";
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
unsigned long long int power(unsigned long long int base,
unsigned long long int exp) {
unsigned long long int res = 1;
while (exp) {
if (exp % 2) res *= base;
base *= base;
res %= mod;
base %= mod;
exp /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
unsigned long long int n, i;
cin >> n;
n--;
unsigned long long int x = n, bits = 0;
vector<unsigned long long int> v;
while (x) {
v.push_back(x % 2);
bits++;
x /= 2;
}
unsigned long long int ans = 0;
x = 1;
for (i = 1; i <= bits; i++) {
x *= 2;
ans += 1ull * (x / 2) * (v[i - 1] + n / x);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<string, pair<vector<string>, int> > mp;
bool c(string &x, string &y) {
int i = x.size();
int j = y.size();
if (i > j) return 0;
while (i--) {
j--;
if (x[i] != y[j]) return 0;
}
return 1;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string a;
cin >> a;
int v;
cin >> v;
for (int j = 0; j < v; j++) {
string s;
cin >> s;
mp[a].first.push_back(s);
}
}
cout << mp.size() << endl;
;
for (map<string, pair<vector<string>, int> >::iterator it = mp.begin();
it != mp.end(); it++) {
pair<vector<string>, int> p = it->second;
p.second = p.first.size();
for (int i = 0; i < p.first.size(); i++) {
string &x = p.first[i];
for (int j = 0; j < p.first.size(); j++) {
if (i == j) continue;
if (c(x, p.first[j])) {
x = "!";
p.second--;
break;
}
}
}
string k = it->first;
cout << k << " " << p.second << " ";
for (int i = 0; i < p.first.size(); i++) {
string &x = p.first[i];
if (x != "!") cout << x << " ";
}
puts("");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long comb[1005][2010], n, m, k;
void init() {
for (int i = 1; i < 1005; i++)
for (int j = 0; j < 1005; j++) {
if (j > i)
comb[i][j] = 0;
else if (!j || i == j)
comb[i][j] = 1;
else if (j == 1 || j == i - 1)
comb[i][j] = i;
else
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % MOD;
}
}
int main() {
init();
cin >> n >> m >> k;
printf("%lld\n", (comb[n - 1][2 * k] * comb[m - 1][2 * k]) % MOD);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, i;
cin >> n;
int arr[n + 5];
for (i = 1; i <= n; i++) {
cin >> arr[i];
}
for (i = 2; i < n; i++) {
if (arr[i] == 0 && arr[i - 1] == 1 && arr[i + 1] == 1) {
++ans;
i += 2;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using int64 = long long;
const int N = 105;
char p[N][N];
int T, n, m, k, x, y;
int a[N], r[N];
inline char selcol(char a, char b, char c) {
r[0] = r[1] = r[2] = r[3] = 0;
r[a - 'a'] = r[b - 'a'] = r[c - 'a'] = 1;
if (!r[0]) return 'a';
if (!r[1]) return 'b';
if (!r[2]) return 'c';
return 'd';
}
inline void plh(int x, int y) {
int t = selcol(p[x - 1][y], p[x - 1][y + 1], p[x][y - 1]);
p[x][y] = p[x][y + 1] = t;
}
inline void pls(int x, int y) {
int t = selcol(p[x - 1][y], p[x][y - 1], p[x + 1][y - 1]);
p[x][y] = p[x + 1][y] = t;
}
inline void out(int n, int m) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) std::cout << p[i][j];
std::cout << '\n';
}
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0), std::cout.tie(0);
std::cin >> T;
while (T--) {
std::cin >> n >> m >> k;
memset(p, 'a', sizeof(p));
if (n & 1) {
if (k < m / 2) {
std::cout << "NO\n";
continue;
}
k -= m / 2, --n;
if (k & 1) {
std::cout << "NO\n";
continue;
}
std::cout << "YES\n";
x = 1, y = 1;
while (k) {
plh(x, y), --k;
if (++x > n) ++ ++y, x = 1;
}
while (y <= m) {
pls(x, y), pls(x, y + 1);
if (++ ++x > n) ++ ++y, x = 1;
}
for (int i = 1; i <= m; ++ ++i) plh(n + 1, i);
out(n + 1, m);
continue;
}
if (m & 1) {
if (k & 1 || k > m / 2 * n) {
std::cout << "NO\n";
continue;
}
std::cout << "YES\n";
x = 1, y = 1;
while (k) {
plh(x, y), --k;
if (++x > n) ++ ++y, x = 1;
}
while (y <= m) {
pls(x, y), pls(x, y + 1);
if (++ ++x > n) ++ ++y, x = 1;
}
out(n, m);
continue;
}
if (k & 1) {
std::cout << "NO\n";
continue;
}
std::cout << "YES\n";
x = 1, y = 1;
while (k) {
plh(x, y), --k;
if (++x > n) ++ ++y, x = 1;
}
while (y <= m) {
pls(x, y), pls(x, y + 1);
if (++ ++x > n) ++ ++y, x = 1;
}
out(n, m);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long m[n];
for (long long i = 0; i < n; i++) {
cin >> m[i];
}
vector<long long> ls(n);
stack<pair<long long, long long> > s;
for (long long i = 0; i < n; i++) {
while (!s.empty() && s.top().first >= m[i]) {
s.pop();
}
if (s.empty())
ls[i] = -1;
else
ls[i] = s.top().second;
s.push({m[i], i});
}
vector<long long> rs(n);
while (!s.empty()) s.pop();
for (long long i = n - 1; i >= 0; i--) {
while (!s.empty() && s.top().first >= m[i]) s.pop();
if (s.empty())
rs[i] = -1;
else
rs[i] = s.top().second;
s.push({m[i], i});
}
long long l[n];
for (long long i = 0; i < n; i++) {
if (ls[i] == -1)
l[i] = (i + 1) * m[i];
else {
long long j = ls[i];
l[i] = l[j] + (i - j) * m[i];
}
}
long long r[n];
for (long long i = n - 1; i >= 0; i--) {
if (rs[i] == -1)
r[i] = (n - i) * m[i];
else {
long long j = rs[i];
r[i] = r[j] + (j - i) * m[i];
}
}
long long floors = 0, index = -1;
for (long long i = 0; i < n; i++) {
if (l[i] + r[i] - m[i] > floors) {
floors = l[i] + r[i] - m[i];
index = i;
}
}
long long ans[n];
ans[index] = m[index];
long long last = m[index];
for (long long j = index - 1; j >= 0; j--) {
if (m[j] >= last) {
ans[j] = last;
} else {
ans[j] = m[j];
last = m[j];
}
}
last = m[index];
for (long long j = index + 1; j < n; j++) {
if (m[j] >= last) {
ans[j] = last;
} else {
ans[j] = m[j];
last = m[j];
}
}
for (long long i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (auto &x : v) in >> x;
return in;
}
template <typename T>
ostream &operator<<(ostream &in, vector<T> &v) {
for (auto &x : v) in << x << " ";
return in;
}
long long fast(long long a, long long b, long long mid) {
if (b == 0) return 1;
a %= mid;
long long ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % mid;
}
a *= a;
a %= mid;
b >>= 1;
}
return ans;
}
class solve {
public:
solve() {
int n;
cin >> n;
vector<int> v(n), w(n), idx(n), idx2(n), idx3(n);
for (auto &x : v) scanf("%d", &x);
for (auto &x : w) scanf("%d", &x);
for (int i = 0; i < n; i++) idx[i] = idx2[i] = idx3[i] = i;
sort(idx.begin(), idx.end(),
[&](const int &a, const int &b) { return v[a] < v[b]; });
sort(idx2.begin(), idx2.end(),
[&](const int &a, const int &b) { return w[a] < w[b]; });
sort(idx3.begin(), idx3.end(),
[&](const int &a, const int &b) { return idx2[a] < idx2[b]; });
for (int i = 0; i < n; i++) {
int id = idx3[i];
printf("%d ", v[idx[n - 1 - id]]);
}
cout << "\n";
return;
}
};
int32_t main() {
int t = 1, i = 1;
if (0) scanf("%d", &t);
while (t--) {
if (0) printf("Case #%d: ", i++);
new solve;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1LL;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
template <class T>
inline void chmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void chmin(T &a, T b) {
if (a > b) a = b;
}
inline void swap(int &a, int &b) {
int c = a;
a = b;
b = c;
}
using namespace std;
const int N = 2e5 + 10;
int n, m;
vector<int> base;
inline void add(int x) {
vector<int>::iterator it = base.begin();
for (; it != base.end(); ++it) x = min(x, x ^ (*it));
if (x) {
it = base.begin();
for (; it != base.end(); ++it) *it = min(*it, (*it) ^ x);
base.push_back(x);
}
}
inline int query(int x) {
vector<int>::iterator it = base.begin();
for (; it != base.end(); ++it) x = min(x, x ^ *it);
return x;
}
struct DSU {
int fa[N], ra[N], w[N];
stack<pair<int *, int> > s;
inline void init(int n) {
for (int i = (1); i <= (n); ++i) fa[i] = i, ra[i] = w[i] = 0;
}
inline int find(int x) {
while (x != fa[x]) x = fa[x];
return x;
}
inline int get(int x) {
int ret = 0;
while (x != fa[x]) ret = ret ^ w[x], x = fa[x];
return ret;
}
inline int merge(int x, int y, int z) {
int fx = find(x), fy = find(y);
if (fx == fy)
return 0;
else {
if (ra[fx] < ra[fy]) {
s.push(make_pair(&w[fx], w[fx]));
w[fx] = get(x) ^ get(y) ^ z;
s.push(make_pair(&fa[fx], fa[fx]));
fa[fx] = fy;
} else {
s.push(make_pair(&w[fy], w[fy]));
w[fy] = get(x) ^ get(y) ^ z;
s.push(make_pair(&fa[fy], fa[fy]));
fa[fy] = fx;
if (ra[fx] == ra[fy]) {
s.push(make_pair(&ra[fx], ra[fx]));
++ra[fx];
}
}
}
return 1;
}
inline void rollback(int x) {
while (s.size() > x) {
*s.top().first = s.top().second;
s.pop();
}
}
} dsu;
int x[N], y[N], d[N], op[N];
vector<vector<int> > sm[N << 2];
inline void cover(int cur, int L, int R, int l, int r, int x, int y, int d) {
if (l <= L && r >= R) {
vector<int> tmp;
tmp.push_back(x);
tmp.push_back(y);
tmp.push_back(d);
sm[cur].push_back(tmp);
return;
}
int mid = (L + R) >> 1;
if (l <= mid) cover(cur << 1, L, mid, l, r, x, y, d);
if (r > mid) cover(cur << 1 | 1, mid + 1, R, l, r, x, y, d);
}
inline void solve(int cur, int l, int r) {
int mid = (l + r) >> 1, sz = (int)dsu.s.size();
vector<int> tbase = base;
for (int i = (0); i <= ((int)(sm[cur].size()) - 1); ++i) {
int x = sm[cur][i][0], y = sm[cur][i][1], w = sm[cur][i][2];
if (!dsu.merge(x, y, w)) add(dsu.get(x) ^ dsu.get(y) ^ w);
}
if (l == r) {
if (op[l] == 3) printf("%d\n", query(dsu.get(x[l]) ^ dsu.get(y[l])));
} else {
solve(cur << 1, l, mid);
solve(cur << 1 | 1, mid + 1, r);
}
dsu.rollback(sz);
base = tbase;
}
int main() {
n = read();
m = read();
map<pair<int, int>, pair<int, int> > t;
for (int i = (1); i <= (m); ++i) {
int u = read(), v = read(), w = read();
t[make_pair(u, v)] = make_pair(w, 0);
}
int q = read();
for (int i = (1); i <= (q); ++i) {
op[i] = read();
if (op[i] == 1) {
x[i] = read(), y[i] = read(), d[i] = read();
t[make_pair(x[i], y[i])] = make_pair(d[i], i);
} else if (op[i] == 2) {
x[i] = read(), y[i] = read();
pair<int, int> tt = t[make_pair(x[i], y[i])];
cover(1, 0, q, tt.second, i - 1, x[i], y[i], tt.first);
t.erase(make_pair(x[i], y[i]));
} else {
x[i] = read(), y[i] = read();
}
}
map<pair<int, int>, pair<int, int> >::iterator it = t.begin();
for (; it != t.end(); ++it) {
cover(1, 0, q, it->second.second, q, it->first.first, it->first.second,
it->second.first);
}
dsu.init(n);
solve(1, 0, q);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[2001];
int ans = 0;
for (int i = 1; i < (int)n + 1; i++) cin >> a[i];
for (int i = 1; i < (int)n + 1; i++) {
int j = i, count = 1;
while (a[j] != -1) {
j = a[j];
count++;
}
ans = max(ans, count);
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long infty = 1e18;
vector<long long> primeFactorization(long long x) {
vector<long long> ans;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
ans.push_back(i);
}
while (x % i == 0) {
x /= i;
}
}
if (x > 1) {
ans.push_back(x);
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long x, y;
cin >> x >> y;
vector<long long> xPrimes = primeFactorization(x);
long long ans = 0;
while (y != 0) {
long long g = gcd(x, y);
if (g == x) {
ans += y / x;
y = 0;
break;
}
if (g == y) {
ans++;
y = 0;
break;
}
long long currAns = infty;
for (int i = 0; i < xPrimes.size(); i++) {
long long pi = xPrimes[i];
long long gpi = g * pi;
if (x % gpi != 0) {
continue;
}
long long k = (y % gpi) / g;
currAns = min(currAns, k);
}
y -= g * currAns;
ans += currAns;
}
cout << ans << endl;
cin >> x;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int vis[10010000];
int main() {
char a[1001000];
scanf("%s", a);
memset(vis, 0, sizeof(vis));
int mod = 0;
int l = strlen(a);
int p = 0;
int w = 0, e = 0, r = 0, t = 0;
for (int i = 0; i < l; i++) {
int we = (a[i] - '0');
if (we == 0) {
p++;
vis[i] = 1;
continue;
}
if (we == 1 && !w) {
w = 1;
vis[i] = 1;
continue;
}
if (we == 6 && !e) {
vis[i] = 1;
e = 1;
continue;
}
if (we == 8 && !r) {
r = 1;
vis[i] = 1;
;
continue;
}
if (we == 9 && !t) {
vis[i] = 1;
t = 1;
continue;
} else
mod = (mod * 10 + we) % 7;
}
mod = (mod * 10000) % 7;
for (int i = 0; i < l; i++) {
if (!vis[i]) {
printf("%c", a[i]);
}
}
if (mod == 0) {
printf("1869");
} else if (mod + 1 == 7) {
printf("1968");
} else if (mod + 2 == 7) {
printf("1689");
} else if (mod + 3 == 7) {
printf("6198");
} else if (mod + 4 == 7) {
printf("1698");
} else if (mod + 5 == 7) {
printf("1986");
} else if (mod + 6 == 7) {
printf("1896");
}
while (p--) {
printf("0");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, -1, 1, -1, -1, 1, 1};
int dy[] = {-1, 1, 0, 0, -1, 1, -1, 1};
int n, sz, fsz, flag, last;
string str, ch, ans[100], ar[100], nw;
map<int, int> mp;
bool check(int n) {
int sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
if (sum < 10) return 1;
return 0;
}
void call(int pos, int val, int in) {
if (flag) return;
if (pos >= sz) {
if (check(val)) {
fsz = in;
last = val;
flag = true;
for (int i = 0; i < in; i++) ans[i] = ar[i];
}
return;
}
for (int i = pos; i < sz; i++) {
nw = "";
int x = 0;
for (int j = pos; j <= i; j++) {
nw += ch[j];
x = (x * 10) + ch[j] - '0';
}
ar[in] = nw;
call(i + 1, val + x, in + 1);
}
}
int main() {
cin >> n;
cin >> str;
while (1) {
flag = 0;
srand(time(0));
int i = rand() % 9;
if (i == 0 && str.length() > 8) continue;
int val = 0, in = 0;
long long int sum = 0;
while (in < n) {
val = 0;
for (int j = in; j < n && j < in + i; j++)
val = (val * 10) + str[j] - '0';
sum += val;
in += i;
}
stringstream ss;
ss << sum;
ch = ss.str();
sz = ch.length();
call(0, 0, 0);
if (flag) {
i = min(i, n);
for (int j = 0; j < i; j++) cout << str[j];
int in = i;
while (in < n) {
cout << "+";
ch = "";
for (int j = in; j < in + i && j < n; j++) ch += str[j];
cout << ch;
in = in + i;
}
cout << endl;
cout << ans[0];
for (int i = 1; i < fsz; i++) cout << "+" << ans[i];
cout << endl;
stringstream ss;
ss << last;
ch = ss.str();
cout << ch[0];
for (int i = 1; i < ch.length(); i++) cout << "+" << ch[i];
cout << endl;
return 0;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long c[300][300];
long long pd[300][300 + 1];
int n;
long long solve(int p, int q) {
if (q <= 0) return 0;
if (p == n) return LLONG_MAX;
long long& ans = pd[p][q];
if (ans != -1) return ans;
ans = LLONG_MAX;
for (int i = p; i < n; ++i)
if (c[p][i] != LLONG_MAX) {
long long t = solve(i + 1, q - (i - p + 1));
if (t != LLONG_MAX) ans = min(ans, c[p][i] + t);
}
ans = min(ans, solve(p + 1, q));
return ans;
}
int main() {
memset(pd, -1, sizeof pd);
int m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i)
for (int j = i; j < n; ++j) c[i][j] = LLONG_MAX;
while (m--) {
int l, r, t;
scanf("%d%d%d", &l, &r, &t);
--l, --r;
c[l][r] = min(c[l][r], (long long)t);
}
for (int i = 0; i < n; ++i)
for (int j = i; j < n; ++j)
for (int k = i; k <= j; ++k) c[k][j] = min(c[k][j], c[i][j]);
long long ans = solve(0, k);
if (ans == LLONG_MAX) ans = -1;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, x, ans = 0;
cin >> n >> x;
int arr[n];
long long sum = 0;
for (int i = 0; i < n; i++) cin >> arr[i], sum += arr[i];
sort(arr, arr + n);
if (sum / n >= x)
ans = n;
else
for (int i = 0; i < n - 1; i++) {
sum -= arr[i];
if (sum / (n - i - 1) >= x) {
ans = n - i - 1;
break;
}
}
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int difX[] = {2, 2, -2, -2};
int difY[] = {-2, 2, 2, -2};
bool dfs(int y, int x, const vector<string>& board,
vector<vector<bool> >& vis) {
vis[y][x] = true;
if (board[y][x] != '#') return true;
for (int i = 0; i < 4; ++i) {
int nx = x + difX[i];
int ny = y + difY[i];
if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) continue;
if (vis[ny][nx]) continue;
if (dfs(ny, nx, board, vis)) return true;
}
return false;
}
int main(int argc, char* argv[]) {
int n;
cin >> n;
for (int c = 0; c < n; ++c) {
vector<string> board(8);
for (int i = 0; i < 8; ++i) cin >> board[i];
bool found = false;
vector<vector<bool> > possible(8, vector<bool>(8, false));
for (int i = 0; !found && i < 8; ++i)
for (int j = 0; !found && j < 8; ++j)
if (board[i][j] == 'K')
for (int k = 0; k < 4; ++k) {
int nx = j + difX[k];
int ny = i + difY[k];
if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) continue;
if (possible[ny][nx]) {
vector<vector<bool> > vis(8, vector<bool>(8, false));
if (dfs(ny, nx, board, vis)) {
found = true;
break;
}
}
possible[ny][nx] = true;
}
if (found)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return EXIT_SUCCESS;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M, S, T, STEP, cnt, blockedRoad;
long long SOL = 1000000000000000ll;
vector<int> solRoads;
int countEdges[1024][1024];
int viz[1024], prevRoad[1024], prevRoad2[1024], pre[1024], low[1024],
bridge[30100];
vector<pair<pair<int, int>, pair<int, int> > > roads;
vector<pair<pair<int, int>, int> > G[1024];
void DFS(int u, int v) {
pre[v] = cnt++;
low[v] = pre[v];
for (vector<pair<pair<int, int>, int> >::iterator it = G[v].begin();
it != G[v].end(); it++) {
int w = (*it).first.first;
if (pre[w] == -1) {
DFS(v, w);
low[v] = min(low[v], low[w]);
if (low[w] == pre[w]) {
if (countEdges[v][w] == 1) bridge[(*it).second] = STEP;
}
} else if (w != u) {
low[v] = min(low[v], pre[w]);
}
}
}
void BFS(int root) {
queue<int> Q;
Q.push(root);
viz[root] = 1;
prevRoad[root] = 0;
while (!Q.empty()) {
int node = Q.front();
Q.pop();
for (vector<pair<pair<int, int>, int> >::iterator it = G[node].begin();
it != G[node].end(); it++) {
if (!viz[(*it).first.first]) {
Q.push((*it).first.first);
viz[(*it).first.first] = 1;
prevRoad[(*it).first.first] = (*it).second;
}
}
}
}
void BFS2(int root) {
queue<int> Q;
memset(viz, 0, sizeof(viz));
memset(prevRoad2, 0, sizeof(prevRoad2));
Q.push(root);
viz[root] = 1;
prevRoad2[root] = 0;
while (!Q.empty()) {
int node = Q.front();
Q.pop();
for (vector<pair<pair<int, int>, int> >::iterator it = G[node].begin();
it != G[node].end(); it++) {
if (!viz[(*it).first.first]) {
Q.push((*it).first.first);
viz[(*it).first.first] = 1;
prevRoad2[(*it).first.first] = (*it).second;
}
}
}
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
cin >> N >> M;
cin >> S >> T;
for (int i = 1; i <= M; i++) {
int first, second, c;
cin >> first >> second >> c;
roads.push_back(make_pair(make_pair(first, second), make_pair(c, i)));
G[first].push_back(make_pair(make_pair(second, c), i));
G[second].push_back(make_pair(make_pair(first, c), i));
countEdges[first][second]++;
countEdges[second][first]++;
}
BFS(S);
if (!prevRoad[T]) {
cout << 0 << endl;
cout << 0 << endl;
return 0;
}
int currNode = T;
blockedRoad = prevRoad[T];
while (blockedRoad != 0) {
int ll = roads[blockedRoad - 1].first.first;
int rr = roads[blockedRoad - 1].first.second;
int cost = roads[blockedRoad - 1].second.first;
for (vector<pair<pair<int, int>, int> >::iterator it = G[ll].begin();
it != G[ll].end(); it++) {
if ((*it).second == blockedRoad) {
G[ll].erase(it);
break;
}
}
for (vector<pair<pair<int, int>, int> >::iterator it = G[rr].begin();
it != G[rr].end(); it++) {
if ((*it).second == blockedRoad) {
G[rr].erase(it);
break;
}
}
countEdges[ll][rr]--;
countEdges[rr][ll]--;
for (int i = 1; i <= N; i++) low[i] = pre[i] = -1;
STEP++;
cnt = 0;
DFS(S, S);
BFS2(S);
if (prevRoad2[T] == 0) {
if (cost < SOL) {
SOL = cost;
solRoads.clear();
solRoads.push_back(blockedRoad);
}
} else {
int blockedRoad2 = prevRoad2[T];
int currNode2 = T;
while (blockedRoad2) {
int ll2 = roads[blockedRoad2 - 1].first.first;
int rr2 = roads[blockedRoad2 - 1].first.second;
int cost2 = roads[blockedRoad2 - 1].second.first;
if (bridge[blockedRoad2] == STEP) {
if ((long long)cost + (long long)cost2 < SOL) {
SOL = (long long)cost + (long long)cost2;
solRoads.clear();
solRoads.push_back(blockedRoad);
solRoads.push_back(blockedRoad2);
}
}
if (ll2 == currNode2) {
currNode2 = rr2;
} else {
currNode2 = ll2;
}
blockedRoad2 = prevRoad2[currNode2];
}
}
G[ll].push_back(make_pair(make_pair(rr, cost), blockedRoad));
G[rr].push_back(make_pair(make_pair(ll, cost), blockedRoad));
countEdges[ll][rr]++;
countEdges[rr][ll]++;
if (ll == currNode) {
currNode = rr;
} else {
currNode = ll;
}
blockedRoad = prevRoad[currNode];
}
if (SOL == 1000000000000000ll) {
cout << -1 << endl;
} else {
cout << SOL << endl;
cout << solRoads.size() << endl;
for (int i = 0; i < solRoads.size(); i++) {
cout << solRoads[i] << ' ';
}
cout << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int *a = new int[n]();
int b;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
vector<int> v;
int s = 0, i, t = 0, p = 0;
for (i = 1; s <= m; i++) {
if (a[p] == i) {
p++;
} else {
if (s + i > m)
break;
else {
s += i;
t++;
v.push_back(i);
}
}
}
cout << t << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, ans, res1, res2, l, r, mid;
cin >> a >> b;
mid = (a + b) / 2;
l = abs(mid - a);
r = abs(mid - b);
res1 = (l * (l + 1)) / 2;
res2 = (r * (r + 1)) / 2;
cout << res1 + res2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-12;
const long double PI = acos(-1);
const int MAXN = 100005;
int N;
long double A, X[MAXN], Y[MAXN];
bool check(long double m) {
long double u = m / 2;
long double v = sqrt(A * A - u * u);
vector<pair<long double, long double>> ev;
for (int i = 0; i < N; i++) {
long double x = 1, y = Y[i] / v, alpha;
if (X[i] != 0) {
x *= u / X[i], y *= u / X[i];
long double r = sqrt(x * x + y * y);
if (r < 1) continue;
alpha = acos(1 / r);
} else {
alpha = PI / 2;
}
long double base = atan2(y, x) - alpha;
if (base < 0) base += 2 * PI;
ev.push_back({base, base + 2 * alpha});
}
priority_queue<long double, vector<long double>, greater<long double>> pq;
sort(ev.begin(), ev.end());
for (int i = 0; i < 2; i++) {
for (int j = 0; j < ev.size(); j++) {
while (pq.size() && pq.top() < ev[j].first) pq.pop();
if (pq.size() && pq.top() < ev[j].second) return 1;
pq.push(ev[j].second);
ev[j].first += 2 * PI;
ev[j].second += 2 * PI;
}
}
return 0;
}
int main() {
cin >> N >> A;
for (int i = 0; i < N; i++) {
cin >> X[i] >> Y[i];
}
long double lo = 0, hi = 2 * A;
while (hi - lo > EPS) {
long double mid = (lo + hi) / 2;
(check(mid) ? hi : lo) = mid;
}
cout << fixed << setprecision(12);
cout << (lo + hi) / 2 << '\n';
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
const int N = 100;
const int S = 2505;
const int mod = int(1e9) + 7;
vector<vector<int>> f(N + 1, vector<int>(S));
f[0][0] = 1;
for (int i = 1; i <= N; i++) {
for (int s = 0; s < S; s++) {
int x = 0;
for (int j = 0; j <= 25; j++) {
if (s - j >= 0) {
x += f[i - 1][s - j];
x %= mod;
}
}
f[i][s] = x;
}
}
int T;
scanf("%i", &T);
while (T--) {
char word[101];
scanf("%s", word);
int n = strlen(word);
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (word[i] - 'a');
}
printf("%i\n", (f[n][sum] + mod - 1) % mod);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x = 0;
cin >> n >> k;
int* a = new int[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
if (a[i] + a[i + 1] < k) {
x += k - (a[i] + a[i + 1]);
a[i + 1] += k - (a[i] + a[i + 1]);
}
}
cout << x << endl;
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool rot(string a[], string c[], int n) {
string b[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) b[i][n - j - 1] = a[j][i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) a[i][j] = b[i][j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (a[i][j] != c[i][j]) return false;
}
return true;
}
bool fli(string s[], string s1[], int n) {
for (int i = 0; i < n; i++) reverse(s[i].begin(), s[i].end());
for (int i = 0; i < n; i++) {
if (s[i] != s1[i]) return false;
}
return true;
}
bool flh(string s[], string s1[], int n) {
string s2[n];
for (int i = 0; i < n; i++) s2[n - i - 1] = s[i];
for (int i = 0; i < n; i++) s[i] = s2[i];
for (int i = 0; i < n; i++) {
if (s[i] != s1[i]) return false;
}
return true;
}
int main() {
int n;
cin >> n;
string s[n], s1[n], cs[n], cs1[n], cs2[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
cs[i] = s[i];
cs1[i] = s[i];
cs2[i] = s[i];
}
for (int i = 0; i < n; i++) cin >> s1[i];
if (fli(cs, s1, n)) {
cout << "YES\n";
return 0;
}
if (flh(cs1, s1, n)) {
cout << "YES\n";
return 0;
}
bool a = fli(cs2, s1, n);
a = flh(cs2, s1, n);
for (int i = 0; i < 3; i++) {
if (rot(s, s1, n) || rot(cs, s1, n) || rot(cs1, s1, n) || rot(cs2, s1, n)) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double d, count;
int n;
cin >> n >> d;
double p[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
p[n - 1] = p[n - 1] - (abs(7 - d) + 1);
count = 1;
count += ceil(p[n - 1] / 7.0);
cout << count;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int t;
int odd = 0;
int even = 0;
scanf("%d", &t);
int tmp;
while (t--) {
scanf("%d", &tmp);
if (tmp % 2 == 0) {
even++;
} else {
odd++;
}
}
int anw = 0;
while (odd > 0) {
if (even) {
anw++;
even--;
odd--;
} else {
if (odd >= 3) {
anw++;
odd -= 3;
} else {
break;
}
}
}
printf("%d\n", anw);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[200009], n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++)
if (a[i] < a[i + 1] && a[i] < a[i - 1]) {
cout << "NO";
return 0;
}
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1000;
const long long INF64 = 1e18 + 1000;
const int N = 2 * 100 * 1000;
const int M = 1000;
const int MOD = 998244353;
const double EPS = 1e-9;
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
int f(int x) {
x++;
while (x % 10 == 0) {
x /= 10;
}
return x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < int(n); ++i) {
cin >> a[i];
}
int l = 0, r = n - 1;
int last = -1;
string s;
while (l <= r && l < n && r >= 0) {
if (a[l] < last && a[r] < last) {
break;
}
if (a[l] < a[r]) {
if (a[l] > last) {
s += 'L';
last = a[l];
l++;
} else {
s += 'R';
last = a[r];
r--;
}
} else {
if (a[r] > last) {
s += 'R';
last = a[r];
r--;
} else {
s += 'L';
last = a[l];
l++;
}
}
}
cout << s.size() << '\n';
cout << s << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int dp[2][maxn][maxn][11];
string s;
string t;
int n;
int m;
int k;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
cin >> s >> t;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int w = 1; w <= k; w++) {
dp[0][i][j][w] =
max(max(dp[1][i - 1][j - 1][w], dp[0][i - 1][j - 1][w]),
max(max(dp[0][i][j - 1][w], dp[1][i][j - 1][w]),
max(dp[1][i - 1][j][w], dp[0][i - 1][j][w])));
if (s[i - 1] == t[j - 1]) {
dp[1][i][j][w] = max(
dp[1][i - 1][j - 1][w - 1] + 1,
max(dp[0][i - 1][j - 1][w - 1] + 1, dp[1][i - 1][j - 1][w] + 1));
}
}
}
}
cout << max(dp[0][n][m][k], dp[1][n][m][k]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 500 + 3;
bool dp[M][M][M];
int n, k, a[M];
void make(int x) {
if (x > n) return;
for (int j = (0); j <= (k); j++) {
for (int i = (0); i <= (500); i++) dp[x][j][i] = dp[x - 1][j][i];
}
if (a[x] <= k) {
dp[x][a[x]][a[x]] = 1;
dp[x][a[x]][0] = 1;
for (int j = (a[x] + 1); j <= (k); j++) {
for (int y = (0); y <= (500); y++)
if (dp[x - 1][j - a[x]][y]) {
dp[x][j][a[x] + y] = 1;
dp[x][j][y] = 1;
dp[x][j][0] = 1;
}
}
}
make(x + 1);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = (1); i <= (n); i++) cin >> a[i];
if (a[1] <= k) dp[1][a[1]][a[1]] = 1, dp[1][a[1]][0] = 1;
make(2);
int sz = 0;
for (int i = (0); i <= (500); i++)
if (dp[n][k][i]) sz++;
cout << sz << endl;
for (int i = (0); i <= (500); i++)
if (dp[n][k][i]) cout << i << " ";
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 100;
const ll mod = 1e9+7;
ll fact[N];
ll qpow(ll a,ll n)
{
ll ans=1%mod;
while(n)
{
if(n&1)
ans=ans*a%mod;
a=a*a%mod;
n>>=1;
}
return ans;
}
ll inv(ll a)
{
return qpow(a,mod-2);
}
ll C(ll m,ll n)
{
return m<n?0:fact[m]*inv(fact[n])%mod*inv(fact[m-n])%mod;
}
ll lucas(ll m,ll n)
{
return n==0? 1%mod :lucas(m/mod,n/mod)*C(m%mod,n%mod)%mod;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
fact[1]=1;
fact[0]=1;
for(int i=2;i<=1e6;i++)
{
fact[i]=fact[i-1]*i%mod;
}
ll n;
cin>>n;
int temp=(int)ceil(n*1.0/2);
if(temp%2!=0)
temp++;
ll ans=0;
for(int x=temp;x<=n;x+=2)
{
ans=(ans+2*(lucas(x,n-x)%mod+lucas(x-1,n-x-1)%mod)*fact[x]%mod)%mod;
}
cout<<ans<<endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
cin.tie(nullptr)->sync_with_stdio(false);
long long n;
cin >> n;
vector<long long> a(n);
for (long long &x : a) {
cin >> x;
}
vector<vector<long long>> ans;
auto apply = [&](vector<long long> op) {
vector<long long> new_a;
for (long long i = (long long)op.size() - 1; i >= 0; i--) {
long long m = op[i];
vector<long long> tmp(a.end() - m, a.end());
a.resize(a.size() - m);
new_a.insert(new_a.end(), tmp.begin(), tmp.end());
}
a = new_a;
ans.push_back(op);
};
while (!is_sorted(a.begin(), a.end())) {
for (long long i = 2; i <= n; i++) {
long long cur_pos = find(a.begin(), a.end(), i) - a.begin();
long long pv_pos = find(a.begin(), a.end(), i - 1) - a.begin();
if (cur_pos < pv_pos) {
vector<long long> op;
long long lm = pv_pos;
while (a[lm - 1] == a[lm] - 1) lm--;
if (cur_pos != 0) op.push_back(cur_pos);
op.push_back(lm - cur_pos);
op.push_back(pv_pos - lm + 1);
if (pv_pos != n - 1) op.push_back(n - 1 - pv_pos);
apply(op);
}
}
}
cout << ans.size() << "\n";
for (auto ls : ans) {
cout << ls.size() << " ";
for (long long x : ls) {
cout << x << " ";
}
cout << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> f(6, false);
int main() {
long long n;
unsigned long long x = 1;
cin >> n;
for (int i = n - 4; i <= n; i++) {
x *= i * i;
for (int j = 1; j <= 5; j++) {
if (!f[j] && x % j == 0) x /= j, f[j] = true;
}
}
cout << x;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, b[66], l, r;
long long cnt(long long k) {
long long ans = 0;
while (k % 2 == 0) k /= 2, ans++;
return ans;
}
int main() {
cin >> n >> l >> r;
long long nn = n;
long long i;
for (i = 0; nn; i++, nn /= 2) b[i] = nn % 2;
reverse(b, b + i);
long long ans = 0;
for (long long i = l; i <= r; i++) {
long long x = cnt(i);
ans += b[x];
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
char s[1000005], t[1000005];
int pre[1000005][2], p2[1000005][2];
int jj0[1000005], jj1[1000005];
int main() {
ios::sync_with_stdio(false);
cin >> s + 1 >> t + 1;
for (int i = 1; s[i]; i++) {
if (s[i] > 'A') {
pre[i][s[i] - 'A' - 1]++;
jj0[i] = 0;
} else
jj0[i] = jj0[i - 1] + 1;
pre[i][0] += pre[i - 1][0];
pre[i][1] += pre[i - 1][1];
}
for (int i = 1; t[i]; i++) {
if (t[i] > 'A') {
p2[i][t[i] - 'A' - 1]++;
jj1[i] = 0;
} else
jj1[i] = jj1[i - 1] + 1;
p2[i][0] += p2[i - 1][0];
p2[i][1] += p2[i - 1][1];
}
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int l1, l2, r1, r2;
cin >> l1 >> r1 >> l2 >> r2;
int c1 = 0, c2 = 0;
c1 = pre[r1][0] - pre[l1 - 1][0] + pre[r1][1] - pre[l1 - 1][1];
c2 = p2[r2][0] - p2[l2 - 1][0] + p2[r2][1] - p2[l2 - 1][1];
if (c1 > c2) {
cout << 0;
} else if (c1 == c2 && c1 == 0) {
int len1 = r1 - l1 + 1;
int len2 = r2 - l2 + 1;
if (len1 < len2 || (len1 - len2) % 3)
cout << 0;
else
cout << 1;
} else if ((c2 - c1) % 2)
cout << 0;
else if (jj0[r1] < jj1[r2] || (((jj0[r1] - jj1[r2]) % 3) && (c1 == c2)) ||
((c1 == 0) && ((jj0[r1] - jj0[l1 - 1]) <= jj1[r2])))
cout << 0;
else
cout << 1;
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool check(vector<string> &v, map<string, vector<string> > &mp) {
for (int i = 0; i < v.size(); i++) {
if (mp.find(v[i]) != mp.end()) {
auto it = mp.find(v[i]);
vector<string> v1 = it->second;
for (int j = 0; j < v1.size(); j++) {
for (int k = 0; k < v.size(); k++) {
if (v1[j] == v[k]) return false;
}
}
}
}
return true;
}
int main() {
int n, m;
cin >> n >> m;
vector<string> v, v_max;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
v.push_back(s);
}
map<string, vector<string> > mp;
int mx = 0;
for (int i = 1; i <= m; i++) {
string s, t;
cin >> s >> t;
mp[s].push_back(t);
}
int counter = (1 << n) - 1;
for (int c = 0; c <= counter; c++) {
vector<string> v1;
for (int j = 0; j < v.size(); j++) {
if (c & (1 << j)) v1.push_back(v[j]);
}
if (check(v1, mp)) {
if (v1.size() > mx) {
mx = v1.size();
v_max = v1;
}
}
}
sort(v_max.begin(), v_max.end());
cout << mx << "\n";
for (int i = 0; i < v_max.size(); i++) cout << v_max[i] << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(NULL), cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
string c;
cin >> c;
vector<int> isp(27, 0);
for (int i = 0; i < c.length(); ++i) {
isp[c[i] - 'a']++;
}
for (int i = 0; i < 26; ++i) {
if (isp[i] % n != 0) {
cout << "-1\n";
return 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 26; j++) {
if (isp[j] != 0) {
for (int r = 0; r < (isp[j] / n); r++) {
cout << (char)(j + 'a');
}
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int i = 1;
while (m >= i) {
m = m - i;
i++;
if (i > n) i = 1;
}
cout << m;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char ch;
bool flag = false;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') flag = true;
for (x = 0; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
x = flag ? -x : x;
}
const int maxn = 1010;
const int mod = 1e9 + 7;
const int MOD = 1e9 + 7;
const int maxm = 2e6 + 10;
int k, pa, pb;
int dp[maxn][maxn];
long long invv[maxm];
void init() {
memset(dp, -1, sizeof(dp));
invv[1] = 1;
for (int i = 2; i < maxm; i++)
invv[i] = 1LL * (mod - mod / i) * invv[mod % i] % mod;
}
int pow_mod(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = (1LL * res * a) % MOD;
b >>= 1;
a = (1LL * a * a) % MOD;
}
return res;
}
int inv(int x) { return pow_mod(x, MOD - 2); }
int go(int i, int j) {
if (i + j >= k) {
return dp[i][j] = (i + j + 1LL * pa * invv[pb] % mod) % mod;
} else if (dp[i][j] != -1)
return dp[i][j];
else
return dp[i][j] = (1LL *
((1LL * pa * go(i + 1, j)) % mod +
(1LL * pb * go(i, j + i)) % mod) *
invv[pa + pb]) %
mod;
}
int main() {
cin >> k >> pa >> pb;
init();
cout << go(1, 0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
string ans = "YES";
bool flag = false;
for (int i = 0; i < n - 1; i++) {
if (arr[i] >= arr[i + 1] && flag == false) {
if (arr[i + 1] < i + 1) {
flag = true;
}
}
if (flag) {
if (arr[i] < n - i - 1) {
ans = "NO";
break;
}
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, k;
vector<int> v, h, m;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
h.push_back(x);
}
sort(v.begin(), v.end());
k = 0;
for (int j = n - 1; j >= 0; j--) {
for (int i = n - 1; i >= 0; i--) {
if (v[j] == h[i]) {
h[i] = -1;
m.push_back(i + 1);
k++;
break;
}
}
}
int y = 0;
x = 0;
for (int i = n - 1; i >= 0; i--) {
x += ((y * v[i]) + 1);
y++;
}
cout << x << endl;
for (int i = 0; i < n; i++) {
cout << m[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, t;
long long f[62][62];
int divi(long long x) {
int rn = 0;
while (x > 1) x /= 2, rn++;
return rn;
}
long long solve(long long n, long long t) {
if (n <= 3) {
int cnt = 0;
if (n >= 1 && t == 1) cnt++;
if (n >= 2 && t == 2) cnt++;
if (n >= 3 && t == 1) cnt++;
return cnt;
}
long long a = 1, b, e = 1, rn = 0;
for (;;) {
b = a, a = a * 2 + 3;
if (a + 3 <= n)
e++;
else {
if (a + 1 <= n && ((long long)1 << e + 1) == t) rn++;
if (a + 2 <= n && t == 1) rn++;
if (a + 3 <= n && t == 2) rn++;
n = min(a, n);
break;
}
}
rn += f[e][divi(t)];
if (t == 1 || t == 2) rn++;
if (t % 2 == 0) rn += solve(n - b - 3, t / 2);
return rn;
}
int main() {
cin >> n >> t;
if (((long long)1 << divi(t)) != t) {
cout << 0 << endl;
return 0;
}
f[1][0] = 1, f[1][1] = 1;
for (int i = 2; i <= 60; i++)
for (int j = 0; j <= i; j++) {
f[i][j] = f[i - 1][j] + (j ? f[i - 1][j - 1] : 0);
if (j == 0 || j == 1) f[i][j]++;
}
cout << solve(n, t) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int T,n;
const int maxn=200;
int a[maxn],b[maxn],t[maxn];
int main(){
scanf("%d",&T);
while(T--){
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d%d",&a[i],&b[i]);
for(int i=1;i<=n;i++) scanf("%d",&t[i]);
int ans=0;
for(int i=1;i<=n;i++){
ans+=(t[i]+(a[i]-b[i-1]));
//printf("%d ",ans);
int temp=(b[i]-a[i]+1)/2;
if(i!=n){
if(ans+temp<b[i]) ans+=(b[i]-a[i]);
else ans+=temp;
}
//printf("%d\n",ans);
}
printf("%d\n",ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, x, y = 0;
cin >> n >> a >> b;
while ((n - y * b) >= 0) {
x = n - y * b;
if (x % a == 0) {
x = x / a;
cout << "YES\n" << x << " " << y;
return 0;
}
y++;
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int lim = 2500 + 7;
vector<int> r;
vector<int> color;
bool cmp(int a, int b) { return r[a] < r[b]; }
int find_ind(int ind_old, const vector<int> &a) {
for (int i = 0; i < (int)a.size(); i++) {
if (a[i] == ind_old) {
return i;
}
}
return -1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k, s;
cin >> n >> s >> k;
s--;
r.resize(n);
for (auto &t : r) {
cin >> t;
}
color.resize(n);
for (auto &t : color) {
char c;
cin >> c;
if (c == 'R') {
t = 0;
} else if (c == 'G') {
t = 1;
} else {
t = 2;
}
}
vector<int> a(n);
for (int i = 0; i < n; i++) {
a[i] = i;
}
sort(a.begin(), a.end(), cmp);
int start = find_ind(s, a);
assert(start != -1);
vector<vector<vector<int>>> dp(n,
vector<vector<int>>(lim, vector<int>(3, inf)));
for (int i = 0; i < n; i++) {
if (r[a[i]] < lim) {
int delta = abs(a[start] - a[i]);
dp[i][r[a[i]]][color[a[i]]] = delta;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < lim; j++) {
for (int clr = 0; clr < 3; clr++) {
for (int next = 0; next < n; next++) {
if (j + r[a[next]] < lim && color[a[next]] != clr &&
r[a[next]] > r[a[i]]) {
int delta = abs(a[i] - a[next]);
dp[next][j + r[a[next]]][color[a[next]]] =
min(dp[next][j + r[a[next]]][color[a[next]]],
dp[i][j][clr] + delta);
}
}
}
}
}
int best = inf;
for (int i = 0; i < n; i++) {
for (int j = lim - 1; j >= k; j--) {
for (int clr = 0; clr < 3; clr++) {
best = min(best, dp[i][j][clr]);
}
}
}
if (best == inf) {
cout << "-1\n";
} else {
cout << best << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long> spf(2750132, 0);
vector<long long> prime;
vector<bool> isprime(2750132, true);
unordered_map<long long, long long> mp;
long long i, j, c = 0;
isprime[0] = isprime[1] = false;
for (i = 2; i <= 2750131; i++) {
if (isprime[i]) {
prime.push_back(i);
c++;
mp[i] = c;
spf[i] = i;
}
for (j = 0;
j < prime.size() && prime[j] * i < 2750132 && prime[j] <= spf[i];
j++) {
isprime[i * prime[j]] = false;
spf[i * prime[j]] = prime[j];
}
}
long long n;
cin >> n;
long long k = 2 * n;
vector<long long> a(k);
unordered_map<long long, long long> m;
for (i = 0; i < k; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a.begin(), a.end());
vector<long long> ans;
for (i = k - 1; i >= 0; i--) {
if (m[a[i]] != 0) {
if (isprime[a[i]] == true) {
m[mp[a[i]]]--;
m[a[i]]--;
ans.push_back(mp[a[i]]);
} else {
long long h = spf[a[i]];
long long g = a[i] / spf[a[i]];
ans.push_back(a[i]);
m[g]--;
m[a[i]]--;
}
}
}
for (i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (a[i] == 1) continue;
int pos = lower_bound(a + 1, a + n + 1, 2 * a[i]) - a;
if (a[pos - 1] > a[i]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
int main() {
int a, n, m;
cin >> a >> n >> m;
vector<int> rain(a + 1);
vector<pair<int, int>> umb(a + 1, make_pair(INF, -1));
vector<int> costs(m);
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
for (int j = l; j < r; ++j) rain[j] = 1;
}
for (int i = 0; i < m; ++i) {
int x, p;
cin >> x >> p;
costs[i] = p;
umb[x] = min(umb[x], make_pair(p, i));
}
vector<vector<int>> dp(a + 1, vector<int>(m + 1, INF));
dp[0][m] = 0;
for (int i = 0; i < a; ++i) {
for (int j = 0; j <= m; ++j) {
if (dp[i][j] == INF) continue;
if (rain[i] == 0) dp[i + 1][m] = min(dp[i + 1][m], dp[i][j]);
if (j < m) dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + costs[j]);
if (umb[i].first != INF)
dp[i + 1][umb[i].second] =
min(dp[i + 1][umb[i].second], dp[i][j] + umb[i].first);
}
}
int ans = INF;
for (int i = 0; i <= m; ++i) ans = min(ans, dp[a][i]);
if (ans == INF) ans = -1;
cout << ans << endl;
return 0;
}
| 6 |
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
const int Maxpw=66000;
vector<int>e[Maxpw],cur,nxt;
int vis[Maxpw],id[Maxpw],p[Maxpw],col[Maxpw];
int m,n,T;
inline bool check(int x)
{
while(!(x&1))
x>>=1;
return x!=1;
}
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d",&m);
n=1<<m;
for(int i=0;i<n;++i)
e[i].clear(),
id[i]=p[i]=col[i]=vis[i]=0;
for(int i=1,u,v;i<=m*(1<<(m-1));++i)
scanf("%d%d",&u,&v),
e[u].emplace_back(v),
e[v].emplace_back(u);
vis[0]=2;
int pw=1,cnt=1;
cur.clear(),nxt.clear();
for(auto i:e[0])
id[i]=pw,
vis[i]=1,
cur.emplace_back(i),
pw<<=1,
++cnt;
while(cnt<n)
{
for(auto i:cur)
vis[i]=2;
nxt.clear();
for(auto i:cur)
for(auto j:e[i])
if(vis[j]!=2)
{
id[j]|=id[i];
if(vis[j]==0)
vis[j]=1,
++cnt,
nxt.emplace_back(j);
}
cur=nxt;
}
for(int i=0;i<n;++i)
p[id[i]]=i;
for(int i=0;i<n;++i)
printf("%d ",p[i]);
puts("");
if(check(m))
{
puts("-1");
continue;
}
for(int i=0;i<n;++i)
{
int s=0;
for(int j=0;j<m;++j)
if(i&(1<<j))
s^=j;
col[p[i]]=s;
}
for(int i=0;i<n;++i)
printf("%d ",col[i]);
puts("");
}
} | 9 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> sum(100002);
int main() {
int t;
long long n, k;
cin >> t;
sum[0] = 0;
for (int i = 1; i < 100002; i++) sum[i] = i + sum[i - 1];
while (t--) {
cin >> n >> k;
int idx = lower_bound(sum.begin(), sum.end(), k) - sum.begin();
int f_idx, s_idx;
if (sum[idx] != k) {
idx--;
f_idx = n - 2 - idx;
s_idx = n - (k - sum[idx]);
} else {
f_idx = n - 1 - idx;
s_idx = f_idx + 1;
}
for (int i = 0; i < n; i++) {
if (i == f_idx || (s_idx) == i)
cout << "b";
else
cout << "a";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
const int top = 2015;
bitset<top> bit[top], A[top];
int n, pos[top];
char str[701];
int main() {
memset(pos, 255, sizeof(pos));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", str);
int len = strlen(str);
for (int j = 0; j <= len - 1; j++) str[j] -= '0';
int st = 0;
int ls = 0;
int last, bc;
while (st < len) {
while (str[st] == 0 && st < len) st++;
bc = 0;
for (int j = st; j <= len - 1; j++) {
last = str[j];
str[j] = (bc * 10 + str[j]) >> 1;
bc = (bc * 10 + last) & 1;
}
bit[i][ls++] = bc;
}
A[i][i] = 1;
int flag = 1;
for (int j = 0; j <= top - 1; j++)
if (bit[i][j]) {
if (pos[j] == -1) {
pos[j] = i;
flag = 0;
break;
}
bit[i] ^= bit[pos[j]];
A[i] ^= A[pos[j]];
}
if (!flag)
puts("0");
else {
A[i][i] = 0;
printf("%d ", A[i].count());
for (int j = 1; j <= top - 1; j++)
if (A[i][j]) printf("%d ", j - 1);
puts("");
}
}
fclose(stdin);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 100;
int cups[MAXN];
int main() {
std::ios::sync_with_stdio(false);
int n, w;
double x, ans;
cin >> n >> w;
x = (double)w / (3 * n);
int n2 = n << 1;
for (int i = 0; i < n2; ++i) {
cin >> cups[i];
}
sort(cups, cups + n2);
x = min(x, (double)cups[0]);
x = min(x, cups[n] / 2.0);
ans = x * 3 * n;
cout.precision(std::numeric_limits<double>::digits10);
cout << fixed << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct __ {
int x, y, l;
bool operator<(const __ &ob) const {
if (x != ob.x) return x < ob.x;
if (y != ob.y) return y < ob.y;
return l < ob.l;
}
};
set<__> xxx;
struct _ {
int x, y;
};
vector<_> s[400010];
int top;
struct node {
int fa, w, dep;
} a[100010];
struct oper {
int over, pos;
node val;
} sta[400010];
int fail;
void update(int L, int R, _ c, int l, int r, int rt) {
if (L <= l && r <= R) {
s[rt].push_back(c);
return;
}
int m = l + r >> 1;
if (m >= L) update(L, R, c, l, m, rt << 1);
if (m < R) update(L, R, c, m + 1, r, rt << 1 | 1);
}
node find(int x) {
if (a[x].fa == x) return a[x];
node tmp = find(a[x].fa);
tmp.w ^= a[x].w;
return tmp;
}
int ans[100010];
void dfs(int l, int r, int rt) {
int i, optop = 0;
node tmpx, tmpy;
for (i = 0; i < s[rt].size(); i++) {
tmpx = find(s[rt][i].x);
tmpy = find(s[rt][i].y);
if (tmpx.fa == tmpy.fa) {
if (tmpx.w == tmpy.w) {
sta[top++].over = 1;
fail++;
optop++;
break;
}
} else {
int x = tmpx.fa, y = tmpy.fa;
sta[top++] = (oper){0, x, a[x]}, optop++;
sta[top++] = (oper){0, y, a[y]}, optop++;
if (tmpx.dep < tmpy.dep) {
tmpx.fa = y;
tmpx.w ^= 1 ^ tmpy.w;
tmpy.dep = max(tmpy.dep, tmpx.dep + 1);
tmpy.w = 0;
} else {
tmpy.fa = x;
tmpy.w ^= 1 ^ tmpx.w;
tmpx.dep = max(tmpx.dep, tmpy.dep + 1);
tmpx.w = 0;
}
a[x] = tmpx, a[y] = tmpy;
}
}
int m = l + r >> 1;
if (l == r) {
ans[l] = !fail;
} else {
if (!fail) {
dfs(l, m, rt << 1);
dfs(m + 1, r, rt << 1 | 1);
}
}
while (optop--) {
if (sta[--top].over) {
fail--;
} else {
a[sta[top].pos] = sta[top].val;
}
}
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
int i, x, y;
for (i = 1; i <= n; i++) {
a[i] = (node){i, 0, 1};
}
set<__>::iterator tmp;
for (i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
tmp = xxx.lower_bound((__){x, y, 0});
if (tmp == xxx.end() || (tmp->x != x || tmp->y != y)) {
xxx.insert((__){x, y, i});
} else {
update(tmp->l, i - 1, (_){x, y}, 1, q, 1);
xxx.erase(tmp);
}
}
while (!xxx.empty()) {
tmp = xxx.begin();
update(tmp->l, q, (_){tmp->x, tmp->y}, 1, q, 1);
xxx.erase(tmp);
}
dfs(1, q, 1);
for (i = 1; i <= q; i++) {
if (ans[i])
puts("YES");
else
puts("NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
inline long long pw2(int x) { return 1ll * x * x; }
typedef class SplayNode {
public:
int sz, vsz;
long long sz2, vsz2;
SplayNode *fa, *ch[2];
SplayNode() : sz(0), vsz(0) {}
bool isroot() { return !fa || (fa->ch[0] != this && fa->ch[1] != this); }
int which() { return isroot() ? -1 : fa->ch[1] == this; }
void upd(SplayNode* q, int sgn = 1) {
sz += sgn * q->sz;
sz2 += sgn * pw2(q->sz);
}
void push_up() {
sz = vsz + 1, sz2 = vsz2;
if (ch[0]) upd(ch[0]);
if (ch[1]) upd(ch[1]);
}
} SplayNode;
typedef class LinkCutTree {
public:
long long ans;
int* fa;
vector<int> P;
SplayNode* pool;
bool* havefa;
void init(int n, int* fa, int* sz) {
this->fa = fa;
pool = new SplayNode[(n + 1)];
havefa = new bool[(n + 1)];
pool[0].ch[0] = pool[0].ch[1] = NULL;
pool[0].fa = NULL;
pool[0].sz = n + 1, pool[0].vsz = n;
for (int i = 0; i <= n; i++) {
pool[i].sz2 = 0;
havefa[i] = i != 0;
}
for (int i = 1; i <= n; i++) {
pool[i].ch[0] = pool[i].ch[1] = NULL;
pool[i].fa = pool + fa[i];
pool[i].sz = sz[i], pool[i].vsz = sz[i] - 1;
pool[i].fa->sz2 += pw2(sz[i]);
}
for (int i = 0; i <= n; i++) {
pool[i].vsz2 = pool[i].sz2;
}
ans = 1ll * n * n;
}
void rotate(SplayNode* p) {
int d = p->which();
int df = p->fa->which();
SplayNode* fa = p->fa;
fa->ch[d] = p->ch[d ^ 1];
p->ch[d ^ 1] = fa;
if (~df) fa->fa->ch[df] = p;
p->fa = fa->fa;
fa->fa = p;
if (fa->ch[d]) fa->ch[d]->fa = fa;
fa->push_up();
p->push_up();
}
void splay(SplayNode* p) {
for (; !p->isroot(); rotate(p)) {
if (!p->fa->isroot()) {
rotate((p->which() == p->fa->which()) ? (p->fa) : (p));
}
}
}
void access(SplayNode* p) {
SplayNode* q = NULL;
while (p) {
splay(p);
if (p->ch[1]) {
p->vsz += p->ch[1]->sz;
p->vsz2 += pw2(p->ch[1]->sz);
}
if (q) {
p->vsz -= q->sz;
p->vsz2 -= pw2(q->sz);
}
p->ch[1] = q;
q = p, p = p->fa;
}
}
long long query(SplayNode* p) {
access(p);
splay(p);
if (!p->ch[0]) return p->sz2;
while (p->ch[0]) p = p->ch[0];
splay(p);
return pw2(p->ch[1]->sz);
}
long long query(int x) { return query(pool + x); }
void link(SplayNode* p, SplayNode* q) {
access(p);
splay(p);
access(q);
splay(q);
p->fa = q;
q->upd(p);
q->vsz += p->sz;
q->vsz2 += pw2(p->sz);
}
void link_fa(int p) {
ans -= query(p);
if (havefa[fa[p]]) ans -= query(fa[p]);
link(pool + p, pool + fa[p]);
ans += query(p);
havefa[p] = true;
}
void cut(SplayNode* p) {
access(p);
splay(p);
assert(p->ch[0]);
SplayNode* q = p->ch[0];
p->upd(q, -1);
p->ch[0] = q->fa = NULL;
}
void cut(int p) {
ans -= query(p);
cut(pool + p);
ans += query(p);
if (havefa[fa[p]]) ans += query(fa[p]);
havefa[p] = false;
P.push_back(p);
}
void reverse(int p) {
if (havefa[p]) {
cut(p);
} else {
link_fa(p);
}
}
void reset() {
for (auto p : P) {
if (!havefa[p]) {
link_fa(p);
}
}
P.clear();
}
} LinkCutTree;
typedef class Event {
public:
int t, p;
Event(int t, int p) : t(t), p(p) {}
} Event;
int n, m;
long long res[N];
LinkCutTree lct;
vector<int> G[N];
vector<Event> E[N];
int c[N], fa[N], sz[N];
void dfs(int p, int fa) {
::fa[p] = fa;
sz[p] = 1;
for (auto e : G[p]) {
if (e ^ fa) {
dfs(e, p);
sz[p] += sz[e];
}
}
}
void solve(vector<Event>& E) {
long long lastans = lct.ans;
res[0] += lastans;
for (auto e : E) {
int t = e.t;
int p = e.p;
res[t] -= lastans;
lct.reverse(p);
res[t] += (lastans = lct.ans);
}
lct.reset();
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", c + i);
E[c[i]].emplace_back(0, i);
}
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 0);
for (int i = 1, p, nc; i <= m; i++) {
scanf("%d%d", &p, &nc);
E[c[p]].emplace_back(i, p);
E[c[p] = nc].emplace_back(i, p);
}
lct.init(n, fa, sz);
for (int i = 1; i <= n; i++) {
solve(E[i]);
}
long long n3 = 1ll * n * n * n, ans = 0;
for (int i = 0; i <= m; i++) {
ans += res[i];
printf("%lld\n", n3 - ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, d, x, y, v, r;
int main() {
cin >> n >> d;
for (int i = 2 * n - 2; i >= 0; i -= 2) {
r = 4 * v | (d >> i) & 3;
x = (x << 1) | (0x936c >> r) & 1;
y = (y << 1) | (0x39c6 >> r) & 1;
v = (0x3e6b94c1 >> 2 * r) & 3;
}
cout << x << " " << y;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1LL << 31) - 1;
const long long int LINF = (1LL << 62) - 1;
const int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};
const int MOD = (int)(1e9) + 7;
const int NMAX = 100000 + 5;
const int MMAX = 100000 + 5;
const int KMAX = 100000 + 5;
const int PMAX = 100000 + 5;
const int LMAX = 100000 + 5;
const int VMAX = 100000 + 5;
int N, best;
int V[NMAX];
int T[NMAX];
int F1[NMAX];
int F2[NMAX];
int F[NMAX];
int sol[NMAX];
int main() {
int i, j;
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%d", &V[i]);
for (i = 1; i <= N; i++) {
T[i] = INF;
j = lower_bound(T + 1, T + i + 1, V[i]) - T;
T[j] = V[i];
F1[i] = j;
best = max(best, j);
}
for (i = N; i >= 1; i--) {
T[N - i + 1] = INF;
j = lower_bound(T + 1, T + N - i + 2, -V[i]) - T;
T[j] = -V[i];
F2[i] = j;
}
for (i = 1; i <= N; i++)
if (F1[i] + F2[i] - 1 != best)
sol[i] = 1;
else {
sol[i] = 2;
F[F1[i]]++;
}
for (i = 1; i <= N; i++)
if (sol[i] == 2 && F[F1[i]] == 1) sol[i] = 3;
for (i = 1; i <= N; i++) printf("%d", sol[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
inline long long rd() {
long long x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * w;
}
int to[N << 2], nt[N << 2], hd[N << 1], dg[N << 1], tot = 1;
void add(int x, int y) {
++tot, to[tot] = y, nt[tot] = hd[x], hd[x] = tot, ++dg[x];
++tot, to[tot] = x, nt[tot] = hd[y], hd[y] = tot, ++dg[y];
}
bool cs[N << 2], ban[N << 2], v[N << 1];
int n, m, a[N][2], b[N << 1];
void dfs(int x) {
v[x] = 1;
for (int &i = hd[x]; i; i = nt[i]) {
if (ban[i]) continue;
int y = to[i];
ban[i] = ban[i ^ 1] = 1, cs[i] = 1;
dfs(y);
}
}
int main() {
n = rd();
for (int i = 1; i <= n; ++i)
a[i][0] = b[i * 2 - 1] = rd(), a[i][1] = b[i * 2] = rd() + 1;
sort(b + 1, b + n + n + 1), m = unique(b + 1, b + n + n + 1) - b - 1;
for (int i = 1; i <= n; ++i) {
a[i][0] = lower_bound(b + 1, b + m + 1, a[i][0]) - b;
a[i][1] = lower_bound(b + 1, b + m + 1, a[i][1]) - b;
add(a[i][0], a[i][1]);
}
for (int i = 1, la = 0; i <= m; ++i)
if (dg[i] & 1) {
if (!la)
la = i;
else
add(la, i), la = 0;
}
for (int i = 1; i <= m; ++i)
if (!v[i]) dfs(i);
for (int i = 1; i <= n; ++i) printf("%d ", cs[i << 1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T re() {
T N = 0;
char c = getchar();
bool neg = 0;
for (; c < '0' || c > '9'; c = getchar()) neg |= c == '-';
for (; c >= '0' && c <= '9'; c = getchar()) N = (N << 3) + (N << 1) + c - '0';
return neg ? -N : N;
}
const int MX = 1e5;
const int SQRTN = 320;
int n, q;
int p[MX + 5];
int rev[MX + 5];
int a[MX + 5];
int main() {
n = re<int>();
q = re<int>();
for (int i = 1; i <= n; i++) rev[p[i] = re<int>()] = i;
for (int i = 1; i <= n; i++) {
a[i] = i;
for (int j = 0; j < SQRTN; j++) a[i] = p[a[i]];
}
for (int qq = 0, t, x, y; qq < q; qq++) {
t = re<int>();
x = re<int>();
y = re<int>();
if (t == 1) {
swap(rev[p[x]], rev[p[y]]);
swap(p[x], p[y]);
for (int ff = 0, u; ff < 2; ff++) {
u = x;
for (int i = 0; i < SQRTN; i++) u = p[u];
for (int i = 0; i < SQRTN; i++) {
a[x] = u;
x = rev[x];
u = rev[u];
}
swap(x, y);
}
} else {
for (; y >= SQRTN; y -= SQRTN) x = a[x];
for (; y > 0; --y) x = p[x];
printf("%d\n", x);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int id, flag, number;
} f[100000 + 2];
int cmp1(struct node f1, struct node f2) {
if (f1.number > f2.number || f1.number == f2.number && f1.id < f2.id)
return 1;
return 0;
}
int cmp2(struct node f1, struct node f2) {
if (f1.number > f2.number || f1.number == f2.number && f1.id > f2.id)
return 1;
return 0;
}
int cmp3(struct node f1, struct node f2) { return f1.id < f2.id; }
void solve(int n, int k, int flag) {
if (flag == 1)
sort(f, f + n, cmp1);
else
sort(f, f + n, cmp2);
for (int i = 0; i < k; i++) f[i].flag = flag;
for (int j = k; j < n; j++) f[j].flag = 3 - flag;
sort(f, f + n, cmp3);
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
int k1, k2, flag = 2;
scanf("%d%d", &k1, &k2);
if (k1 < k2) {
int t = k1;
k1 = k2;
k2 = t;
flag = 1;
}
for (int i = 0; i < n; i++) {
scanf("%d", &f[i].number);
f[i].id = i;
}
if (k1 == k2) {
for (int k = 0; k < k1; k++) printf("%d ", 1);
for (int z = 0; z < k1; z++) {
printf("%d", 2);
if (z == k1 - 1)
printf("\n");
else
printf(" ");
}
continue;
}
solve(n, k2, flag);
for (int j = 0; j < n; j++) {
if (j > 0) printf(" ");
printf("%d", f[j].flag);
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1001, oo = ~0U >> 1;
int n;
long long A[maxn];
long long ans = oo;
void check(int l, int r) {
long long sum1, sum2, now, res;
int i;
sum1 = 0, sum2 = 0;
now = A[l - 1] - 1;
for (i = l; i <= r; ++i) sum1 += now / A[i], now %= A[i];
res = now = A[l - 1] - 1 - now + A[r], ++sum1;
for (i = 1; i <= n; ++i) sum2 += now / A[i], now %= A[i];
if (sum1 < sum2 && res < ans) {
ans = res;
}
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%I64d", &A[i]);
for (i = 2; i <= n; ++i)
for (j = i; j <= n; ++j) check(i, j);
if (ans < oo)
printf("%I64d", ans);
else
printf("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t) {
t--;
int n, k;
cin >> n >> k;
string s;
cin >> s;
sort(s.begin(), s.end());
if (s[0] != s[k - 1] || k == n)
cout << s[k - 1];
else if (s[k] != s[n - 1])
for (int i = k - 1; i < n; i++) cout << s[i];
else {
cout << s[k - 1];
int t = (n - 1) / k;
for (int i = 0; i < t; i++) cout << s[n - 1];
}
cout << endl;
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.