solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long d = n / 2 / (k + 1);
long long c = k * d;
long long w = n - c - d;
cout << d << " " << c << " " << w;
}
int main() {
int T = 1;
while (T--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n--;
cout << "1 1" << endl;
for (int i = 0; i < n / 2 + (n % 2 || n % 12 == 6 || n % 12 == 10); i++)
cout << (!(i % 6) || i % 2) << ' ' << 2 + i / 6 * 4 + (i % 6 + 1) / 2
<< endl;
for (int i = 0; i < n / 2 - (n % 12 == 6 || n % 12 == 10); i++)
cout << 2 + i / 6 * 4 + (i % 6 + 1) / 2 << ' ' << (!(i % 6) || i % 2)
<< endl;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000;
const int M = 50000;
char str[N];
int cntS[M];
int main() {
int a;
scanf("%d", &a);
scanf(" %s", str);
int len = strlen(str);
for (int i = 0; i < len; i++) {
int curSum = 0;
for (int s = i; s < len; s++) {
curSum += str[s] - '0';
cntS[curSum]++;
}
}
long long ans = 0;
if (a == 0) {
long long allC = (long long)len * (long long)(len + 1) / (long long)2;
long long allZ = cntS[0];
ans = 2 * (allC - allZ) * allZ + allZ * allZ;
printf("%lld", ans);
return 0;
}
for (int i = 0; i < len; i++) {
int curSum = 0;
for (int s = i; s < len; s++) {
curSum += str[s] - '0';
if (curSum == 0) continue;
int t = a / curSum;
if (t * curSum == a && t < M) {
ans += cntS[t];
}
}
}
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
map<long long int, long long int> m;
vector<long long int> v, v1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, x, y, t, k;
string s;
cin >> s;
long long int sum = 0;
for (long long int i = 0; i < s.length() - 1; i++) {
if (s[i] == s[i + 1] and s[i] == 'v') {
sum++;
}
if (s[i] == 'o') {
v.push_back(sum);
}
}
long long int ans = 0;
for (long long int i = 0; i < v.size(); i++) {
ans += ((sum - v[i]) * (v[i]));
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
int ok = 0, wa = 0;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
if (s.length() % 2) {
ok = 1;
} else {
int a = 0;
for (int j = 0; j < s.length(); j++) {
if ((s[j] - '0') & 1) {
a++;
}
}
if (a & 1) {
if (wa == 1)
wa--;
else
wa = 1;
}
}
}
if (wa == 1 && ok == 0) {
printf("%d\n", n - 1);
} else {
printf("%d\n", n);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, r, l;
int pos[1000010];
int num[1000010];
int b[1000010];
long long ans = 0;
int lowbit(int o) { return o & -o; }
int query(int o) {
int res = 0;
while (o > 0) res += b[o], o -= (o & -o);
return res;
}
void insert(int o) {
while (o <= n) b[o]++, o += (o & -o);
}
int main() {
memset(num, false, sizeof(num));
memset(b, 0, sizeof(b));
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
pos[a] = i;
}
for (int i = 0; i < k; i++) {
scanf("%d", &a);
num[a] = 1;
}
set<int> position;
set<int>::iterator it;
for (int i = 1; i <= n; i++) {
if (num[i] == 1) {
position.insert(pos[i]);
} else {
int r, l;
it = position.lower_bound(pos[i]);
if (it == position.begin()) {
if (position.size() == 0) {
r = n;
l = 1;
} else {
l = 1;
r = (*it) - 1;
}
} else if (it == position.end()) {
l = (*(--it)) + 1;
r = n;
} else {
r = (*it) - 1;
l = (*(--it)) + 1;
}
ans += r - l + 1;
ans -= query(r) - query(l - 1);
insert(pos[i]);
}
}
printf("%lld\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int inv = 1000000000;
const int minv = -inv;
const pair<int, int> ABSENT = pair<int, int>(-1, -1);
struct node {
int lr, rr, ct, id;
node* lc;
node* rc;
node() {}
node(int lr_, int rr_, int ct_, int id_, node* lc_, node* rc_) {
lr = lr_;
rr = rr_;
ct = ct_;
id = id_;
lc = lc_;
rc = rc_;
}
};
struct rankST {
node* head;
int sn;
rankST() {}
rankST(int sn_) {
sn = sn_;
head = new node(0, sn + 1, 0, -1, NULL, NULL);
}
void insert(int i, int v) { insert(head, i, v); }
void insert(node* t, int i, int v) {
++(t->ct);
int clr = (t->lr), crr = (t->rr), mid = clr + (crr - clr) / 2;
if (clr + 1 == crr) {
t->id = v;
return;
} else if (i < mid) {
if (t->lc == NULL) t->lc = new node(clr, mid, 0, -1, NULL, NULL);
insert(t->lc, i, v);
} else {
if (t->rc == NULL) t->rc = new node(mid, crr, 0, -1, NULL, NULL);
insert(t->rc, i, v);
}
}
pair<int, int> query(int k) {
if ((head->ct) < k)
return ABSENT;
else
return query(head, k);
}
pair<int, int> query(node* t, int k) {
if ((t->lr) + 1 == (t->rr)) return pair<int, int>((t->lr), (t->id));
if ((t->lc) != NULL and (t->lc->ct) >= k)
return query(t->lc, k);
else
return query(t->rc, k - ((t->lc == NULL) ? 0 : (t->lc->ct)));
}
bool present;
void remove(int i) {
present = false;
remove(head, i);
}
void remove(node* t, int i) {
int clr = (t->lr), crr = (t->rr), mid = clr + (crr - clr) / 2;
if (clr + 1 == crr) {
if ((t->ct) > 0) {
present = true;
--(t->ct);
t->id = -1;
}
return;
}
if (i < mid) {
if (t->lc == NULL) return;
remove(t->lc, i);
if (t->lc->ct == 0) {
delete t->lc;
t->lc = NULL;
}
} else {
if (t->rc == NULL) return;
remove(t->rc, i);
if (t->rc->ct == 0) {
delete t->rc;
t->rc = NULL;
}
}
if (present) --(t->ct);
}
};
rankST rankst;
const int max_n = 1000010;
const int max_m = 1000010;
int n, m;
int a[max_n];
int ct[max_n] = {0};
vector<int> rem;
int main() {
scanf("%d", &n);
scanf("%d", &m);
rankst = rankST(n + m);
for (int i = m; i < m + n; ++i) rankst.insert(i, i - m);
fill(a, a + n, -1);
int x, y;
for (int i = 0; i < m; ++i) {
scanf("%d", &x);
scanf("%d", &y);
--x;
pair<int, int> q = rankst.query(y);
assert(q != ABSENT);
int remloc = q.first;
int orix = q.second;
if (a[orix] == -1 or a[orix] == x)
a[orix] = x;
else {
printf("%d\n", -1);
return 0;
}
rankst.remove(remloc);
rankst.insert(m - 1 - i, orix);
}
for (int i = 0; i < n; ++i) ++ct[a[i]];
for (int i = 0; i < n; ++i) {
if (ct[i] > 1) {
printf("%d\n", -1);
return 0;
}
if (ct[i] == 0) rem.push_back(i);
}
int p = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == -1)
printf("%d ", rem[p++] + 1);
else
printf("%d ", a[i] + 1);
}
printf("\n");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55;
const int inf = 1 << 30;
int mp[300][300];
int main() {
int n, a[110], sum1[110], sum2[110];
while (scanf("%d", &n) != EOF) {
memset(sum1, 0, sizeof(sum1));
memset(sum2, 0, sizeof(sum2));
for (int i = 2; i <= n; i++) {
scanf("%d", &a[i]);
sum1[i] = sum1[i - 1] + a[i];
}
for (int i = 1; i < n; i++) scanf("%d", &a[i]);
for (int i = n - 1; i >= 1; i--) sum2[i] = sum2[i + 1] + a[i];
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int MIN = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (sum1[i] + sum2[i] + a[i] + sum1[j] + sum2[j] + a[j] < MIN)
MIN = sum1[i] + sum2[i] + a[i] + sum1[j] + sum2[j] + a[j];
}
}
printf("%d\n", MIN);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acosl(-1.0);
const int MAXN = 100005;
const long long mod = 1000000007ll;
int alp[26];
int cur[26];
void update() {
for (int i = 0; i < 26; ++i) cur[i] -= alp[i];
}
char getneed() {
for (int i = 0; i < 26; ++i)
if (cur[i] < alp[i]) {
++cur[i];
return 'a' + i;
}
update();
return getneed();
}
void solve() {
string a, b;
cin >> a >> b;
for (int i = 0; i < 26; ++i) alp[i] = cur[i] = 0;
for (int i = 0; i < b.size(); ++i) alp[b[i] - 'a']++;
for (int i = 0; i < a.size(); ++i)
if (a[i] != '?') cur[a[i] - 'a']++;
for (int i = 0; i < a.size(); ++i)
if (a[i] == '?') a[i] = getneed();
cout << a;
}
int main(int argc, char *argv[]) {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, m;
int ans[N];
pair<int, int> p[N];
void solve() {
int t, sum = 0;
for (int i = 0; i < m; ++i) {
scanf("%d", &t);
sum += t;
p[i] = make_pair(t, i + 1);
}
if ((n == 3 && m == 2) || sum < n) {
puts("-1");
return;
}
sort(p, p + m);
t = sum - p[m - 1].first;
if (t * 2 < n) {
puts("-1");
return;
}
memset(ans, -1, sizeof(ans));
int cnt = 0;
int i = 0, z = m - 1;
while (cnt < n) {
t = p[z].second;
int j, last = 0;
for (j = 0; j < n; ++j) {
int pos = (i + j) % n;
if (ans[pos] != -1) continue;
int pre = (i + j + n - 1) % n;
int bck = (i + j + 1) % n;
if (ans[pre] == t || ans[bck] == t) continue;
ans[pos] = t;
cnt++;
last = pos;
if (--p[z].first <= 0) break;
}
--z;
i = last;
}
for (int i = 0; i < n; ++i) {
if (i) printf(" ");
printf("%d", ans[i]);
}
puts("");
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
solve();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long double epsylon = 1e-9;
int num(string c) {
if (c == "S") return 0;
if (c == "M") return 1;
if (c == "L") return 2;
if (c == "XL") return 3;
return 4;
}
char strs[5][6] = {"S", "M", "L", "XL", "XXL"};
int main() {
int n[5];
cin >> n[0] >> n[1] >> n[2] >> n[3] >> n[4];
int m;
cin >> m;
string s;
getline(cin, s);
for (int i = 0; i < m; i++) {
getline(cin, s);
int j = num(s);
int d = 0;
while (true) {
if (j + d < 5 && n[j + d] > 0) {
printf("%s\n", strs[j + d]);
n[j + d]--;
break;
}
if (j - d >= 0 && n[j - d] > 0) {
printf("%s\n", strs[j - d]);
n[j - d]--;
break;
}
d++;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int> > v[1000];
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[y / 1001].push_back(make_pair(x, i + 1));
}
for (int i = 0; i < 1000; i++) {
sort(v[i].begin(), v[i].end());
if (i % 2) reverse(v[i].begin(), v[i].end());
}
for (int i = 0; i < 1000; i++)
for (int j = 0; j < v[i].size(); j++) printf("%d ", v[i][j].second);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010];
string s, t;
const int mod = 1000000007;
int main() {
cin >> s >> t;
long long curr = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == t[0]) {
curr++;
}
dp[i][0] = curr;
}
curr = 0;
for (int i = 0; i < t.length(); i++) {
if (t[i] == s[0]) {
curr++;
}
dp[0][i] = curr;
}
for (int i = 1; i < s.length(); i++) {
for (int j = 1; j < t.length(); j++) {
if (s[i] == t[j]) {
if (i > 1)
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j] + 1 - dp[i - 2][j - 1]) % mod;
else
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j] + 1) % mod;
} else {
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j] - dp[i - 1][j - 1]) % mod;
}
}
}
int res = dp[s.length() - 1][t.length() - 1] % mod;
if (res < 0) res += mod;
cout << res << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int k, n, a[1000006], d[1003];
queue<int> que;
int main() {
cin >> k >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] -= k;
sort(a + 1, a + 1 + n);
n = unique(a + 1, a + 1 + n) - a - 1;
for (int i = 0; i <= 1000; i++) d[i] = -1;
for (int i = 1; i <= n; i++)
if (a[i] >= 0) d[a[i]] = 1, que.push(a[i]);
while (!que.empty()) {
int x = que.front();
que.pop();
if (!x) return cout << d[x] << endl, 0;
for (int i = 1; i <= n; i++)
if (x + a[i] >= 0 && x + a[i] <= 1000 && d[x + a[i]] == -1)
d[x + a[i]] = d[x] + 1, que.push(x + a[i]);
}
return puts("-1"), 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, x, temp;
int t;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> a >> b;
if (b == 0 || (b == 0 && a == 0))
cout << 1 << endl;
else if (a == 0)
cout << 0.5 << endl;
else {
x = ((4 * b) < (a) ? (4 * b) : (a));
if (x == a)
temp = (a * b) + ((a * (a / 4)) / 2);
else
temp = (a * b) + ((a * b) - (x * b) / 2);
cout << temp / (2 * a * b) << endl;
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void Open() {}
int reverse(int x) {
int rev = 0;
while (x) {
rev *= 10;
rev += x % 10;
x /= 10;
}
return rev;
}
int main() {
Open();
string s;
cin >> s;
long long h1, h2, m1, m2, num = 0, revers;
h1 = s[0] - 48;
h2 = s[1] - 48;
m1 = s[3] - 48;
m2 = s[4] - 48;
while (1) {
m2++;
if (m2 == 10) {
m2 = 0;
m1++;
}
if (m1 == 6) {
m1 = 0;
h2++;
}
if (h2 == 10) {
h2 = 0;
h1++;
}
if (h1 * 10 + h2 == 24) {
h1 = h2 = m1 = m2 = 0;
}
if (h1 == m2 && h2 == m1) {
cout << h1 << h2 << ":" << m1 << m2 << endl;
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
char F[10][10][11];
bool V[10][10][11];
int k, n, m, x, y;
int ans;
void DFS(int f, int x, int y) {
ans++;
V[f][x][y] = true;
if (f - 1 >= 0 && F[f - 1][x][y] == '.' && !V[f - 1][x][y]) DFS(f - 1, x, y);
if (f + 1 < k && F[f + 1][x][y] == '.' && !V[f + 1][x][y]) DFS(f + 1, x, y);
if (x - 1 >= 0 && F[f][x - 1][y] == '.' && !V[f][x - 1][y]) DFS(f, x - 1, y);
if (x + 1 < n && F[f][x + 1][y] == '.' && !V[f][x + 1][y]) DFS(f, x + 1, y);
if (y - 1 >= 0 && F[f][x][y - 1] == '.' && !V[f][x][y - 1]) DFS(f, x, y - 1);
if (y + 1 < m && F[f][x][y + 1] == '.' && !V[f][x][y + 1]) DFS(f, x, y + 1);
}
int main() {
while (scanf("%d%d%d", &k, &n, &m) == 3) {
for (int i = 0; i < k; i++)
for (int j = 0; j < n; j++) scanf("%s", F[i][j]);
scanf("%d%d", &x, &y);
memset(V, false, sizeof(V));
ans = 0;
if (F[0][x - 1][y - 1] == '.') DFS(0, x - 1, y - 1);
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
enum { UP, DOWN };
const int MAXN = 20 + 10;
long long dp[2][MAXN][5];
bool can(int mask, int n, int t) {
bool bits[21];
short len = 0, cnt = 0, cnt2 = 0;
bits[0] = false;
while (mask > 0) {
bits[++len] = (mask & 1);
if (bits[len] && bits[len - 1]) return false;
if (bits[len]) cnt++;
mask >>= 1;
}
if (n - len > 3) return false;
while (len < n) bits[++len] = false;
if (bits[1] + bits[2] + bits[3] + bits[4] == 0) return false;
if (bits[len] + bits[len - 1] + bits[len - 2] + bits[len - 3] == 0)
return false;
if (cnt != t || bits[1] || bits[len]) return false;
int i = 1;
while (!bits[i]) i++;
for (; i <= n; i++) {
if (bits[i])
cnt2 = 0;
else
cnt2++;
if (cnt2 > 5) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
int n, t;
cin >> n >> t;
int max_mask = (1 << n);
long long ans = 0ll;
for (int mask = 1; mask < max_mask; mask++) {
if (can(mask, n, t)) {
bool top = false;
for (int i = 1; i < n; i++)
for (int j = 1; j <= 4; j++) dp[UP][i][j] = dp[DOWN][i][j] = 0;
dp[UP][0][1] = dp[UP][0][2] = dp[UP][0][3] = dp[UP][0][4] = 1;
for (int j = 1; j < n; j++) {
if (mask & (1 << j)) {
dp[UP][j][2] += dp[UP][j - 1][1] + dp[DOWN][j - 1][1];
dp[UP][j][3] += dp[UP][j - 1][1] + dp[UP][j - 1][2] +
dp[DOWN][j - 1][1] + dp[DOWN][j - 1][2];
dp[UP][j][4] += dp[UP][j - 1][1] + dp[UP][j - 1][2] +
dp[UP][j - 1][3] + dp[DOWN][j - 1][1] +
dp[DOWN][j - 1][2] + dp[DOWN][j - 1][3];
top = true;
} else {
if (top) {
top = false;
for (int k = 1; k < 4; k++)
for (int d = k + 1; d <= 4; d++)
dp[DOWN][j][k] += dp[UP][j - 1][d];
} else {
for (int k = 1; k < 4; k++)
for (int d = 1; d < k; d++)
dp[UP][j][k] += dp[UP][j - 1][d] + dp[DOWN][j - 1][d];
for (int k = 3; k > 0; k--)
for (int d = k + 1; d <= 4; d++)
dp[DOWN][j][k] += dp[DOWN][j - 1][d];
}
}
}
ans += dp[DOWN][n - 1][1] + dp[DOWN][n - 1][2] + dp[DOWN][n - 1][3] +
dp[DOWN][n - 1][4];
}
}
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<char> v;
for (int i = 0; i < s.length(); i += 2) {
v.push_back(s[i]);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (i < v.size() - 1) {
cout << v.at(i) << "+";
} else
cout << v.at(i);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, i, e, f, g, n, m, k, l, A[200005], maxx, t, fix[200005];
map<long long, long long> dp;
string s[200005];
int main() {
cin >> t;
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
for (long long i = 1; i <= 0; i++) {
a++;
l = 1;
}
while (true) {
break;
continue;
}
while (t--) {
cin >> n >> k;
l = 0;
for (long long i = 1; i <= n; i++) {
cin >> A[i];
if (l == 1) continue;
s[i] = "";
while (A[i] > 0) {
if (A[i] % k != 1 && A[i] % k != 0) {
l = 1;
break;
}
s[i] += char(A[i] % k + 48);
A[i] /= k;
}
}
while (true) {
break;
continue;
}
while (true) {
break;
continue;
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < s[i].size(); j++) {
fix[j] = 0;
}
}
if (l == 1) {
cout << "NO" << endl;
continue;
}
for (long long i = 1; i <= n; i++) {
if (l == 1) continue;
for (long long j = 0; j < s[i].size(); j++) {
if (s[i][j] == '1' && fix[j] == 1) {
l = 1;
break;
}
if (s[i][j] == '1') fix[j] = 1;
}
}
if (l == 1) {
cout << "NO" << endl;
} else
cout << "YES" << endl;
}
while (true) {
break;
continue;
}
while (true) {
break;
continue;
}
while (true) {
break;
continue;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
vector<int> N(300500);
vector<pair<int, int> > P(300500);
map<pair<int, int>, int> m;
cin >> n >> p;
for (int i = 1; i <= n; i++) N[i] = 0;
for (int i = 1; i <= n; i++) {
cin >> P[i].first >> P[i].second;
if (P[i].first > P[i].second) swap(P[i].first, P[i].second);
m[P[i]]++;
N[P[i].first]++;
N[P[i].second]++;
}
vector<int> v;
for (int i = 1; i <= n; i++) v.push_back(N[i]);
sort(v.begin(), v.end());
long long ans = 0;
for (int i = 1; i <= n; i++) {
int n1 = N[i];
int n2 = p - n1;
int l = 0, r = n - 1;
while (l != r && r != l + 1) {
int sr = (l + r) / 2;
if (v[sr] >= n2)
r = sr;
else
l = sr;
}
if (v[l] >= n2)
ans += (long long)(n - l);
else if (v[r] >= n2)
ans += (long long)(n - r);
if (n2 <= n1) ans--;
}
for (int i = 1; i <= n; i++)
if (m[P[i]] != -1) {
if (N[P[i].first] + N[P[i].second] - m[P[i]] < p &&
N[P[i].first] + N[P[i].second] >= p)
ans -= 2;
m[P[i]] = -1;
}
cout << ans / 2;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
double a, b, c;
int main() {
cin >> a >> b >> c;
double k = b * b;
double l = 4 * a * c;
if (a == 0) {
if (b == 0 && c == 0) {
cout << -1 << endl;
return 0;
}
if (b == 0 && c != 0) {
cout << 0 << endl;
return 0;
}
if (c == 0) {
cout << 1 << endl;
printf("%.9f", 0);
} else {
cout << 1 << endl;
printf("%.9f", -c / b);
}
} else {
if (k - l < 0)
cout << 0 << endl;
else if (k - l == 0) {
cout << 1 << endl;
printf("%.9f\n", (sqrt(k - l) - b) / 2 / a);
} else if (k - l > 0) {
cout << 2 << endl;
printf("%.9f\n%.9f\n",
((sqrt(k - l) - b) / 2 / a - (-sqrt(k - l) - b) / 2 / a) < 0
? (sqrt(k - l) - b) / 2 / a
: (-sqrt(k - l) - b) / 2 / a,
((sqrt(k - l) - b) / 2 / a - (-sqrt(k - l) - b) / 2 / a) > 0
? (sqrt(k - l) - b) / 2 / a
: (-sqrt(k - l) - b) / 2 / a);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r;
cin >> n >> m;
int a[111], c[111];
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
c[i] = a[i];
}
for (int j = 1; j <= m; j++) scanf("%d%d", &l, &r);
sort(&a[1], &a[1] + n);
int b[111];
for (int i = 1; i <= n; i++) b[a[i]] = i % 2;
for (int i = 1; i <= n; i++) printf("%d ", b[c[i]]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, j = 0;
priority_queue<pair<long long, long long> > q;
cin >> n;
vector<pair<long long, long long> > w(n);
string s;
vector<long long> res(2 * n, 99);
for (long long i = 0; i < n; ++i) {
w[i].second = i;
cin >> w[i].first;
}
cin >> s;
sort(w.begin(), w.end());
for (long long i = 0; i < s.size(); ++i) {
if (s[i] == '0') {
res[i] = w[j].second;
q.push(w[j]);
j++;
} else {
res[i] = q.top().second;
q.pop();
}
}
for (long long i = 0; i < 2 * n; ++i) {
cout << res[i] + 1 << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int R, C;
string grid[maxn];
int ans[maxn * maxn];
int ds[maxn * maxn], sz[maxn * maxn];
int nxt_r[4] = {1, -1, 0, 0};
int nxt_c[4] = {0, 0, -1, 1};
int quadros(int a) {
int r = a / C, c = a % C;
if (grid[r][c] == '*') return 0;
int acc = 0;
for (int i = 0; i < 4; i++) {
acc += grid[r + nxt_r[i]][c + nxt_c[i]] == '*';
}
return acc;
}
void dsBuild(int n) {
for (int i = 0; i < n; i++) {
ds[i] = i;
sz[i] = 1;
ans[i] = quadros(i);
}
}
int dsFind(int i) { return (ds[i] == i ? i : ds[i] = dsFind(ds[i])); }
void dsUnion(int a, int b) {
a = dsFind(a), b = dsFind(b);
if (sz[a] < sz[b]) swap(a, b);
if (a != b) {
sz[a] += sz[b];
ans[a] += ans[b];
}
ds[b] = a;
}
void solve() {
int k;
cin >> R >> C >> k;
for (int i = 0; i < R; i++) cin >> grid[i];
dsBuild(R * C);
for (int r = 0; r < R; r++)
for (int c = 0; c < C; c++) {
if (grid[r][c] == '*') continue;
for (int i = 0; i < 4; i++)
if (grid[r + nxt_r[i]][c + nxt_c[i]] != '*')
dsUnion(r * C + c, (r + nxt_r[i]) * C + c + nxt_c[i]);
}
int x, y;
while (k--) {
cin >> x >> y;
x--, y--;
x = x * C + y;
cout << ans[dsFind(x)] << endl;
}
}
int32_t main() {
cin.tie(0);
ios::sync_with_stdio(0);
int tc = 1;
while (tc--) solve();
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000 * 1000 * 1000;
char tbl[55][55];
bool ap[55][55];
int dst[55][55];
string p[55][55];
bool got[55];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, -1, 0, 1};
string path;
bool SUKASUKA;
int N, M, K;
pair<int, int> s, t;
bool checkPos(int x, int y) {
return x >= 0 && x < N && y >= 0 && y < M && ap[x][y];
}
void solve() {
if (path.empty()) {
path.resize(N * M + 1, 'z' + 1);
}
vector<char> gc;
for (int i = (0); i < (26); ++i)
if (got[i]) {
gc.push_back(char('a' + i));
}
for (int i = (0); i < (N); ++i)
for (int j = (0); j < (M); ++j) {
ap[i][j] = false;
for (int k = (0); k < ((int)gc.size()); ++k)
if (tbl[i][j] == gc[k]) {
ap[i][j] = true;
}
}
ap[s.first][s.second] = ap[t.first][t.second] = true;
for (int i = (0); i < (N); ++i)
for (int j = (0); j < (M); ++j) {
dst[i][j] = INF;
p[i][j] = "";
}
dst[s.first][s.second] = 0;
queue<pair<int, int> > q;
q.push(s);
while (!q.empty()) {
pair<int, int> now = q.front();
q.pop();
for (int k = (0); k < (4); ++k) {
int x = now.first + dx[k], y = now.second + dy[k];
if (checkPos(x, y))
if (dst[x][y] > dst[now.first][now.second] + 1) {
dst[x][y] = dst[now.first][now.second] + 1;
p[x][y] = p[now.first][now.second] + tbl[x][y];
q.push(make_pair(x, y));
} else if (dst[x][y] == dst[now.first][now.second] + 1) {
p[x][y] = min(p[x][y], p[now.first][now.second] + tbl[x][y]);
}
}
}
if (dst[t.first][t.second] == INF) {
return;
}
SUKASUKA = true;
string npath = p[t.first][t.second];
if ((int)npath.size() < (int)path.size() ||
(int)npath.size() == (int)path.size() && npath < path) {
path = npath;
}
}
void gen(int step = 0, int prev = -1) {
if (step == K) {
solve();
} else {
if (prev + 1 == 26) {
return;
}
for (int i = (prev + 1); i < (26); ++i) {
got[i] = true;
gen(step + 1, i);
got[i] = false;
}
}
}
void read() {
cin >> N >> M >> K;
for (int i = (0); i < (N); ++i)
for (int j = (0); j < (M); ++j) {
cin >> tbl[i][j];
if (tbl[i][j] == 'S') {
s.first = i;
s.second = j;
}
if (tbl[i][j] == 'T') {
t.first = i;
t.second = j;
}
}
}
void out() {
if (SUKASUKA) {
for (int i = (0); i < ((int)path.size() - 1); ++i) {
cout << path[i];
}
} else {
cout << "-1";
}
}
int main() {
read();
gen();
out();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
pair<int, int> t[4 * 100001];
pair<int, int> combine(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first) return a;
if (b.first > a.first) return b;
return make_pair(a.first, a.second + b.second);
}
void build(int a[], int v, int tl, int tr) {
if (tl == tr)
t[v] = make_pair(a[tl], 1);
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
pair<int, int> get_max(int v, int tl, int tr, int l, int r) {
if (l > r) return make_pair(-9999999999, 0);
if (l == tl && r == tr) return t[v];
int tm = (tl + tr) / 2;
return combine(get_max(v * 2, tl, tm, l, min(r, tm)),
get_max(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
void update(int v, int tl, int tr, int pos, int new_val) {
if (tl == tr)
t[v] = make_pair(new_val, 1);
else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update(v * 2, tl, tm, pos, new_val);
else
update(v * 2 + 1, tm + 1, tr, pos, new_val);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
int main() {
int n, m, k, q;
string s;
long long ans = 0;
scanf("%d %d", &n, &q);
std::vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
std::vector<int> b(n - 1);
std::vector<std::pair<int, int> > so;
for (int i = 0; i < n - 1; i++) {
b[i] = abs(a[i] - a[i + 1]);
}
deque<std::pair<int, int> > val;
val.push_back(make_pair(b[0], 0));
std::vector<int> nx(n - 1);
std::vector<int> px(n - 1);
for (int i = 1; i < n - 1; i++) {
while ((val.size() > 0) && (val.back().first < b[i])) {
nx[val.back().second] = i;
val.pop_back();
}
val.push_back(make_pair(b[i], i));
}
while (val.size() > 0) {
nx[val.back().second] = n - 1;
val.pop_back();
}
val.push_back(make_pair(b[n - 2], n - 2));
for (int i = n - 3; i >= 0; i--) {
while ((val.size() > 0) && (val.back().first <= b[i])) {
px[val.back().second] = i;
val.pop_back();
}
val.push_back(make_pair(b[i], i));
}
while (val.size() > 0) {
px[val.back().second] = -1;
val.pop_back();
}
build(b.data(), 1, 0, n - 2);
for (int i = 0; i < q; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
std::vector<std::pair<int, int> > si;
long long ans = 0;
for (int j = x; j < y; j++) {
ans += 1ll * b[j] * (j - max(x - 1, px[j])) * (min(y, nx[j]) - j);
}
printf("%I64d\n", ans);
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long p;
long long q;
cin >> p >> q;
if ((q > p) || (p % q != 0)) {
cout << p << endl;
} else if (p == q) {
long long ans = 1;
for (__typeof(2) i = 2; i < ceil(sqrt(q)) + 1; i++) {
if (p % i == 0) {
ans = q / i;
break;
}
}
cout << ans << endl;
} else {
long long ans = 1;
for (__typeof(2) i = 2; i < ceil(sqrt(q)) + 1; i++) {
if (q % i == 0 && q != i) {
long long cntq = 0;
long long tq = q;
while (tq % i == 0) {
tq /= i;
cntq++;
}
long long t = p;
while (t % i == 0) {
t /= i;
}
cntq--;
while (cntq--) {
t *= i;
}
ans = max(ans, t);
int r = q / i;
cntq = 0;
tq = q;
while (tq % r == 0) {
tq /= r;
cntq++;
}
t = p;
while (t % r == 0) {
t /= r;
}
cntq--;
while (cntq--) {
t *= r;
}
ans = max(ans, t);
}
}
if (ans == 1) {
long long t = p;
while (t % q == 0) {
t /= q;
}
ans = max(ans, t);
}
cout << ans << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
vector<long long> pre(n);
pre[0] = a[0];
for (int i = 1; i < n; i++) pre[i] = a[i] + pre[i - 1];
vector<int> pos;
for (int i = 0; i < n - 1; i++)
if (a[i] != a[i + 1]) pos.push_back(i);
pos.push_back(n - 1);
long long ans = 1e18;
for (int i = 0; i < pos.size(); i++) {
int lpos = (i ? pos[i - 1] + 1 : 0);
int rpos = pos[i];
long long need = k - (rpos - lpos + 1);
if (need <= 0) {
cout << 0;
return 0;
}
long long lsum = (lpos * a[lpos]) - (lpos ? pre[lpos - 1] : 0);
long long rsum = (pre[n - 1] - pre[rpos]) - (n - rpos - 1) * a[lpos];
if (lpos >= need) ans = min(ans, lsum - lpos + need);
if (n - rpos - 1 >= need) ans = min(ans, rsum - (n - rpos - 1) + need);
ans = min(ans, lsum + rsum - (n - k));
}
cout << ans;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n = 0, i = 0;
cin >> n;
while (n != 0) {
i = n % 2 + i;
n = n / 2;
}
cout << i;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char c[1015][1015];
int main() {
memset(c, '.', sizeof(c));
int n;
cin >> n;
int s = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i + j) % 2 == 0) c[i][j] = 'C';
}
}
cout << (n * n + 1) / 2 << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << c[i][j];
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int a, b, c, v, side1, side2, side3;
cin >> a >> b >> c;
v = sqrt((a * b * c));
side1 = v / a;
side2 = v / b;
side3 = v / c;
cout << (4 * (side1 + side2 + side3)) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005, L = (1 << 19), inf = 1e8;
struct segtree {
int v[2 * L], l[2 * L];
void init() {
for (int i = 2 * L; --i;) {
v[i] = inf;
}
}
void lazydown(int P) {
v[2 * P] += l[P];
v[2 * P + 1] += l[P];
l[2 * P] += l[P];
l[2 * P + 1] += l[P];
l[P] = 0;
}
void upd(int S, int E, int X, int SS = 0, int SE = L - 1, int P = 1) {
if (S <= SS && SE <= E) {
v[P] += X;
l[P] += X;
return;
}
if (S > SE || SS > E) return;
lazydown(P);
int M = (SS + SE) / 2;
upd(S, E, X, SS, M, 2 * P);
upd(S, E, X, M + 1, SE, 2 * P + 1);
v[P] = min(v[2 * P], v[2 * P + 1]);
}
pair<int, int> findmin(int SS = 0, int SE = L - 1, int P = 1) {
if (SS == SE) return {SS, v[P]};
lazydown(P);
int M = (SS + SE) / 2;
if (v[2 * P] < v[2 * P + 1])
return findmin(SS, M, 2 * P);
else
return findmin(M + 1, SE, 2 * P + 1);
}
} seg;
struct sumseg {
int v[2 * L];
void upd(int P, int V) {
P += L;
v[P] += V;
P /= 2;
while (P) {
v[P] += V;
P /= 2;
}
}
int get(int S, int E) {
S += L;
E += L;
int R = 0;
while (S <= E) {
if (S % 2 == 1) R += v[S++];
if (E % 2 == 0) R += v[E--];
S /= 2;
E /= 2;
}
return R;
}
} sseg;
int n, q, a[N], mi[N], ans[N];
vector<int> swp[N];
vector<pair<int, int> > qry[N];
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
seg.init();
for (int i = n; i >= 1; i--) {
int D = i - a[i];
if (D >= 0) seg.upd(i, i, D - inf);
while (true) {
int I, V;
tie(I, V) = seg.findmin();
if (V > 0) break;
mi[I] = i;
seg.upd(I, I, inf);
seg.upd(I + 1, n, -1);
}
}
for (int i = 1; i <= n; i++) {
swp[mi[i]].push_back(i);
}
for (int i = 1; i <= q; i++) {
int A, B;
scanf("%d%d", &A, &B);
int S = A + 1, E = n - B;
qry[S].push_back({E, i});
}
for (int i = n; i >= 1; i--) {
for (auto &T : swp[i]) {
sseg.upd(T, 1);
}
for (auto &T : qry[i]) {
int E, I;
tie(E, I) = T;
ans[I] = sseg.get(i, E);
}
}
for (int i = 1; i <= q; i++) {
printf("%d\n", ans[i]);
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
cin >> q;
int b[q][3];
for (int i = 0; i < q; i++) {
cin >> b[i][0];
if (b[i][0] == 1)
cin >> b[i][1] >> b[i][2];
else
cin >> b[i][2];
}
int res[n], c = -1;
memset(res, -1, sizeof(res));
for (int i = q - 1; i >= 0; i--) {
if (b[i][0] == 1 && res[b[i][1] - 1] == -1)
res[b[i][1] - 1] = max(c, b[i][2]);
else if (b[i][0] == 2)
c = max(c, b[i][2]);
}
for (int i = 0; i < n; i++) {
if (res[i] == -1) res[i] = max(c, a[i]);
cout << res[i] << " ";
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int k, a, b;
int main() {
cin >> k >> a >> b;
if (b > a) swap(a, b);
int fswins = a / k;
int scwins = b / k;
if (a % k && b / k == 0 || b % k && a / k == 0)
cout << -1;
else
cout << fswins + scwins;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> v;
bool can(long long val) {
long long curK = 0;
if (val <= v[n / 2]) {
return true;
} else {
curK += val - v[n / 2];
}
for (int i = n / 2 + 1; i < n; ++i) {
if (v[i] < val) {
curK += val - v[i];
if (curK > k) {
return false;
}
} else {
break;
}
}
return curK <= k;
}
long long findRes() {
long long l = 0, r = 2000000001;
while (l < r) {
long long m = (l + r + 1) >> 1;
if (can(m)) {
l = m;
} else {
r = m - 1;
}
}
return r;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
sort(v.begin(), v.end());
cout << findRes();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, Query;
char ch;
bool a[520][520];
int A[520][520][15][18], P[520], dp[520];
void go(int tl, int tr, int deep, int pr) {
if (tl == tr) return;
int v = (tl + tr) / 2;
dp[v] = deep;
P[v] = pr;
for (int i = 1; i <= n; ++i) {
if (a[i][v] == 1) continue;
for (int j = 0; j < 17; ++j) A[i][v][deep][j] = A[i - 1][v][deep][j];
int x = i / 31;
int y = i % 31;
A[i][v][deep][x] = (A[i][v][deep][x] | (1 << y));
}
for (int i = v + 1; i < tr; ++i)
for (int j = 1; j <= n; ++j) {
if (a[j][i] == 1) continue;
for (int k = 0; k < 17; ++k)
A[j][i][deep][k] = (A[j - 1][i][deep][k] | A[j][i - 1][deep][k]);
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j < 17; ++j)
if (a[i][v] == 0)
A[i][v][deep][j] = A[i + 1][v][deep][j];
else
A[i][v][deep][j] = 0;
if (a[i][v] == 1) continue;
int x = i / 31;
int y = i % 31;
A[i][v][deep][x] = (A[i][v][deep][x] | (1 << y));
}
for (int i = v - 1; i >= tl; --i)
for (int j = n; j >= 1; --j) {
if (a[j][i] == 1) continue;
for (int k = 0; k < 17; ++k)
A[j][i][deep][k] = (A[j + 1][i][deep][k] | A[j][i + 1][deep][k]);
}
go(tl, v, deep + 1, v);
go(v + 1, tr, deep + 1, v);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
ch = getchar();
while (ch != '.' && ch != '#') ch = getchar();
if (ch == '#')
a[i][j] = true;
else
a[i][j] = false;
}
go(1, m + 1, 0, 0);
scanf("%d", &Query);
while (Query--) {
pair<int, int> x, y;
int c1, c2, X, Y;
scanf("%d %d", &x.first, &x.second);
scanf("%d %d", &y.first, &y.second);
if (x.first > y.first || x.second > y.second) {
printf("No\n");
continue;
}
c1 = x.second;
c2 = y.second;
while (dp[c1] > dp[c2]) c1 = P[c1];
while (dp[c2] > dp[c1]) c2 = P[c2];
while (c1 != c2) c1 = P[c1], c2 = P[c2];
if (y.second == c2) {
X = y.first / 31;
Y = y.first % 31;
if ((A[x.first][x.second][dp[c1]][X] & (1 << Y)) == 0)
printf("No\n");
else
printf("Yes\n");
continue;
}
bool b = true;
for (int i = 0; i < 17; ++i)
if ((A[x.first][x.second][dp[c1]][i] & A[y.first][y.second][dp[c1]][i]) >
0) {
b = false;
break;
}
if (b)
printf("No\n");
else
printf("Yes\n");
}
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long long x, y;
pt operator-(pt a) { return {x - a.x, y - a.y}; }
void read() { cin >> x >> y; }
};
long long cross(pt a, pt b) { return a.x * b.y - b.x * a.y; }
vector<pt> v;
bool sol(pt a, pt b) {
vector<pt> vv;
for (auto u : v) {
if (cross(b - a, u - a) != 0) {
vv.push_back(u);
}
}
if (vv.size() < 3) {
return true;
}
pt c = vv[0], d = vv[1];
for (auto u : vv) {
if (cross(d - c, u - c) != 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
pt a;
a.read();
v.push_back(a);
}
if (n < 5) {
cout << "YES" << endl;
return 0;
}
int ind = -1;
for (int i = 2; i < v.size(); i++) {
if (cross(v[i] - v[i - 1], v[i] - v[i - 2]) != 0) {
ind = i;
break;
}
}
if (ind == -1) {
cout << "YES\n";
return 0;
}
bool is = false;
is |= sol(v[ind], v[ind - 1]);
is |= sol(v[ind - 1], v[ind - 2]);
is |= sol(v[ind], v[ind - 2]);
if (is) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n;
int f[1000 * 1000 + 5];
int tab[1000 * 1000 + 5];
vector<int> czyn[1000 * 1000 + 5];
int sil[1000 * 1000 + 5];
int podst[1000 * 1000 + 5];
int cnt[1000 * 1000 + 5], cntpodst[1000 * 1000 + 5];
int kogo[1000 * 1000 + 5], mam[1000 * 1000 + 5];
inline int F(int x) { return x == 1 ? 1 : n / x; }
void wypierpapier() {
cout << "0\n";
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> tab[i];
podst[i] = 1;
}
sil[0] = 1;
for (int i = 1; i <= n; i++) sil[i] = (1LL * sil[i - 1] * i) % mod;
czyn[1].push_back(1);
cnt[1]++;
for (int i = 2; i <= n; i++)
if (!f[i]) {
cnt[F(i)]++;
for (int j = i; j <= n; j += i) {
if (!f[j]) f[j] = i;
czyn[j].push_back(i);
podst[j] *= i;
}
}
for (int i = 1; i <= n; i++) cntpodst[podst[i]]++;
for (int i = 1; i <= n; i++) {
if (!tab[i]) continue;
if ((int)(czyn[i]).size() != (int)(czyn[tab[i]]).size()) wypierpapier();
for (int j = 0; j < (int)(czyn[i]).size(); j++) {
int a = czyn[i][j], b = czyn[tab[i]][j];
int va = F(a), vb = F(b);
if (va != vb) wypierpapier();
if (kogo[a] && kogo[a] != b) wypierpapier();
if (mam[b] && mam[b] != a) wypierpapier();
if (!kogo[a]) cnt[va]--;
kogo[a] = b, mam[b] = a;
}
cntpodst[podst[i]]--;
}
long long res = 1;
for (int i = 1; i <= n; i++) {
res *= sil[cnt[i]];
res %= mod;
res *= sil[cntpodst[i]];
res %= mod;
}
cout << res << "\n";
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
class JuRuo {
bool sb;
int neg_IQ;
} LHM;
int ey[1000000], enext[1000000], ec[1000000], g[1000000], col[1000000],
dep[1000000], etot, n, m, ans, tot, fa[1000000];
pair<int, int> q[1000000];
int gcd(int x, int y) { return (y == 0) ? x : gcd(y, x % y); }
int get(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
return dep[x] - dep[y] + 1;
}
void builde(int e, int x, int y, int c) {
ey[e] = y, enext[e] = g[x], ec[e] = c, g[x] = e;
}
int main() {
scanf("%d%d", &n, &m);
ans = -1;
memset(g, 0xff, sizeof(g));
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
builde(2 * i, x, y, 1);
builde(2 * i + 1, y, x, -1);
}
memset(col, 0, sizeof(col));
for (int r = 1; r <= n; r++)
if (col[r] == 0) {
q[tot = 1] = make_pair(1, g[r]);
fa[r] = 0;
dep[r] = 0;
while (tot) {
int x = q[tot].first, &e = q[tot].second;
if (e == g[x]) {
col[x] = 1;
}
if (e == -1) {
tot--;
col[x] = 2;
continue;
}
int y = ey[e], c = ec[e];
e = enext[e];
if (col[y] == 0) {
q[++tot] = make_pair(y, g[y]);
fa[y] = x;
dep[y] = dep[x] + c;
continue;
}
int d = abs(dep[x] + c - dep[y]);
if (ans == -1)
ans = d;
else
ans = gcd(ans, d);
}
}
if (ans <= 0)
cout << n << endl;
else
cout << ans << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
struct st {
st *left, *right;
int sum, l, r, m;
st(int l, int r) : l(l), r(r), sum(0) {
if (l != r) {
m = (l + r) / 2;
left = new st(l, m);
right = new st(m + 1, r);
}
}
void update(int pos, int v, int o) {
if (l == r) {
sum = v;
} else {
if (pos <= m) {
left->update(pos, v, o ^ 1);
} else
right->update(pos, v, o ^ 1);
if (o)
sum = left->sum ^ right->sum;
else
sum = left->sum | right->sum;
}
}
int get(int a, int b) {
if (a > r || b < l) return 0;
if (a <= l && r <= b) return sum;
return left->get(a, b) | right->get(a, b);
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int num = 1 << n;
int cal = log2(num) + 1;
if (cal % 2)
cal = 1;
else
cal = 0;
st rmq(0, num - 1);
for (int i = 0; i < num; i++) {
int a;
cin >> a;
rmq.update(i, a, cal);
}
while (m--) {
int a;
long long b;
cin >> a >> b;
rmq.update(a - 1, b, cal);
cout << rmq.get(0, num) << "\n";
;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const int mxN = 2e5 + 5;
template <class T>
T gcd(T a, T b) {
return ((b == 0) ? a : gcd(b, a % b));
}
void solve() {
int n;
cin >> n;
vector<int> b(n), a;
int mx = 0;
for (int i = 0; i < (int)(n); i++) cin >> b[i], mx = max(mx, b[i]);
sort(b.begin(), b.end());
for (int i = 0; i < (int)(n); i++)
if (!i || (i && b[i] != b[i - 1])) a.push_back(b[i]);
n = a.size();
for (int i = 0; i < (int)(n); i++) {
vector<int> st;
for (int j = i - 1; j >= 0; j--) {
if (a[i] % a[j] != 0) {
for (int k = 0; k < (int)(st.size()); k++) {
if (st[k] % a[j] != 0) {
mx = max(mx, a[i] + st[k] + a[j]);
if (!k) goto end;
}
}
mx = max(mx, a[i] + a[j]);
st.push_back(a[j]);
}
}
end:;
}
cout << mx << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int j, t;
cin >> t;
for (j = 0; j < t; j++) {
long long int n, k;
cin >> n >> k;
long long int i, a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
a[0] += k;
bool flag = false;
for (i = 1; i < n; i++) {
if (abs(a[i] - a[0]) > k) {
cout << -1 << endl;
flag = true;
break;
}
}
if (flag == false) cout << a[0] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
int n;
int a[maxN];
const int LIM = 100;
int pref[maxN][101];
const int SHIFT = maxN;
int lst[maxN + SHIFT];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= LIM; j++) {
pref[i][j] = pref[i - 1][j];
if (a[i] == j) pref[i][j]++;
}
}
int f = 1;
for (int c = 1; c <= 100; c++) {
if (pref[n][c] > pref[n][f]) f = c;
}
int best = 0;
for (int other = 1; other <= 100; other++) {
if (other == f) continue;
memset(lst, -1, sizeof lst);
lst[SHIFT] = 0;
for (int j = 1; j <= n; j++) {
int cur_val = pref[j][f] - pref[j][other];
if (lst[SHIFT + cur_val] != -1) {
best = max(best, j - lst[SHIFT + cur_val]);
} else {
lst[SHIFT + cur_val] = j;
}
}
}
cout << best;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = ~0ull >> 2;
const long long MAX = 100005;
const long long mod = 1e9 + 7;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, len = 0;
cin >> n;
vector<pair<int, int> > v(3e6, {-1, -1});
vector<string> s(n);
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
cin >> s[i];
int k;
cin >> k;
while (k--) {
int x;
cin >> x;
len = max(len, x + int((s[i]).size()) - 1);
pair<int, int> p = {int((s[i]).size()), i};
if (p > v[x]) v[x] = p;
}
}
pair<int, int> prev = {-1, -1};
for (__typeof(len + 1) i = (1) - ((1) > (len + 1));
i != (len + 1) - ((1) > (len + 1)); i += 1 - 2 * ((1) > (len + 1))) {
v[i] = max(make_pair(prev.first - 1, prev.second), v[i]);
if (v[i].first <= 0 || v[i].second < 0)
cout << "a";
else {
int idx = v[i].second;
cout << s[idx][int((s[idx]).size()) - v[i].first];
}
prev = v[i];
}
cout << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m, x, y;
cin >> n >> m >> x >> y;
char arr[1001][1001];
for (long long int i = 0; i < n; i++) {
string s;
cin >> s;
for (long long int j = 0; j < m; j++) arr[i][j] = s[j];
}
if (2 * x < y) y = 2 * x;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (arr[i][j] == '.') {
if (j + 1 < m && arr[i][j + 1] == '.') {
arr[i][j] = '*';
arr[i][j + 1] = '*';
ans += y;
} else {
arr[i][j] = '*';
ans += x;
}
}
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool ok1, ok2;
char c[101][101];
int n, i, j, a[101], b[101];
int main() {
scanf("%d\n", &n);
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
scanf("%c", &c[i][j]);
if (c[i][j] == 'E') {
++a[i];
++b[j];
}
}
scanf("\n");
}
for (i = 0; i < n; ++i)
if (a[i] == n) ok1 = true;
for (i = 0; i < n; ++i)
if (b[i] == n) ok2 = true;
if (ok1 == true && ok2 == true)
cout << -1;
else {
if (ok1 == false) {
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j)
if (c[i][j] == '.') {
cout << i + 1 << " " << j + 1 << endl;
break;
}
} else {
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j)
if (c[j][i] == '.') {
cout << j + 1 << " " << i + 1 << endl;
break;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool vis1[100011];
long long int vis2[100011];
vector<long long int> second;
vector<long long int> g[100011], gd[100011];
void dfs1(long long int v) {
vis1[v] = 1;
second.emplace_back(v);
for (auto x : g[v]) {
if (!vis1[x]) dfs1(x);
}
}
long long int dfs2(long long int v) {
vis2[v] = 1;
for (auto x : gd[v]) {
if (vis2[x] == 0) {
if (dfs2(x)) return 1;
}
if (vis2[x] == 1) return 1;
}
vis2[v] = 2;
return 0;
}
long long int func(vector<long long int>& w) {
long long int p = 0;
for (auto x : w) {
if (vis2[x] == 0) p += dfs2(x);
}
if (!p) return 1;
return 0;
}
int main() {
long long int n, m;
cin >> n >> m;
long long int u, v;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
g[u].emplace_back(v);
g[v].emplace_back(u);
gd[u].emplace_back(v);
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis1[i]) {
second.clear();
dfs1(i);
ans = ans + second.size() - func(second);
}
}
cout << ans;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> v1;
for (int i = 0; i < n; i++) {
int r;
scanf("%d", &r);
v1.push_back(r);
}
long long int sum = 0;
sort(v1.begin(), v1.end());
reverse(v1.begin(), v1.end());
while (n > 0) {
for (int i = 0; i < n; i++) {
sum = sum + v1[i];
}
n = n / 4;
}
cout << sum;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, M = 110;
struct edge {
int la, b;
char v;
} e[N << 1];
int n, q, tot, hd[N], fa[N][20], dep[N], rt[N], ans[N];
unsigned long long val[N][M], nowv[N];
void add(int from, int to, char val) {
e[++tot] = (edge){hd[from], to, val};
hd[from] = tot;
}
void dfs(int pos, int f) {
dep[pos] = dep[f] + 1;
for (int i = 2, j = f; i <= 100; ++i, j = fa[j][0])
val[pos][i] = val[pos][i - 1] * 233 + val[j][1];
fa[pos][0] = f;
for (int i = 1; i < 20; ++i) {
fa[pos][i] = fa[fa[pos][i - 1]][i - 1];
if (!fa[pos][i]) break;
}
for (int i = hd[pos]; i; i = e[i].la)
if (e[i].b != f) {
val[e[i].b][1] = e[i].v - 'a';
dfs(e[i].b, pos);
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20 - 1; i >= 0; --i)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 20 - 1; i >= 0; --i)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int up(int x, int k) {
for (int i = 19; i >= 0; --i)
if ((k >> i) & 1) x = fa[x][i];
return x;
}
string str;
struct data {
int u, v, id;
string s;
};
vector<data> vec[M];
vector<unsigned long long> tmp;
struct node {
int sum, ls, rs;
} t[N * 50];
int cnt, m;
void update(int& x, int y, int p, int lp = 1, int rp = m) {
x = ++cnt, t[x] = t[y], ++t[x].sum;
if (lp == rp) return;
int mid = (lp + rp) >> 1;
if (p <= mid)
update(t[x].ls, t[y].ls, p, lp, mid);
else
update(t[x].rs, t[y].rs, p, mid + 1, rp);
}
int query(int p, int x, int px, int lp = 1, int rp = m) {
if (lp == rp) return t[x].sum - t[px].sum;
int mid = (lp + rp) >> 1;
if (p <= mid)
return query(p, t[x].ls, t[px].ls, lp, mid);
else
return query(p, t[x].rs, t[px].rs, mid + 1, rp);
}
unsigned long long dval[M], rval[M];
int solve(data que) {
int ret = 0, z = lca(que.u, que.v), l = que.s.size();
dval[0] = 0;
for (int i = 0; i < l; ++i) dval[i + 1] = dval[i] * 233 + que.s[i] - 'a';
rval[0] = 0;
for (int i = 0; i < l; ++i)
rval[i + 1] = rval[i] * 233 + que.s[l - i - 1] - 'a';
if (dep[que.u] - dep[z] >= l) {
int v = lower_bound(tmp.begin(), tmp.end(), dval[l]) - tmp.begin() + 1;
if (v <= m && dval[l] == tmp[v - 1])
ret += query(v, rt[que.u], rt[up(que.u, dep[que.u] - dep[z] - l + 1)]);
}
if (dep[que.v] - dep[z] >= l) {
int v = lower_bound(tmp.begin(), tmp.end(), rval[l]) - tmp.begin() + 1;
if (v <= m && rval[l] == tmp[v - 1])
ret += query(v, rt[que.v], rt[up(que.v, dep[que.v] - dep[z] - l + 1)]);
}
for (int i = up(que.u, max(0, dep[que.u] - dep[z] - l + 1)), j; i != z;
i = fa[i][0]) {
int step = dep[que.v] - dep[z] - (l - (dep[i] - dep[z]));
if (step < 0) continue;
j = up(que.v, step);
if (val[i][dep[i] - dep[z]] == dval[dep[i] - dep[z]] &&
val[j][dep[j] - dep[z]] == rval[dep[j] - dep[z]])
++ret;
}
return ret;
}
void fsd(int pos) {
update(rt[pos], rt[fa[pos][0]], nowv[pos]);
for (int i = hd[pos]; i; i = e[i].la)
if (e[i].b != fa[pos][0]) fsd(e[i].b);
}
void work() {
for (int i = 1; i <= 100; ++i)
if (vec[i].size()) {
tmp.clear();
cnt = 1;
for (int j = 1; j <= n; ++j) tmp.push_back(val[j][i]);
sort(tmp.begin(), tmp.end());
tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());
for (int j = 1; j <= n; ++j)
nowv[j] =
lower_bound(tmp.begin(), tmp.end(), val[j][i]) - tmp.begin() + 1;
m = tmp.size();
fsd(1);
for (int j = 0; j < vec[i].size(); ++j)
ans[vec[i][j].id] = solve(vec[i][j]);
}
}
int main() {
scanf("%d", &n);
char z;
for (int i = 1, x, y; i < n; ++i)
scanf("%d%d %c", &x, &y, &z), add(x, y, z), add(y, x, z);
dfs(1, 0);
scanf("%d", &q);
for (int i = 1, x, y; i <= q; ++i) {
scanf("%d%d", &x, &y);
cin >> str;
vec[str.size()].push_back((data){x, y, i, str});
}
work();
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c;
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + c - '0';
return x * f;
}
int n, mxn;
int main() {
n = read();
while (n--) {
int x = read(), y = read();
mxn = (x + y > mxn ? x + y : mxn);
}
printf("%d", mxn);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
for (int tc = 0; tc < t; tc++) {
int n;
cin >> n;
vector<long long int> arr(n), brr(n);
for (int i1 = 0; i1 < n; i1++) cin >> arr[i1];
brr = arr;
sort(brr.begin(), brr.end());
vector<int> v;
for (int i = 0; i < n; i++) {
if (arr[i] != brr[i]) v.push_back(i);
}
if (v.size() > 2) {
cout << "NO"
<< "\n";
continue;
}
if (v.size() == 0) {
cout << "YES"
<< "\n";
continue;
}
swap(arr[v[0]], arr[v[1]]);
cout << (arr == brr ? "YES" : "NO") << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF32 = 1E9;
const long long INF64 = 4E18;
const long long M = 1E9 + 7;
const double EPS = 1E-9;
const double PI = 2 * acos(0);
vector<long long> suffix_sum(1E6);
bool cmp_v(pair<long long, long long> a, pair<long long, long long> b) {
return (a.second < b.second);
}
long long solve(vector<pair<long long, long long> >& points, int start,
int end) {
if ((end - start) == 1) return 0;
int mid = (start + end) / 2;
long long d1 = solve(points, start, mid);
long long d2 = solve(points, mid, end);
sort(points.begin() + mid, points.begin() + end, cmp_v);
for (int i = end - 1; i >= mid; --i) {
suffix_sum[i] = points[i].first;
if (i != end - 1) suffix_sum[i] += suffix_sum[i + 1];
}
long long d = 0;
for (int i = start; i < mid; ++i) {
int p = lower_bound(points.begin() + mid, points.begin() + end, points[i],
cmp_v) -
points.begin();
d += suffix_sum[p];
d -= (end - p) * points[i].first;
}
return d1 + d2 + d;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<long long, long long> > points(n);
for (int i = 0; i < n; ++i) {
cin >> points[i].first;
}
for (int i = 0; i < n; ++i) {
cin >> points[i].second;
}
sort(points.begin(), points.end());
cout << solve(points, 0, n) << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int color;
int len;
node(int _color, int _len) : color(_color), len(_len) {}
};
char s[1000005];
list<node> ls;
int maintain() {
int res = INT_MAX;
for (auto it = ls.begin(); it != ls.end(); ++it) {
if (it == ls.begin() || it == prev(ls.end()))
res = min(res, it->len);
else
res = min(res, it->len / 2 + it->len % 2);
}
bool first = true;
for (auto it = ls.begin(); it != ls.end();) {
if (first || it == prev(ls.end())) {
it->len -= res;
first = false;
} else
it->len -= res * 2;
if (it->len <= 0)
it = ls.erase(it);
else
++it;
}
if (ls.size() >= 1) {
for (auto it = next(ls.begin()); it != ls.end();) {
auto pre = prev(it);
if (it->color == pre->color) {
pre->len += it->len;
it = ls.erase(it);
} else
++it;
}
}
return res;
}
int main(int argc, char* argv[]) {
scanf("%s", s);
for (int i = 0; s[i];) {
int j;
for (j = i; s[j] == s[i]; ++j)
;
ls.emplace_back(s[i], j - i);
i = j;
}
int res = 0;
while (ls.size() > 1) res += maintain();
printf("%d\n", res);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int a[N];
int sum[N];
int f[2 * N + 10];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[a[i]]++;
}
int mx = *max_element(sum + 1, sum + n + 1);
int cnt = 0, val;
for (int i = 1; i <= n; i++) {
if (mx == sum[i]) {
cnt++;
val = i;
}
}
if (cnt > 1) {
printf("%d\n", n);
return 0;
}
int ans = 0;
int sz = sqrt(n * 1.0);
for (int i = 1; i <= n; i++) {
if (sum[i] <= sz) continue;
if (i == val) continue;
memset(f, -1, sizeof(f));
f[N] = 0;
int tot = 0;
for (int j = 1; j <= n; j++) {
if (a[j] == val)
tot++;
else if (a[j] == i)
tot--;
if (f[tot + N] != -1)
ans = max(ans, j - f[tot + N]);
else
f[tot + N] = j;
}
}
for (int i = 1; i <= sz; i++) {
memset(f, 0, sizeof(f));
int tot = 0;
for (int l = 1, r = 1; r <= n; r++) {
f[a[r]]++;
if (f[a[r]] == i) tot++;
while (f[a[r]] > i) {
if (f[a[l]] == i) tot--;
f[a[l++]]--;
}
if (tot >= 2) ans = max(ans, r - l + 1);
}
}
printf("%d\n", ans);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int n, len;
int nr;
int nr1, nr0, nrc, ok = 0;
char a[100005], aux[100005];
int check() {
nr1 = nr0 = nrc = 0;
for (int i = 1; i <= len; i++)
if (a[i] == '0')
nr0++;
else if (a[i] == '1')
nr1++;
else
nrc++;
if (nrc) return 1;
if (nr1 > 1) return 1;
return 0;
}
int main() {
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) {
scanf("%s ", a + 1);
len = strlen(a + 1);
if (len == 1 && a[1] == '0') {
printf("0");
return 0;
}
if (check())
memcpy(aux, a, sizeof(a)), ok = 1;
else
nr += nr0;
}
if (ok)
printf("%s", aux + 1);
else
printf("1");
for (int i = 1; i <= nr; i++) printf("0");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long Nfact = 200005;
const long long mod = 1000000007;
const long long Nsieve = 1000005;
vector<bool> is_prime(Nsieve, true);
void sieve() {
is_prime[0] = is_prime[1] = false;
for (long long i = 2; i * i <= Nsieve; i++) {
if (is_prime[i]) {
for (long long j = i * i; j <= Nsieve; j += i) is_prime[j] = false;
}
}
}
long long bSearch(long long l, long long r, long long x,
vector<long long> arr) {
while (l <= r) {
long long m = l + (r - l) / 2;
if (arr[m] == x) return m;
if (arr[m] < x)
l = m + 1;
else
r = m - 1;
}
return -1;
}
void primeFactors(long long n) {
while (n % 2 == 0) {
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
n = n / i;
}
}
if (n > 2) cout << n << " ";
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modulo(long long a, long long b) {
long long c = a % b;
return (c < 0) ? c + b : c;
}
long long mul(long long x, long long y) { return (x * y) % mod; }
long long inv(long long x) { return power(x, mod - 2, mod); }
long long divide(long long x, long long y) { return mul(x, inv(y)); }
long long fact[Nfact];
void precalc() {
fact[0] = 1;
for (long long i = 1; i < Nfact; i++) fact[i] = mul(fact[i - 1], i);
}
long long nCr(long long n, long long k) {
if (n < k) return 0;
return divide(fact[n], mul(fact[k], fact[n - k]));
}
void solve() {
long long n, k;
cin >> n >> k;
string s, str;
cin >> s;
str = s;
set<char> se;
for (long long i = 0; i < n; i++) {
se.insert(s[i]);
}
auto it = se.begin();
if (k > n) {
s.append(k - n, *it);
} else {
for (long long i = k - 1; i >= 0; i--) {
auto it3 = se.find(s[i]);
++it3;
if (it3 != se.end()) {
s[i] = *it3;
break;
} else {
s[i] = *it;
continue;
}
}
}
cout << s.substr(0, k) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long a = (1ll << n);
long long b = 0;
int i, j;
for (i = n - 1, j = 0; j < n / 2; i--, j++) {
b += (1ll << i);
}
while (i) {
a += (1ll << i);
i--;
}
cout << a - b << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k1, k2, a[1007], b[1007];
int main() {
cin >> n >> k1 >> k2;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> b[i];
for (int i = 1; i <= k1; ++i) {
int pos = -1, curr = -1;
for (int i = 1; i <= n; ++i)
if (abs(a[i] - b[i]) > curr) {
curr = abs(a[i] - b[i]);
pos = i;
}
if (a[pos] <= b[pos])
a[pos]++;
else
a[pos]--;
}
for (int i = 1; i <= k2; ++i) {
int pos = -1, curr = -1;
for (int i = 1; i <= n; ++i)
if (abs(a[i] - b[i]) > curr) {
curr = abs(a[i] - b[i]);
pos = i;
}
if (b[pos] <= a[pos])
b[pos]++;
else
b[pos]--;
}
long long res = 0;
for (int i = 1; i <= n; ++i) res += (a[i] - b[i]) * (a[i] - b[i]);
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int IN() {
int c, f, x;
while (!isdigit(c = getchar()) && c != '-')
;
c == '-' ? (f = 1, x = 0) : (f = 0, x = c - '0');
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + c - '0';
return !f ? x : -x;
}
const int N = 4e5 + 19;
const int p = 1e9 + 7;
int Pow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % p)
if (b & 1) res = 1ll * res * a % p;
return res;
}
struct seg {
int l, r;
} A[N], B[N];
int v0[N], v1[N], F[N], G[N], sumF[N], sumG[N], C[N];
int n, a, b, x, y;
int main() {
n = IN(), a = IN(), b = IN();
for (int i = 1; i < a + 1; i++) {
A[i] = (seg){IN(), IN()};
C[++*C] = A[i].l;
C[++*C] = A[i].r;
}
for (int i = 1; i < b + 1; i++) {
B[i] = (seg){IN(), IN()};
C[++*C] = B[i].l;
C[++*C] = B[i].r;
}
C[++*C] = 1;
C[++*C] = n;
C[++*C] = n + 1;
sort(C + 1, C + *C + 1);
*C = unique(C + 1, C + *C + 1) - C - 1;
for (int i = 1; i < a + 1; i++) {
A[i].l = lower_bound(C + 1, C + *C + 1, A[i].l) - C;
A[i].r = lower_bound(C + 1, C + *C + 1, A[i].r) - C;
}
for (int i = 1; i < b + 1; i++) {
B[i].l = lower_bound(C + 1, C + *C + 1, B[i].l) - C;
B[i].r = lower_bound(C + 1, C + *C + 1, B[i].r) - C;
}
for (int i = 1; i < a + 1; i++) {
v0[A[i].r] = max(v0[A[i].r], A[i].l);
}
for (int i = 1; i < b + 1; i++) {
v1[B[i].r] = max(v1[B[i].r], B[i].l);
}
for (int i = 1; i < *C + 1; i++) {
v0[i] = max(v0[i], v0[i - 1]);
v1[i] = max(v1[i], v1[i - 1]);
}
F[0] = G[0] = 1;
sumF[0] = sumG[0] = 1;
for (int i = 1; i < *C; i++) {
int f = (sumF[i - 1] - (v0[i] ? sumF[v0[i] - 1] : 0) + p) % p;
int g = (sumG[i - 1] - (v1[i] ? sumG[v1[i] - 1] : 0) + p) % p;
int len = C[i + 1] - C[i];
F[i] =
(1ll * g * Pow(2, len - 1) + 1ll * f * (Pow(2, len - 1) - 1 + p)) % p;
G[i] =
(1ll * f * Pow(2, len - 1) + 1ll * g * (Pow(2, len - 1) - 1 + p)) % p;
sumF[i] = (sumF[i - 1] + F[i]) % p;
sumG[i] = (sumG[i - 1] + G[i]) % p;
}
printf("%d\n", (F[*C - 1] + G[*C - 1]) % p);
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int getNumberOfAdditionalVotes(vector<int> array) {
if (array.size() < 1) {
return -1;
}
int x = array[0];
int count = 0;
array[0] = array[array.size() - 1];
array.pop_back();
sort(array.begin(), array.end());
while (x <= array[array.size() - 1]) {
array[array.size() - 1]--;
x++;
count++;
sort(array.begin(), array.end());
}
return count;
}
int main() {
int n;
vector<int> array;
cin >> n;
int value;
for (int i = 0; i < n; i++) {
cin >> value;
array.push_back(value);
}
cout << getNumberOfAdditionalVotes(array);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i, a[5001], w;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[a[a[i]]] == i) w++;
}
if (w != 0)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int calc(int x, int y) { return x * 60 + y; }
string out(int x) {
int y = x / 60, z = x % 60;
stringstream s;
if (y < 10) {
s << "0";
}
s << y;
s << ":";
if (z < 10) {
s << "0";
}
s << z;
string res;
s >> res;
return res;
}
int main() {
int a, b, c, d, x, y;
scanf("%d:%d", &a, &b);
scanf("%d:%d", &c, &d);
x = calc(a, b);
y = calc(c, d);
cout << out((x - y < 0) ? x - y + 1440 : x - y);
}
| 1 |
#include <bits/stdc++.h>
const int N = 30006, D = 400;
int n, d, a[N];
int f[N][2 * D + 1];
inline int read() {
int s = 0, f = 1;
char ch;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
s = (s << 1) + (s << 3) + ch - '0';
return s * f;
}
int main() {
n = read(), d = read();
for (int i = 1; i <= n; ++i) ++a[read()];
memset(f, -1, sizeof(f));
f[d][D] = a[0] + a[d];
for (int i = d; i <= N; ++i)
for (int j = -D; j <= D; ++j) {
if (f[i][j + D] == -1) continue;
for (int z = -1; z <= 1; ++z) {
int len = j + d + z;
if (j + z < -D || j + z > D || len < 1 || i + len > N) continue;
f[i + len][j + z + D] =
std::max(f[i + len][j + z + D], f[i][j + D] + a[i + len]);
}
}
int ans = 0;
for (int i = 0; i < N; ++i)
for (int j = 0; j <= (D << 1); ++j) ans = std::max(ans, f[i][j]);
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
unordered_map<long long, int> endspot, l;
unordered_map<long long, bool> visited;
pair<int, int> best[MAXN][3];
vector<int> edges[MAXN];
int pilg[MAXN];
int n, m;
set<int> notdone[MAXN];
int dfsorder[MAXN], tree[8 * MAXN], revdfs[MAXN];
int ct = 0;
vector<int> euler;
int firsttime[MAXN];
int partpl[MAXN], partmi[MAXN];
int ans[MAXN];
int part = 0;
bool ispilg[MAXN];
int ___dist[MAXN];
void dfs(int f, int v) {
dfsorder[v] = ct;
revdfs[ct] = v;
++ct;
euler.push_back(dfsorder[v]);
firsttime[v] = euler.size() - 1;
for (int i = 0; i < edges[v].size(); ++i) {
if (f != edges[v][i]) {
___dist[edges[v][i]] = ___dist[v] + 1;
dfs(v, edges[v][i]);
euler.push_back(dfsorder[v]);
}
}
}
void init(int l = 0, int r = 2 * n - 2, int node = 1) {
if (l == r) {
tree[node] = euler[l];
return;
}
int mid = (l + r) / 2;
init(l, mid, 2 * node);
init(mid + 1, r, 2 * node + 1);
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
}
int lca(int a, int b, int l = 0, int r = 2 * n - 2, int node = 1) {
if (a == l && b == r) return tree[node];
int mid = (l + r) / 2;
if (b <= mid) return lca(a, b, l, mid, 2 * node);
if (a >= mid + 1) return lca(a, b, mid + 1, r, 2 * node + 1);
return min(lca(a, mid, l, mid, 2 * node),
lca(mid + 1, b, mid + 1, r, 2 * node + 1));
}
void update(int x, int v) {
if (!ispilg[v] &&
((best[v][0] == pair<int, int>(0, v)) ||
(best[v][0].second == x && best[v][1] == pair<int, int>(0, v))))
return;
if (best[v][0].second == x) {
if (best[v][1].first == best[v][2].first)
endspot[1LL * MAXN * x + v] = v;
else
endspot[1LL * MAXN * x + v] = endspot[1LL * MAXN * v + best[v][1].second];
int lx = l[1LL * MAXN * x + v] + best[v][1].first;
pair<int, int> xl = {lx, v};
for (int i = 0; i < 3; ++i) {
if (xl > best[x][i]) {
for (int j = 2; j >= i + 1; --j) best[x][j] = best[x][j - 1];
best[x][i] = xl;
break;
}
}
} else if (best[v][1].second == x) {
if (best[v][0].first == best[v][2].first)
endspot[1LL * MAXN * x + v] = v;
else
endspot[1LL * MAXN * x + v] = endspot[1LL * MAXN * v + best[v][0].second];
int lx = l[1LL * MAXN * x + v] + best[v][0].first;
pair<int, int> xl = {lx, v};
for (int i = 0; i < 3; ++i) {
if (xl > best[x][i]) {
for (int j = 2; j >= i + 1; --j) best[x][j] = best[x][j - 1];
best[x][i] = xl;
break;
}
}
} else {
if (best[v][0].first == best[v][1].first)
endspot[1LL * MAXN * x + v] = v;
else
endspot[1LL * MAXN * x + v] = endspot[1LL * MAXN * v + best[v][0].second];
int lx = l[1LL * MAXN * x + v] + best[v][0].first;
pair<int, int> xl = {lx, v};
for (int i = 0; i < 3; ++i) {
if (xl > best[x][i]) {
for (int j = 2; j >= i + 1; --j) best[x][j] = best[x][j - 1];
best[x][i] = xl;
break;
}
}
}
}
void compute(int x, int v) {
if (visited.count(1LL * MAXN * x + v) > 0) return;
visited[1LL * MAXN * x + v] = 1;
while (!notdone[v].empty() && *notdone[v].begin() != x) {
compute(v, *notdone[v].begin());
notdone[v].erase(*notdone[v].begin());
}
while (!notdone[v].empty() && *notdone[v].rbegin() != x) {
compute(v, *notdone[v].rbegin());
notdone[v].erase(*notdone[v].rbegin());
}
update(x, v);
}
int finishdfs(int f, int v) {
int tot = 0;
for (int i = 0; i < edges[v].size(); ++i) {
if (f != edges[v][i]) {
tot += finishdfs(v, edges[v][i]);
}
}
tot += partpl[v];
ans[v] += tot;
tot -= partmi[v];
return tot;
}
int main() {
ios_base::sync_with_stdio(0);
memset(partpl, 0, sizeof(partpl));
memset(partmi, 0, sizeof(partmi));
memset(ans, 0, sizeof(ans));
memset(ispilg, 0, sizeof(ispilg));
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d", &pilg[i]);
pilg[i]--;
ispilg[pilg[i]] = true;
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
int l3;
scanf("%d", &l3);
edges[x].push_back(y);
edges[y].push_back(x);
notdone[x].insert(y);
notdone[y].insert(x);
l[1LL * MAXN * x + y] = l[1LL * MAXN * y + x] = l3;
}
for (int i = 0; i < n; ++i) {
best[i][0] = best[i][1] = best[i][2] = {0, i};
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < edges[i].size(); ++j) compute(i, edges[i][j]);
___dist[0] = 0;
dfs(-1, 0);
init();
for (int i = 0; i < m; ++i) {
int p = pilg[i], q;
if (best[p][0].first == best[p][1].first) {
q = p;
} else
q = endspot[1LL * MAXN * p + best[p][0].second];
if (p == q) continue;
if (firsttime[p] > firsttime[q]) swap(p, q);
int lcapq = revdfs[lca(firsttime[p], firsttime[q])];
if (lcapq == p) {
partpl[q]++;
partmi[p]++;
} else {
partpl[p]++;
partpl[q]++;
partmi[lcapq] += 2;
ans[lcapq]--;
}
}
finishdfs(-1, 0);
int maxi = -1, maxct = -1;
for (int i = 0; i < n; ++i) {
if (ispilg[i]) continue;
if (ans[i] == maxi) ++maxct;
if (ans[i] > maxi) {
maxi = ans[i];
maxct = 1;
}
}
if (m == 2) {
if (firsttime[pilg[0]] > firsttime[pilg[1]]) swap(pilg[0], pilg[1]);
int lcapq = revdfs[lca(firsttime[pilg[0]], firsttime[pilg[1]])];
int dist1 = ___dist[pilg[0]] + ___dist[pilg[1]] - 2 * ___dist[lcapq] + 1;
if (dist1 == 2)
cout << "0 " << n - 2 << endl;
else
cout << "2 " << dist1 - 2 << endl;
return 0;
}
cout << maxi << ' ' << maxct << endl;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int dp[maxn], cnt[maxn];
int main() {
int n, m, t, x, y;
cin >> n >> m;
int mp[n + 5][m + 5];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> mp[i][j];
memset(dp, 0, sizeof dp);
memset(cnt, 0, sizeof cnt);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int k = i;
if (dp[j] >= i)
k = dp[j];
else {
while (mp[k + 1][j] >= mp[k][j] && k < n) {
k++;
}
}
dp[j] = k;
cnt[i] = max(cnt[i], k);
}
cin >> t;
while (t--) {
cin >> x >> y;
if (cnt[x] >= y)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct myp {
int f;
int s;
};
struct edges {
int v;
bool check1;
};
int dx[5] = {-1, 0, 0, 1, 0};
int dy[5] = {0, 1, -1, 0, 0};
int len[1008][1008];
bool checktui[1008][1008];
int accum[1008][1008];
bool alpha[28];
long long first1[10009];
long long first2[10009];
long long save[500009];
long long second[1000009];
int deg[10000];
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
bool isok(int n, int m, int x, int y, char** a) {
if (x >= 0 && x < n && y >= 0 && y < m) {
return true;
return false;
}
return false;
}
int gcd(int num, int denum) {
if (num == 0)
return denum;
else
return gcd(denum % num, num);
}
int get(long long x, int& finalzero) {
int len = 0;
while (x != 0) {
len += 1;
if (x % 2 == 0) {
if (len <= 30) finalzero = len;
}
x /= 2;
}
return len;
}
int myabs(int a) {
if (a >= 0)
return a;
else
return -a;
}
int main() {
int n, m;
cin >> n >> m;
char** a;
a = new char*[n];
for (int i = 0; i < n; i++) {
a[i] = new char[m];
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i - 1 >= 0) {
if (a[i - 1][j] != a[i][j]) {
int start = i;
while (start < n) {
if (a[start][j] == a[i][j]) {
len[i][j] += 1;
} else
break;
start += 1;
}
} else {
len[i][j] = len[i - 1][j];
}
} else {
int start = i;
while (start < n) {
if (a[start][j] == a[i][j]) {
len[i][j] += 1;
} else
break;
start += 1;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i >= 1 && i + len[i][j] < n) {
if (len[i - 1][j] >= len[i][j] && len[i][j] <= len[i + len[i][j]][j] &&
a[i][j] != a[i + len[i][j]][j] && a[i - 1][j] != a[i][j]) {
checktui[i][j] = true;
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (checktui[i][j] == true) {
if (j >= 1) {
if (len[i][j - 1] == len[i][j] && a[i - 1][j - 1] == a[i - 1][j] &&
a[i + len[i][j]][j - 1] == a[i + len[i][j]][j] &&
a[i][j - 1] == a[i][j]) {
accum[i][j] = accum[i][j - 1] + 1;
ans += accum[i][j];
} else {
accum[i][j] = 1;
ans += 1;
}
} else {
accum[i][0] = 1;
ans += 1;
}
}
}
}
cout << ans;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
long long int n, k, x, i, j;
cin >> n >> k >> x;
vector<pair<long long int, long long int>> v;
for (i = 0; i < n; i++) {
long long int tm, y = v.size() - 1;
cin >> tm;
if (i == 0)
v.push_back({tm, 1});
else if (v[y].first == tm)
v[y].second++;
else
v.push_back({tm, 1});
}
long long int ans = 0;
if (v[0].second == 2) ans = 2;
for (i = 1; i < v.size(); i++) {
if (v[i].second == 2 && v[i].first == x) {
long long int l = i, r = v.size() - i - 1, cnt, tans = 2;
cnt = min(l, r);
l = i - 1;
r = i + 1;
while (cnt != 0) {
cnt--;
if (v[l].first == v[r].first && v[l].second + v[r].second >= 3) {
tans += v[l].second + v[r].second;
l--;
r++;
} else
break;
}
ans = max(ans, tans);
}
}
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[200005];
long long ar[200005], tree[2][2 * 200005];
int dfstime, start[200005], finish[200005], dep[200005];
void dfs(int s, int fr, int len) {
start[s] = ++dfstime, dep[s] = len;
for (int v : G[s]) {
if (v != fr) dfs(v, s, len + 1);
}
finish[s] = ++dfstime;
return;
}
void update(int idx, long long val, int on) {
for (int i = idx; i <= dfstime; i += (i & -i)) tree[on][i] += val;
return;
}
long long query(int idx, int on) {
long long ret = 0;
for (int i = idx; i > 0; i -= (i & -i)) ret += tree[on][i];
return ret;
}
int main() {
int t, m, k, n, a, u, v, id = 0;
long long x, y;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> ar[i];
for (int i = 1; i < n; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 1, 1);
while (m--) {
cin >> a >> u;
if (a == 2)
cout << query(start[u], dep[u] % 2) + ar[u] << endl;
else {
cin >> x;
update(start[u], x, dep[u] % 2);
update(finish[u], -x, dep[u] % 2);
update(start[u], -x, !(dep[u] % 2));
update(finish[u], x, !(dep[u] % 2));
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int x[100100], y[100100], z[100100], w[100100], tx[100100 * 2], dis[100100],
from[100100];
struct cmp {
bool operator()(int i, int j) const { return y[i] < y[j]; }
};
multiset<int, cmp> f[100100 * 2];
int main() {
int n, m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d", &x[i], &y[i], &z[i], &w[i]);
tx[i * 2] = x[i];
tx[i * 2 + 1] = z[i];
}
memset(dis, -1, sizeof(dis));
tx[0] = -1;
sort(tx, tx + n * 2 + 2);
m = unique(tx, tx + n * 2 + 2) - tx;
for (int i = 1; i <= n; i++) {
int nx = lower_bound(tx, tx + m, x[i]) - tx;
while (nx < 100100 * 2) {
f[nx].insert(i);
nx += nx & -nx;
}
}
queue<int> q;
q.push(0);
dis[0] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
int nx = lower_bound(tx, tx + m, z[u]) - tx;
while (nx > 0) {
while (!f[nx].empty() && w[u] >= y[*f[nx].begin()]) {
int v = *f[nx].begin();
f[nx].erase(f[nx].begin());
if (dis[v] == -1) {
dis[v] = dis[u] + 1;
from[v] = u;
q.push(v);
}
}
nx -= nx & -nx;
}
}
vector<int> ans;
printf("%d\n", dis[n]);
if (dis[n] >= 0) {
for (int i = n; i; i = from[i]) ans.push_back(i);
for (int i = ans.size() - 1; i >= 0; i--) printf("%d ", ans[i]);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
char tab1[301][301];
for (int i = 0; i < n; i++) cin >> tab1[i];
bool tab[301][301];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (tab1[i][j] == '*')
tab[i][j] = 1;
else
tab[i][j] = 0;
for (int rad = 1; rad < min(n, m); rad++)
for (int i = rad; i < n - rad; i++)
for (int j = rad; j < m - rad; j++) {
if (tab[i][j] && tab[i - rad][j] && tab[i + rad][j] &&
tab[i][j - rad] && tab[i][j + rad])
k--;
if (!k) {
cout << i + 1 << " " << j + 1 << endl;
cout << i - rad + 1 << " " << j + 1 << endl;
cout << i + rad + 1 << " " << j + 1 << endl;
cout << i + 1 << " " << j - rad + 1 << endl;
cout << i + 1 << " " << j + rad + 1 << endl;
return 0;
}
}
cout << "-1\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
char a[MAXN], ans[MAXN];
int n;
int main() {
cin >> (a + 1);
int n = strlen(a + 1);
if (n & 1) {
ODD_N:
for (int i = 1; i <= n / 2 + 1; i++) {
putchar('4');
}
for (int i = 1; i <= n / 2 + 1; i++) {
putchar('7');
}
putchar('\n');
} else {
int lead4 = 0, lead7 = 0, now = 1;
while (now <= n) {
if (a[now] < '4') {
break;
} else if (a[now] == '4' && lead4 < n / 2) {
ans[now] = '4';
lead4++;
now++;
} else if (a[now] < '7' && lead7 < n / 2) {
ans[now] = '7';
lead7++;
break;
} else if (a[now] == '7' && lead7 < n / 2) {
ans[now] = '7';
lead7++;
now++;
} else {
goto TRY_LAST_USE_7;
}
}
if (false) {
TRY_LAST_USE_7:
while (--now) {
if (ans[now] == '4') {
lead4--;
} else {
lead7--;
}
if (ans[now] < '7' && lead7 < n / 2) {
ans[now] = '7';
lead7++;
goto OUTPUT;
}
}
goto ODD_N;
}
OUTPUT:
for (int i = 1; i <= lead4 + lead7; i++) {
putchar(ans[i]);
}
for (int i = 1; i <= n / 2 - lead4; i++) {
putchar('4');
}
for (int i = 1; i <= n / 2 - lead7; i++) {
putchar('7');
}
putchar('\n');
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int q = 0, cc = 0;
int z = 0;
int w = 0, e = 0;
if (a == b) {
cc;
cc = b;
cout << cc << " ";
}
if (a > b) {
z = b;
cout << z << " ";
a = a - b;
if (a % 2 == 0) {
q = a / 2;
a = 0;
}
if (a % 2 != 0) {
q = a / 2;
a = 0;
}
}
if (a < b && a != 0) {
w = a;
cout << w << " ";
b = b - a;
if (b % 2 == 0) {
e = b / 2;
b = 0;
}
if (b % 2 != 0) {
e = b / 2;
b = 0;
}
}
cout << e + q;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 3e5 + 10;
int n;
vector<int> g[maxn];
long long fpow(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = r * a % mod;
b >>= 1;
a = a * a % mod;
}
return r;
}
long long dp[maxn][2][2], res[maxn], tp[maxn][2][2], sum[maxn], ans[maxn];
void dfs(int u, int fa) {
res[u] = 1;
dp[u][0][0] = dp[u][0][1] = 1;
sum[u] = 0;
for (auto it : g[u]) {
if (it == fa) continue;
dfs(it, u);
res[u] =
(res[u] * (dp[it][1][0] + dp[it][1][1] + res[it]) % mod + mod) % mod;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) tp[u][i][j] = dp[u][i][j];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (i == 0) {
tp[u][i][j] =
(dp[u][i][j] * (dp[it][1][0] + dp[it][1][1] + res[it]) % mod) %
mod;
} else {
if (j == 0) {
tp[u][i][j] =
(dp[u][i][j] *
(sum[it] + (dp[it][1][0] + dp[it][1][1] + res[it])) % mod +
dp[u][0][j] * sum[it] % mod) %
mod;
} else {
tp[u][i][j] = (dp[u][i][j] *
(dp[it][0][0] + dp[it][1][0] + dp[it][1][0] +
dp[it][1][1] + res[it]) %
mod +
dp[u][0][j] * (dp[it][0][0] + dp[it][1][0]) % mod) %
mod;
}
}
}
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) dp[u][i][j] = tp[u][i][j];
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) sum[u] = (sum[u] + dp[u][i][j]) % mod;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
printf("%lld\n", (dp[1][1][0] + dp[1][1][1] + res[1] - 1 + mod) % mod);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, q, l[N], r[N], u[N], d[N], ans = 2e9;
int f[N][2];
char ch[N];
int Min(int x, int y) { return x < y ? x : y; }
void tomin(int &x, int y) {
if (y < x) x = y;
}
int solve() {
int c0 = 0, c1 = 0, res = 0;
for (int j = 1; j <= m; j++) {
if (u[j] == 1)
c1++;
else
c0++;
}
f[0][0] = c1;
f[0][1] = c0;
for (int i = 1; i <= n; i++) {
c1 = l[i] + r[i];
c0 = 2 - c1;
f[i][0] = Min(f[i - 1][0], f[i - 1][1] + m) + c1;
f[i][1] = Min(f[i - 1][1], f[i - 1][0] + m) + c0;
}
c0 = c1 = 0;
for (int j = 1; j <= m; j++) {
if (d[j] == 1)
c1++;
else
c0++;
}
return Min(f[n][0] + c1, f[n][1] + c0);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
scanf("%s", ch + 1);
for (int i = 1; i <= n; i++) l[i] = (ch[i] == 'B');
scanf("%s", ch + 1);
for (int i = 1; i <= n; i++) r[i] = (ch[i] == 'B');
scanf("%s", ch + 1);
for (int i = 1; i <= m; i++) u[i] = (ch[i] == 'B');
scanf("%s", ch + 1);
for (int i = 1; i <= m; i++) d[i] = (ch[i] == 'B');
tomin(ans, solve());
swap(n, m);
swap(l, u);
swap(r, d);
tomin(ans, solve());
printf("%d", ans);
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x[] = {0, 0, 0, 0, 2, 4};
void in() { scanf("%d%d", &n, &m); }
void ac() {
if (n > m) swap(n, m);
if (n == 1)
printf("%d", m / 6 * 6 + x[m % 6]);
else if (n == 2) {
if (m == 2)
puts("0");
else if (m == 3)
puts("4");
else if (m == 7)
puts("12");
else
printf("%lld", 1ll * n * m);
} else
printf("%lld", n % 2 && m % 2 ? 1ll * n * m - 1 : 1ll * n * m);
}
int main() {
in();
ac();
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int N = 2e6 + 1;
const long long mod = 1e9 + 7;
void solve() {
int m = 6;
vector<int> arr(m);
for (int i = 0; i < m; i++) {
cin >> arr[i];
}
int n;
cin >> n;
vector<array<int, 2>> store;
vector<int> freq(n, 0);
int cnt = 0;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
for (int j = 0; j < m; j++) {
store.push_back({temp - arr[j], i});
}
}
sort(store.begin(), store.end());
int l = 0, r = 0;
int ans = 2e9 + 10;
while (l < store.size()) {
while (r < store.size()) {
if (cnt == n) {
ans = min(ans, store[r - 1][0] - store[l][0]);
break;
}
freq[store[r][1]]++;
if (freq[store[r][1]] == 1) {
cnt++;
}
r++;
}
if (r > store.size()) break;
freq[store[l][1]]--;
if (freq[store[l][1]] == 0) {
cnt--;
}
l++;
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
std::cout << std::fixed << std::setprecision(20);
;
int t = 1;
while (t--) {
solve();
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, d;
cin >> x;
d = x;
vector<int> vec, vec2;
while (x--) {
int q, r;
cin >> q >> r;
vec.push_back(q);
vec2.push_back(r);
}
int c = 0;
for (int i = 0; i < vec.size(); i++) {
for (int j = 0; j < vec2.size(); j++)
if (i != j && vec[i] == vec2[j]) {
c++;
break;
}
}
cout << d - c << endl;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int t;
int a[1005], b[1005], c[1005];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
int i;
scanf("%d", &t);
for (i = 2; i <= t; i++) {
scanf("%d", &a[i]);
b[a[i]]++;
}
for (i = 2; i <= t; i++) {
if (b[i] == 0) {
c[a[i]]++;
}
}
for (i = 1; i <= t; i++) {
if (c[i] != 0 && c[i] < 3) {
printf("No\n");
return 0;
}
if (b[i] != 0 && c[i] == 0) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
int main() {
ios_base::sync_with_stdio(1);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m;
if (m == 0) {
cout << n << ' ' << n;
return 0;
}
long long i = 1;
for (i; i <= n; i++)
if ((long long)i * (i - 1) / 2 >= (long long)m) break;
cout << max((long long)0, n - m * 2) << ' ' << n - i;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long d[10];
long long mem[105][15][15];
long long mod = 1e9 + 7;
long long ncr[105][105];
long long get_ncr(long long n, long long r) {
if (n < r) return 0;
if (n == r || r == 0) return 1;
if (ncr[n][r] != -1) return ncr[n][r];
ncr[n][r] = get_ncr(n - 1, r - 1) + get_ncr(n - 1, r);
ncr[n][r] %= mod;
return ncr[n][r];
}
long long doit(long long id, long long dg, long long fd) {
if (id < 0) return 0;
long long i;
if (id == 0) {
for (i = dg; i <= 9; i++)
if ((d[i] && fd != i) || (fd == i && d[i] > 1)) return 0;
return 1;
}
if (dg > 9) return 0;
long long rt = 0, rr = d[dg];
if (dg == fd) rr = max(0LL, rr - 1);
if (dg <= 9 && id < rr) return 0;
if (mem[id][dg][fd] != -1) return mem[id][dg][fd];
for (i = rr; i <= id; i++) {
rt += get_ncr(id, i) * doit(id - i, dg + 1, fd);
rt %= mod;
}
return mem[id][dg][fd] = rt;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, j, x, y, n, m, cnt = 0, k, g, flg, t, a, b;
memset(mem, -1, sizeof(mem));
memset(ncr, -1, sizeof(ncr));
cin >> n;
for (i = 0; i <= 9; i++) {
cin >> d[i];
cnt += d[i];
}
long long an = 0;
for (i = cnt; i <= n; i++) {
for (j = 1; j <= 9; j++) {
x = doit(i - 1, 0, j);
an += doit(i - 1, 0, j);
an %= mod;
}
}
cout << an << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
map<int, int> m;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
for (int j = 1; j <= k; ++j) m[x * j] = j;
}
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
map<int, int>::iterator l = m.begin(), r = m.end();
r--;
int res = 1e9;
while (l->first < r->first) {
if (l->first == x) {
res = min(res, l->second);
l++;
} else if (r->first == x) {
res = min(res, r->second);
r--;
} else if (r->first + l->first == x) {
res = min(res, r->second + l->second);
l++, r--;
} else if (r->first + l->first > x) {
r--;
} else {
l++;
}
}
if (l->first == x) res = min(res, l->second);
if (res <= k)
cout << res << endl;
else
cout << -1 << endl;
}
return 0;
}
| 11 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll rd(){
char c=getchar();ll s=0;bool f=1;
for(;c<'0'||c>'9';c=getchar())if(c=='-')f=0;
for(;c>='0'&&c<='9';c=getchar())s=(s<<3)+(s<<1)+(c^48);
return f?s:~(s-1);
}
inline void wt1(ll x){if(x>=10)wt1(x/10);putchar('0'+x%10);}
inline void wt(ll x){if(x<0)x=~(x-1),putchar('-');wt1(x);}
inline void wtl(ll x){wt(x);puts("");}
inline void wtb(ll x){wt(x);putchar(' ');}
int a[40],b[40],ha,hb;
int u,v;
int c1,c2;
inline void work(){
ha=0;hb=0;
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
u=rd();v=rd();
if(u>v){
puts("NO");
return;
}
do{
a[++ha]=u%2;
u>>=1;
}while(u);
do{
b[++hb]=v%2;
v>>=1;
}while(v);
c1=0;c2=0;
for(int i=1;i<=max(ha,hb);++i){
if(a[i])++c1;
if(b[i])++c2;
if(c2>c1){
puts("NO");
return;
}
}
puts("YES");
}
int main(){
for(register int t=rd();t;--t){
work();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
set<int> S;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
if (t != 0) S.insert(t);
}
printf("%d\n", (int)S.size());
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int kNmax = 110;
const int kMod = 1e9 + 7;
int n, x, dp[kNmax][kNmax][kNmax][4], pw_fib[kNmax];
string s;
int main() {
pw_fib[0] = pw_fib[1] = 2;
for (int i = 2; i < kNmax; i++) {
pw_fib[i] = (1LL * pw_fib[i - 1] * pw_fib[i - 2]) % kMod;
}
cin >> n >> x >> s;
s = " " + s;
for (int i = 1; i <= n; i++) {
if (s[i] == '0')
dp[0][i][i][0] = dp[0][i][i][1] = dp[0][i][i][2] = dp[0][i][i][3] = 1;
if (s[i] == '1')
dp[1][i][i][0] = dp[1][i][i][1] = dp[1][i][i][2] = dp[1][i][i][3] = 1;
}
for (int i = 2; i <= x; i++) {
for (int left = 1; left <= n; left++) {
for (int right = left; right <= n; right++) {
for (int type = 0; type < 4; type++) {
if (type & 1)
dp[i][left][right][type] =
(1LL * pw_fib[i - 1] * dp[i - 2][left][right][type]) % kMod;
else
dp[i][left][right][type] = dp[i - 2][left][right][type];
if (type & 2)
dp[i][left][right][type] =
(dp[i][left][right][type] +
1LL * pw_fib[i - 2] * dp[i - 1][left][right][type]) %
kMod;
else
dp[i][left][right][type] =
(dp[i][left][right][type] + dp[i - 1][left][right][type]) %
kMod;
for (int k = left; k < right; k++) {
int type_left = type;
if (type_left & 2) type_left -= 2;
int type_right = type;
if (type_right & 1) type_right -= 1;
dp[i][left][right][type] =
(dp[i][left][right][type] +
1LL * dp[i - 1][left][k][type_left] *
dp[i - 2][k + 1][right][type_right]) %
kMod;
}
}
}
}
}
cout << dp[x][1][n][3];
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
bool lower(int a, int b) {
printf("? %d %d\n", a, b);
fflush(stdout);
char c;
scanf(" %c", &c);
return c == '<';
}
int main() {
int test;
scanf("%d", &test);
while (test--) {
int n;
scanf("%d", &n);
if (n == 1) {
printf("! 1 1\n");
fflush(stdout);
continue;
}
vector<int> low, high;
for (int i = 2; i <= n; i += 2) {
if (lower(i - 1, i)) {
low.push_back(i - 1);
high.push_back(i);
} else {
low.push_back(i);
high.push_back(i - 1);
}
}
if (n % 2) {
low.push_back(n);
high.push_back(n);
}
int min = low[0];
for (int i = 1; i < low.size(); i++)
if (lower(low[i], min)) min = low[i];
int max = high[0];
for (int i = 1; i < high.size(); i++)
if (lower(max, high[i])) max = high[i];
printf("! %d %d\n", min, max);
fflush(stdout);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
double a, b, res = 1;
cin >> a >> b;
if (b == 0)
res = 1;
else if (a == 0)
res = 0.5;
else {
double s, ss = (a * 2 * b);
if (a / 4.0 <= b)
s = (b - a / 4.0) * a + a * (a / 4.0) / 2;
else
s = 2 * b * b;
res = (ss - s) / ss;
}
cout << setprecision(6) << fixed << res << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const long long N = 5050, M = 998244353;
long long dp[N][N];
long long a[N];
long long pre[N];
long long inv[N];
long long b[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= n; i++) {
inv[i] = exp(i, M - 2, M);
}
sort(a + 1, a + 1 + n);
long long id = 0;
for (long long i = 1; i <= n;) {
long long cur = a[i];
long long tam = 0;
while (i <= n and a[i] == cur) {
tam++;
i++;
}
b[++id] = tam;
}
long long K = id;
for (long long i = 1; i <= K; i++) {
dp[i][1] = mod(inv[n] * b[i], M);
}
for (long long j = 2; j <= K; j++) {
if (n - j + 1 == 0) break;
for (long long i = 1; i <= K; i++) pre[i] = 0;
for (long long i = 1; i <= K; i++) {
pre[i + 1] = mod(pre[i + 1] + mod(dp[i][j - 1] * inv[(n - j + 1)], M), M);
}
for (long long i = 1; i <= K; i++) pre[i] = mod(pre[i] + pre[i - 1], M);
for (long long i = 1; i <= K; i++) {
dp[i][j] = mod(b[i] * pre[i], M);
}
}
long long res = 0;
for (long long j = 1; j <= K; j++) {
if (j == n) break;
for (long long i = 1; i <= K; i++) {
long long num = b[i] - 1;
if (num == 0) continue;
res = mod(res + mod(dp[i][j] * mod(num * inv[n - j], M), M), M);
}
}
cout << res << "\n";
}
| 15 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int> > neg, pos;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
if (a < 0)
neg.push_back({-a, b});
else
pos.push_back({a, b});
}
sort(neg.begin(), neg.end());
sort(pos.begin(), pos.end());
int sum = 0;
if (neg.size() < pos.size()) {
for (auto &i : neg) sum += i.second;
for (int i = 0; i < neg.size() + 1; ++i) sum += pos[i].second;
} else if (neg.size() == pos.size()) {
for (auto &i : neg) sum += i.second;
for (auto &i : pos) sum += i.second;
} else if (neg.size() > pos.size()) {
for (auto &i : pos) sum += i.second;
for (int i = 0; i < pos.size() + 1; ++i) sum += neg[i].second;
}
cout << sum;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T Max(T a, T b) {
if (a > b)
return a;
else
return b;
}
template <class T>
inline T Min(T a, T b) {
if (a < b)
return a;
else
return b;
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T TripleMax(T a, T b, T c) {
return Max(Max(a, b), c);
}
template <class T>
inline T TripleMin(T a, T b, T c) {
return Min(Min(a, b), c);
}
const long long llinfinity = 9223372036854775807LL;
const long long llminusinfinity = -9223372036854775808LL;
const int intinfinity = 2147483647;
const int intminusinfinity = -2147483648;
const int maxn = 100005;
int n, m;
int color[maxn];
int main(int argc, const char* argv[]) {
memset(color, 0, sizeof(color));
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int a[3];
for (int j = 0; j < 3; ++j) {
scanf("%d", &a[j]);
}
int hsh[3];
memset(hsh, 0, sizeof(hsh));
for (int j = 0; j < 3; ++j) {
if (color[a[j]] != 0) {
hsh[color[a[j]] - 1] = 1;
}
}
for (int j1 = 0; j1 < 3; ++j1) {
if (color[a[j1]] == 0) {
for (int j2 = 0; j2 < 3; ++j2) {
if (hsh[j2] == 0) {
color[a[j1]] = j2 + 1;
hsh[j2] = 1;
break;
}
}
}
}
}
for (int i = 1; i < n + 1; ++i) {
printf("%d ", color[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int d[100000];
int s[100000];
queue<int> q;
int main() {
int n;
long long sum = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", d + i, s + i);
sum += d[i];
if (d[i] == 1) {
q.push(i);
}
}
printf("%I64d\n", sum / 2);
while (!q.empty()) {
int tmp = q.front();
q.pop();
if (d[tmp] != 1) continue;
printf("%d %d\n", tmp, s[tmp]);
d[s[tmp]]--;
s[s[tmp]] ^= tmp;
d[tmp]--;
if (d[s[tmp]] == 1) q.push(s[tmp]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int A[100005];
int bsearch(int q, int l, int r) {
if (l == r - 1) {
return l;
}
int mid = (l + r) / 2;
if (A[mid - 1] < q && q <= A[mid]) {
return mid;
} else if (q <= A[mid - 1]) {
return bsearch(q, l, mid);
} else {
return bsearch(q, mid, r);
}
return -1;
}
int main() {
int N;
cin >> N;
A[0] = 0;
for (int i = 1; i <= N; ++i) {
cin >> A[i];
A[i] += A[i - 1];
}
int M, query;
cin >> M;
for (int i = 0; i < M; ++i) {
cin >> query;
cout << bsearch(query, 0, N + 1) << endl;
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define int long long
//#define PI pair<int,int>
using namespace std;
const int maxm=205;
const int maxd=20;
const int mod=1e9+7;
vector<int>g[maxm];
int d[maxm][maxm];
int f[maxm][25];
int dep[maxm];
int n;
int ppow(int a,int b,int mod){
int ans=1%mod;a%=mod;
while(b){
if(b&1)ans=ans*a%mod;
a=a*a%mod;
b>>=1;
}
return ans;
}
void dfs(int x,int fa){
f[x][0]=fa;dep[x]=dep[fa]+1;
for(int j=1;j<=maxd;j++){
f[x][j]=f[f[x][j-1]][j-1];
}
for(int v:g[x]){
if(v==fa)continue;
dfs(v,x);
}
}
int lca(int x,int y){
if(dep[x]<dep[y])swap(x,y);
for(int i=maxd;i>=0;i--){
if(dep[f[x][i]]>=dep[y]){
x=f[x][i];
}
}
if(x==y)return x;
for(int i=maxd;i>=0;i--){
if(f[x][i]!=f[y][i]){
x=f[x][i];
y=f[y][i];
}
}
return f[x][0];
}
void solve(){
cin>>n;
for(int i=1;i<n;i++){
int a,b;cin>>a>>b;
g[a].push_back(b);
g[b].push_back(a);
}
//dp预处理
//d[i][j]为左边i个数右边j个数,左边先取完的概率.
int inv2=ppow(2,mod-2,mod);
for(int i=1;i<=n;i++){
d[0][i]=1;
d[i][0]=0;
}
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
d[i][j]=(d[i-1][j]+d[i][j-1])*inv2%mod;
}
}
//
int ans=0;
for(int i=1;i<=n;i++){//枚举根
dfs(i,0);
for(int x=1;x<=n;x++){
for(int y=1;y<x;y++){
int lc=lca(x,y);
int len1=dep[x]-dep[lc];
int len2=dep[y]-dep[lc];
ans=(ans+d[len1][len2])%mod;
}
}
}
//
ans=ans*ppow(n,mod-2,mod)%mod;
cout<<ans<<endl;
}
signed main(){
ios::sync_with_stdio(0);cin.tie(0);
// int T;scanf("%d",&T);while(T--)
// int T;cin>>T;while(T--)
solve();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
long long n, k, ft[N];
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
long long get(vector<int> v) {
long long ans = 0;
long long cif[10];
unordered_set<int> use;
memset(cif, 0, sizeof cif);
for (auto i : v) cif[i] = 1;
for (int ii = 0; ii < (1 << v.size()); ii++) {
int f[10];
memset(f, 0, sizeof f);
for (int j = 0; j < v.size(); j++) {
if ((1 << j) & ii) f[v[j]]++;
}
int ok = 1;
for (int i = 0; i < 10; i++)
if (cif[i] && !f[i]) ok = 0;
if (!ok) continue;
long long mask = 0;
for (int i = 0; i < 10; i++) {
mask = mask * 20 + f[i];
}
if (use.count(mask)) continue;
use.insert(mask);
long long tmp = ft[__builtin_popcount(ii)];
for (int i = 0; i < 10; i++) tmp /= ft[f[i]];
;
;
ans += tmp;
}
return ans;
}
long long get2(vector<int> v) {
long long ans = 0;
long long cif[10];
unordered_set<int> use;
memset(cif, 0, sizeof cif);
for (auto i : v) cif[i] = 1;
for (int ii = 0; ii < (1 << v.size()); ii++) {
int f[10];
memset(f, 0, sizeof f);
for (int j = 0; j < v.size(); j++) {
if ((1 << j) & ii) f[v[j]]++;
}
int ok = 1;
for (int i = 1; i < 10; i++)
if (cif[i] && !f[i]) ok = 0;
if (!ok) continue;
long long mask = 0;
for (int i = 0; i < 10; i++) {
mask = mask * 20 + f[i];
}
if (use.count(mask)) continue;
use.insert(mask);
long long tmp = ft[__builtin_popcount(ii)];
for (int i = 0; i < 10; i++) tmp /= ft[f[i]];
;
;
ans += tmp;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
ft[0] = 1;
for (int i = 1; i < 20; i++) ft[i] = ft[i - 1] * i;
vector<int> v;
while (n) {
v.push_back(n % 10);
n /= 10;
}
sort(v.begin(), v.end());
long long ans = get(v);
if (v[0] == 0) {
swap(v[0], v[v.size() - 1]);
v.pop_back();
sort(v.begin(), v.end());
long long scad = get2(v);
;
ans -= scad;
}
cout << ans << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
bool flag[2000010];
int a[maxn], b[2 * maxn];
int n, m, cc;
int main() {
for (int i = 2; i <= 2000000; i++)
if (!flag[i]) {
b[cc++] = i;
for (int j = i * 2; j <= 2000000; j += i) flag[j] = 1;
}
scanf("%d%d", &n, &m);
m--;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
if (m == 1) {
printf("0\n");
return 0;
}
if (a[0] == 1) {
printf("1\n");
return 0;
}
for (int i = 0, j = 0; i < n; i++)
if (a[i] == b[j]) {
if (b[j + 1] - 1 >= m) {
printf("%d\n", j + 1);
return 0;
}
j++;
}
printf("-1\n");
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<char>> adj;
bool vis[2001][2001];
int d[2001][2001];
int main() {
int r, c, x, y, n, m;
cin >> n >> m >> r >> c >> x >> y;
--r;
--c;
adj.resize(n);
for (int i = 0; i < n; ++i) {
adj[i].resize(m);
for (int j = 0; j < m; ++j) {
cin >> adj[i][j];
d[i][j] = 1000000000;
}
}
deque<pair<int, int>> bfs;
bfs.push_front({r, c});
d[r][c] = 0;
while (!bfs.empty()) {
auto now = bfs.front();
bfs.pop_front();
int cur_x = now.first, cur_y = now.second;
if (vis[cur_x][cur_y]) {
continue;
}
vis[cur_x][cur_y] = 1;
if (cur_x > 0 && adj[cur_x - 1][cur_y] != '*' &&
d[cur_x - 1][cur_y] > d[cur_x][cur_y]) {
d[cur_x - 1][cur_y] = d[cur_x][cur_y];
bfs.push_front({cur_x - 1, cur_y});
}
if (cur_x < n - 1 && adj[cur_x + 1][cur_y] != '*' &&
d[cur_x + 1][cur_y] > d[cur_x][cur_y]) {
d[cur_x + 1][cur_y] = d[cur_x][cur_y];
bfs.push_front({cur_x + 1, cur_y});
}
if (cur_y > 0 && adj[cur_x][cur_y - 1] != '*' &&
d[cur_x][cur_y - 1] > d[cur_x][cur_y] + 1) {
d[cur_x][cur_y - 1] = d[cur_x][cur_y] + 1;
bfs.push_back({cur_x, cur_y - 1});
}
if (cur_y < m - 1 && adj[cur_x][cur_y + 1] != '*' &&
d[cur_x][cur_y + 1] > d[cur_x][cur_y]) {
d[cur_x][cur_y + 1] = d[cur_x][cur_y];
bfs.push_front({cur_x, cur_y + 1});
}
}
int ans = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (d[i][j] < 1000000000 && d[i][j] <= x && j - c + d[i][j] <= y) {
++ans;
}
}
cout << ans << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxn = 3e5 + 5;
const long long SQ = 317;
long long dp[15][15][15][15];
long long zez[16];
long long fact[16];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
for (long long i = 1; i < 16; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
long long kek = 1;
for (long long i = 0; i < 15; i++) {
zez[i] = kek;
kek *= 3;
}
zez[15] = kek;
for (long long jj = 0; jj <= 15; jj++) {
for (long long i = 0; i < zez[jj]; i++) {
long long zz = i;
long long cnt[3] = {};
long long last = -1;
bool fl = 1;
for (long long j = 0; j < jj; j++) {
if (zz % 3 == last) fl = 0;
cnt[zz % 3]++;
last = zz % 3;
zz /= 3;
}
dp[cnt[0]][cnt[1]][cnt[2]][cnt[0] + cnt[1] + cnt[2]] += fl;
(dp[cnt[0]][cnt[1]][cnt[2]][cnt[0] + cnt[1] + cnt[2]]) %= mod;
}
}
long long n, x;
cin >> n >> x;
long long t[n], g[n];
for (long long i = 0; i < n; i++) {
cin >> t[i] >> g[i];
}
long long ans = 0;
for (long long msk = 0; msk < (1 << n); msk++) {
vector<long long> a;
long long xx = 0;
long long cnt[3] = {};
for (long long j = 0; j < n; j++) {
if ((1 << j) & msk) {
xx += t[j];
a.push_back(g[j]);
cnt[g[j] - 1]++;
}
}
if (xx != x) continue;
ans +=
(dp[cnt[0]][cnt[1]][cnt[2]][cnt[0] + cnt[1] + cnt[2]] * fact[cnt[0]]) %
mod * (fact[cnt[1]] * fact[cnt[2]]) % mod;
ans %= mod;
}
cout << ans;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e6 + 3;
const int INFI = 1e9 * 2;
const long long LINFI = 1e17;
const double pi = acos(-1.0);
const int N = 22;
const int M = 222222;
const int move[8][2] = {1, 0, -1, 0, 0, 1, 0, -1, 1, 1, 1, -1, -1, 1, -1, -1};
char a[3][N], d[5] = "FMS?";
bool win(char x, char y) {
if (x == 's' && y == 'p') return 1;
if (x == 'p' && y == 'r') return 1;
if (x == 'r' && y == 's') return 1;
return 0;
}
int solve() {
if (win(a[0][0], a[1][0]) && win(a[0][0], a[2][0])) return 0;
if (win(a[1][0], a[0][0]) && win(a[1][0], a[2][0])) return 1;
if (win(a[2][0], a[0][0]) && win(a[2][0], a[1][0])) return 2;
return 3;
}
int main() {
while (cin >> a[0] >> a[1] >> a[2]) cout << d[solve()] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> p1, pair<int, int> p2) {
if (p1.first == p2.first) {
return p1.second < p2.second;
} else {
return p1.first > p2.first;
}
}
int fc(int k, int pos, vector<pair<int, int> > a, vector<int> b) {
vector<int> y;
for (int i = 0; i < k; i++) {
y.push_back(a[i].second);
}
sort(y.begin(), y.end());
return y[pos - 1];
}
int main() {
int n;
cin >> n;
vector<pair<int, int> > a(n);
vector<int> b(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
b[i] = a[i].first;
}
sort(a.begin(), a.end(), cmp);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int k, pos;
cin >> k >> pos;
int x = fc(k, pos, a, b);
cout << b[x] << endl;
}
return 0;
}
| 8 |
Subsets and Splits