solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2005;
string arr[maxN], dir = "v^><";
int n, m, cnt = 0;
int d[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
bool check(int i, int j) {
if (i >= 0 and i < n and j >= 0 and j < m) {
return 1;
}
return 0;
}
int dfs(int u, int v, int dept) {
cnt++;
int ans = dept, i, j, k;
for (i = 0; i < 4; i++) {
int U = u + d[i][0], V = v + d[i][1];
if (check(U, V) and dir[i] == arr[U][V]) {
ans = max(ans, dfs(U, V, dept + 1));
}
}
return ans;
}
void solve() {
int i, j, k, l, p, q, u = 0, v = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (arr[i][j] == '#') {
cnt++;
for (k = 0; k < 4; k++) {
int U = i + d[k][0], V = j + d[k][1];
if (check(U, V) and dir[k] == arr[U][V]) {
int ans = dfs(U, V, 1);
if (ans > u) {
u = ans;
v = ans - 1;
} else if (ans > v) {
v = ans;
}
}
}
}
}
}
int ans = (cnt < n * m) ? -1 : u + v;
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
int i, j, k;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int t, i, j, k, n, x, y, z, r, l, a, c, b, q, T, d, m;
cin >> n;
long long int first = ceil(double(n) / 3);
long long int first1 = (n) / 3;
long long int second = (n - first) / 2;
if ((first * 1 + (second)*2) == n)
cout << first << " " << second << "\n";
else {
cout << second << " " << first << "\n";
}
}
int main() {
long long int t;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int days[13] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
queue<long long> Q;
int n, m;
char s[10000100];
int main() {
cin >> n >> m;
int tot = 0;
while (scanf("%s", s) != EOF) {
++tot;
long long now = 0;
int MMM = (s[5] - '0') * 10 + s[6] - '0';
int DD = (s[8] - '0') * 10 + s[9] - '0';
for (int i = 1; i < MMM; ++i) {
now += days[i];
}
now += DD - 1;
now *= 24 * 60 * 60;
int HH, MM, SS;
scanf("%d:%d:%d:", &HH, &MM, &SS);
gets(s);
now += HH * 60 * 60 + MM * 60 + SS;
Q.push(now);
while (Q.front() <= now - n) Q.pop();
if (Q.size() >= m) {
printf("2012-%02d-%02d %02d:%02d:%02d", MMM, DD, HH, MM, SS);
return 0;
}
}
puts("-1");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int c[120];
int n, a, b;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> a >> b;
for (int i = 0; i < a; i++) {
int t;
cin >> t;
c[t] = 1;
}
for (int i = 0; i < b; i++) {
int t;
cin >> t;
c[t] = 2;
}
for (int i = 1; i <= n; i++) cout << c[i] << " ";
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, sume, sumo, sum1, sum2;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (a % 2 == 0)
sume++;
else
sumo++;
}
for (int i = 0; i < m; i++) {
scanf("%d", &a);
if (a % 2 == 0)
sum1++;
else
sum2++;
}
printf("%d\n", (min(sumo, sum1) + min(sum2, sume)));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int v[N];
set<int> s;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> v[i];
if (v[1] != 0) return cout << 1, 0;
int p(0);
for (int i = 2; i <= n; ++i) {
if (p < v[i] - 1) return cout << i, 0;
s.insert(v[i]);
while (s.find(p + 1) != s.end()) ++p;
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum1 = 0, sum2 = 0;
cin >> n;
string str;
cin >> str;
for (int i = 0; i < n; i++) {
sum1 += str[i];
}
for (int j = n; j < 2 * n; j++) {
sum2 += str[j];
}
if (sum1 == sum2)
cout << "NO" << endl;
else {
int more = 0, les = 0, eqal = 0;
string str1;
string str2;
for (int i = 0; i < n; i++) {
str1 += str[i];
}
for (int i = n; i < 2 * n; i++) {
str2 += str[i];
}
sort(str1.begin(), str1.end());
sort(str2.begin(), str2.end());
for (int i = 0; i < n; i++) {
if (str1[i] > str2[i]) more++;
if (str1[i] < str2[i]) les++;
if (str1[i] == str2[i]) eqal++;
}
if (eqal > 0 || (les > 0 && more > 0))
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, p, check = 0;
scanf("%d%d", &n, &p);
char a[n];
scanf("%s", a);
a[-1] = 0;
a[-2] = 0;
for (int i = n - 1; i >= 0; i--) {
for (int z = 1; a[i] + z <= 96 + p; z++)
if ((a[i] + z) != a[i - 1] && (a[i] + z) != a[i - 2]) {
a[i] = a[i] + z;
for (int j = i + 1; j <= n - 1; j++) {
for (int k = 97; k <= 99; k++)
if (k != a[j - 1] && k != a[j - 2]) {
a[j] = k;
k = 100;
}
}
check = 1;
z = 130;
i = -1;
}
}
if (check == 0)
printf("NO");
else
for (int i = 0; i < n; i++) printf("%c", a[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, b1, c1, a2, b2, c2;
cin >> a1 >> b1 >> c1 >> a2 >> b2 >> c2;
if (a1 == 0 && b1 == 0 && c1 != 0 || a2 == 0 && b2 == 0 && c2 != 0)
printf("0\n");
else if (a1 * b2 == a2 * b1) {
if (b1 * c2 == b2 * c1 && a1 * c2 == a2 * c1)
printf("-1\n");
else
printf("0\n");
} else
printf("1\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, f;
const int b = 2520;
float m;
cin >> n;
m = n / b;
f = m;
cout << f;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 4;
int inp;
set<int> s;
while (i) {
i--;
cin >> inp;
s.insert(inp);
}
cout << 4 - s.size();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, s[102];
while (cin >> a >> b) {
for (int i = 0; i < a; i++) cin >> s[i];
sort(s, s + a);
cout << s[a - b] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
struct point {
long double x, y, v;
} p[2001], num[2001];
int a[2001], b[2001], c[2001], V[2001];
bool cmp(point a, point b) { return a.v < b.v; }
bool same(int x, int y) {
return 1ll * (a[x] * c[x]) * (a[y] * a[y] + b[y] * b[y]) ==
1ll * (a[y] * c[y]) * (a[x] * a[x] + b[x] * b[x]) &&
1ll * (b[x] * c[x]) * (a[y] * a[y] + b[y] * b[y]) ==
1ll * (b[y] * c[y]) * (a[x] * a[x] + b[x] * b[x]);
}
bool samex(int x, int y) {
return 1ll * (a[x] * c[x]) * (a[y] * a[y] + b[y] * b[y]) ==
1ll * (a[y] * c[y]) * (a[x] * a[x] + b[x] * b[x]);
}
bool cross(point a, point b) { return fabs(a.x * b.y - b.x * a.y) > 1e-12; }
int n, top;
int main() {
scanf("%d", &n);
for (int i = 1, a, b, c; i <= n; i++) {
scanf("%d%d%d", &a, &b, &c);
::a[i] = a;
::b[i] = b;
::c[i] = c;
V[i] = a * a + b * b;
p[i] = (point){(long double)(a * c), (long double)(b * c), 0};
}
int ans = 0;
for (int i = 1; i <= n; i++) {
top = 0;
for (int j = 1; j <= n; j++)
if (i != j) {
if (same(i, j))
ans += n - 2;
else {
num[++top] =
(point){p[i].x * (long double)V[j] - p[j].x * (long double)V[i],
p[i].y * (long double)V[j] - p[j].y * (long double)V[i]};
if (num[top].x < 0 || (samex(i, j) && num[top].y < 0))
num[top].x = -num[top].x, num[top].y = -num[top].y;
num[top].v = atan2(num[top].y, num[top].x);
}
}
std::sort(num + 1, num + top + 1, cmp);
for (int j = 1, last = 0; j <= top; j++) {
if (j > 1 && cross(num[j], num[j - 1])) last = 0;
ans += last;
++last;
}
}
printf("%d\n", ans / 3);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
cin >> a;
while (a % 3 == 0) {
a /= 3;
}
cout << a / 3 + 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void parseArray(long long* A, long long n) {
for (long long K = 0; K < n; K++) {
cin >> A[K];
}
}
long long modInverse(long long a, long long b) {
return 1 < a ? b - modInverse(b % a, a) * b / a : 1;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long double dist(long double x, long double y, long double a, long double b) {
return sqrt((x - a) * (x - a) + (y - b) * (y - b));
}
void debug(long long* a, long long n) {
for (long long k = 0; k < n; k++) {
cerr << a[k] << " ";
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
long long _;
cin >> _;
while (_--) {
long long x, y;
cin >> x >> y;
long long a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
long long inc_x = min(b, a + c);
long long inc_y = min(f, e + a);
long long dec_x = min(e, d + f);
long long dec_y = min(c, d + b);
long long inc_xy = min(a, inc_x + inc_y);
long long dec_xy = min(d, dec_x + dec_y);
long long ans = 0;
swap(x, y);
if (x >= 0 && y >= 0) {
ans = min({
inc_x * x + inc_y * y,
inc_xy * min(x, y) + (x >= y ? inc_x * (x - y) : inc_y * (y - x)),
inc_xy * max(x, y) + (x >= y ? dec_y * (x - y) : dec_x * (y - x)),
});
} else if (x >= 0 && y <= 0) {
ans = inc_x * x + dec_y * -y;
} else if (x <= 0 && y >= 0) {
ans = dec_x * -x + inc_y * y;
} else if (x <= 0 && y <= 0) {
x = -x;
y = -y;
ans = min({
dec_x * x + dec_y * y,
dec_xy * min(x, y) + (x >= y ? dec_x * (x - y) : dec_y * (y - x)),
dec_xy * max(x, y) + (x >= y ? inc_y * (x - y) : inc_x * (y - x)),
});
}
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
bool isprime(long long num) {
for (long long i = 2; i * i <= num; ++i) {
if (num % i == 0) return false;
}
return true;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return ((a / gcd(a, b)) * b); }
long long cel(long long x1, long long y1) {
if ((x1) <= 0) return (x1) / (y1);
return (((x1) / (y1)) + (((x1) % (y1)) != 0));
}
void swap(long long int &a, long long int &b) {
a = a ^ b;
b ^= a;
a ^= b;
}
void givesubsequence(string s) {
int n = s.size();
int numberofsubsequence = (1 << n) - 1;
for (int i = 1; i <= numberofsubsequence; i++) {
int temp = i, j = 0;
while (temp > 0) {
if (temp & 1) cout << s[j];
j++;
temp = temp >> 1;
}
cout << endl;
}
}
float squareRoot(float n) {
float x = n;
float y = 1;
float e = 0.000001;
while (x - y > e) {
x = (x + y) / 2;
y = n / x;
}
return x;
}
int power(int x, unsigned int y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
int sum_of_digits(long long n) {
int res = 0;
while (n > 0) {
res += n % 10;
n /= 10;
}
return res;
}
const int N = 3e5 + 2;
int xo[N];
void presolve() {
for (int i = 1; i < N; i++) xo[i] = i ^ xo[i - 1];
}
void solve(int test_case) {
int a, b;
cin >> a >> b;
int ans = a, x = xo[a - 1];
int y = x ^ b;
if (x == b)
cout << ans << endl;
else if (y != a)
cout << ans + 1 << endl;
else
cout << ans + 2 << endl;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
clock_t start, end;
start = clock();
int tc = 1;
presolve();
cin >> tc;
while (tc--) {
solve(tc);
}
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, true : false;
}
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, k;
long long pl[505][505], val[505][505], d[505][505][2], aval[505][505],
nval[505][505], cnt[500005];
vector<pair<int, int> > bef[500005];
vector<pair<int, int> > v[505][505];
bool inmat(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
int main() {
n = readint();
m = readint();
k = readint();
int x, y, z, t, e;
for (int i = 1; i <= k; i++) {
x = readint();
y = readint();
z = readint();
t = readint();
e = readint();
int x1 = x, y1 = y, x2 = x + z, y2 = y - z, x3 = x + z, y3 = y, x4 = x,
y4 = y + z, t1 = 0, t2 = 0, t3 = 0, t4 = 0;
if (inmat(x1, y1) && (x1 + y1) % 4 == t % 4 && x1 + y1 >= t)
v[x1][y1].push_back(make_pair(e, i));
if (inmat(x2, y2) && (x2 + y2) % 4 == (t + 1) % 4 && x2 + y2 >= t + 1)
v[x2][y2].push_back(make_pair(e, i));
if (inmat(x3, y3) && (x3 + y3) % 4 == (t + 2) % 4 && x3 + y3 >= t + 2)
v[x3][y3].push_back(make_pair(e, i));
if (inmat(x4, y4) && (x4 + y4) % 4 == (t + 3) % 4 && x4 + y4 >= t + 3)
v[x4][y4].push_back(make_pair(e, i));
cnt[i] = -1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (auto r : v[i][j]) pl[i][j] += r.first;
memset(d, 0x3f, sizeof(d));
d[0][0][0] = d[0][0][1] = pl[0][0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (auto r : v[i][j]) {
if (bef[r.second].size() >= 0) {
int pos = -1;
for (auto tr : bef[r.second]) {
if (tr.second == j) {
pos = tr.first;
break;
}
}
if (pos >= 0)
for (int k = pos + 1; k <= i; k++) aval[j][k] += r.first;
else
for (int k = i; k >= 0; k--) aval[j][k] += r.first;
} else {
for (int k = i; k >= 0; k--) aval[j][k] += r.first;
}
bef[r.second].push_back(make_pair(i, j));
}
}
for (int j = 0; j < m; j++)
for (int k = 0; k < i; k++)
chkmin(d[i][j][0], d[k][j][1] + aval[j][k] - pl[k][j]);
memset(val, 0, sizeof(val));
memset(nval, 0, sizeof(nval));
for (int j = 0; j < m; j++) {
for (auto r : v[i][j]) {
if (cnt[r.second] >= 0) {
val[0][cnt[r.second]] -= r.first, val[0][m] += r.first,
val[cnt[r.second] + 1][cnt[r.second]] += r.first,
val[cnt[r.second] + 1][m] -= r.first;
val[0][j] += r.first, val[0][m] -= r.first,
val[cnt[r.second] + 1][j] -= r.first,
val[cnt[r.second] + 1][m] += r.first;
val[0][cnt[r.second]] += r.first, val[0][j] -= r.first,
val[cnt[r.second] + 1][cnt[r.second]] -= r.first,
val[cnt[r.second] + 1][j] += r.first;
val[cnt[r.second] + 1][j] += r.first,
val[cnt[r.second] + 1][m] -= r.first, val[j + 1][j] -= r.first,
val[j + 1][m] += r.first;
} else {
val[0][j] += r.first, val[0][m] -= r.first, val[j + 1][j] -= r.first,
val[j + 1][m] += r.first;
cnt[r.second] = j;
}
}
}
for (int j = 0; j < m; j++)
for (auto r : v[i][j]) cnt[r.second] = -1;
for (int j = 0; j < m; j++)
for (int k = 0; k < m; k++)
val[j][k] += (k ? val[j][k - 1] : 0) + (j ? val[j - 1][k] : 0) -
(j && k ? val[j - 1][k - 1] : 0);
for (int j = 0; j < m; j++)
for (int k = 0; k < j; k++)
chkmin(d[i][j][1], d[i][k][0] + val[k][j] + nval[k][j] - pl[i][k]);
}
printf("%lld\n", min(d[n - 1][m - 1][0], d[n - 1][m - 1][1]));
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int total;
long long sum[5005];
string s;
int main() {
cin >> s;
long long temp = s[0] - '0', ans = 0;
sum[total++] = temp;
for (int i = 2; i < s.size(); i += 2) {
if (s[i - 1] == '+') {
sum[total++] = sum[total - 1] + s[i] - '0';
temp = s[i] - '0';
} else {
sum[total++] = sum[total - 1] + temp * (s[i] - '1');
temp *= s[i] - '0';
}
}
for (int i = 0; i < total; i++) {
long long su = 0, mul = 1, cur = i + 1, mu = 1, mid = s[i * 2] - '0',
temp = s[i * 2] - '0';
for (int j = i - 1; j >= 0; j--)
if (s[j * 2 + 1] == '*')
mul *= s[j * 2] - '0';
else {
su = sum[j];
break;
}
for (; cur < total && s[cur * 2 + 1] == '*'; cur++)
mu *= s[cur * 2 + 2] - '0';
for (int j = i + 1; j < total; j++) {
if (s[j * 2 - 1] == '+') {
temp = s[j * 2] - '0';
mid += temp;
} else {
mid += (s[j * 2] - '1') * temp;
temp *= s[j * 2] - '0';
}
if (j > cur) {
cur++;
mu = 1;
for (; cur < total && s[cur * 2 + 1] == '*'; cur++)
mu *= s[cur * 2 + 2] - '0';
}
long long res;
res = mid * mul * mu + su + sum[total - 1] - sum[cur];
ans = max(ans, res);
mu /= s[min(j * 2 + 2, (int)s.size())] - '0';
}
}
if (s.size() != 1)
cout << ans;
else
cout << s[0] - '0';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int id[2][maxn * 4], cnt, n, Q, st;
vector<pair<int, int>> V[maxn * 4];
long long dis[maxn];
void Build(int rt, int l, int r, int val) {
if (l == r) {
id[val][rt] = l;
return;
}
id[val][rt] = ++cnt;
int mid = (l + r) >> 1;
Build(rt << 1, l, mid, val);
Build(rt << 1 | 1, mid + 1, r, val);
if (val == 0) {
V[id[val][rt]].push_back(make_pair(id[val][rt << 1], 0));
V[id[val][rt]].push_back(make_pair(id[val][rt << 1 | 1], 0));
} else {
V[id[val][rt << 1]].push_back(make_pair(id[val][rt], 0));
V[id[val][rt << 1 | 1]].push_back(make_pair(id[val][rt], 0));
}
}
void Update(int rt, int l, int r, int L, int R, int v, int w, int val) {
if (L <= l && r <= R) {
if (val == 0)
V[v].push_back(make_pair(id[val][rt], w));
else
V[id[val][rt]].push_back(make_pair(v, w));
return;
}
int mid = (l + r) >> 1;
if (L <= mid) Update(rt << 1, l, mid, L, R, v, w, val);
if (R > mid) Update(rt << 1 | 1, mid + 1, r, L, R, v, w, val);
}
struct cmp {
bool operator()(pair<long long, int> a, pair<long long, int> b) {
return a.first > b.first;
}
};
int main() {
scanf("%d%d%d", &n, &Q, &st);
cnt = n;
Build(1, 1, n, 0);
Build(1, 1, n, 1);
for (int i = 1; i <= Q; i++) {
int u, v, w, l, r, t;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d%d", &u, &v, &w);
V[u].push_back(make_pair(v, w));
} else {
scanf("%d%d%d%d", &v, &l, &r, &w);
Update(1, 1, n, l, r, v, w, t - 2);
}
}
memset(dis, -1, sizeof(dis));
dis[st] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int>>, cmp> q;
q.push(make_pair(0, st));
while (!q.empty()) {
pair<long long, int> now = q.top();
q.pop();
for (int i = 0; i < V[now.second].size(); i++) {
int v = V[now.second][i].first;
int w = V[now.second][i].second;
if (dis[v] == -1 || dis[now.second] + w < dis[v]) {
dis[v] = dis[now.second] + w;
q.push(make_pair(dis[v], v));
}
}
}
for (int i = 1; i <= n; i++) printf("%lld ", dis[i]);
printf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, k;
struct cmp {
bool operator()(long long const& p1, long long const& p2) { return p1 > p2; }
};
void Anon_mouS() {
string s;
cin >> s;
map<long long, long long> m;
long long n = s.length();
long long ans = 0;
for (i = 0; i < n; i++) {
m[s[i] - '0']++;
ans = max(ans, m[s[i] - '0']);
}
for (i = 0; i <= 9; i++) {
for (j = 0; j <= 9; j++) {
if (i == j) continue;
long long c = 0;
for (k = 0; k < n; k++) {
if (c % 2 == 1 and s[k] - '0' == j) c++;
if (c % 2 == 0 and s[k] - '0' == i) c++;
}
c -= c % 2;
ans = max(ans, c);
}
}
cout << n - ans << '\n';
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long q = 1;
cin >> q;
for (long long it = 1; it <= q; it++) {
Anon_mouS();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
bool cmp(pair<float, long long> p1, pair<float, long long> p2) {
if (p1.first == p2.first) {
return p1.second < p2.second;
}
return p1.first > p2.first;
}
int32_t main() {
long long n;
cin >> n;
string str;
cin >> str;
bool ans = false;
for (long long i = 0; i < str.size() - 1; i++) {
if (str[i] > str[i + 1]) {
str.erase(str.begin() + i);
ans = true;
break;
}
}
if (ans == false) str.pop_back();
cout << str << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, k, ans = 0x3f3f3f3f3f3f3f3fll;
int Count(int x) {
int re = 0;
for (; x; x -= x & -x) ++re;
return re;
}
int main() {
long long i, j;
cin >> l >> r >> k;
if (r - l + 1 <= 4) {
int _ans;
for (i = 1; i < 1 << r - l + 1; i++)
if (Count(i) <= k) {
long long temp = 0;
for (j = 0; j < r - l + 1; j++)
if (i & (1 << j)) temp ^= l + j;
if (temp <= ans) ans = temp, _ans = i;
}
cout << ans << endl;
cout << Count(_ans) << endl;
for (j = 0; j < r - l + 1; j++)
if (_ans & (1 << j)) cout << l + j << ' ';
return 0;
}
if (k >= 4) {
if (l & 1) ++l;
cout << 0 << endl;
cout << 4 << endl;
for (i = 0; i < 4; i++) cout << l + i << ' ';
return 0;
}
if (k >= 3) {
for (i = 1; i < l; i = i << 1 | 1)
;
if (((i + 1) | (i + 1 >> 1)) <= r) {
cout << 0 << endl;
cout << 3 << endl;
cout << i << ' ' << ((i + 1) | (i >> 1)) << ' '
<< ((i + 1) | (i + 1 >> 1)) << ' ';
return 0;
}
}
if (k >= 2) {
if (l & 1) ++l;
cout << 1 << endl;
cout << 2 << endl;
cout << l << ' ' << l + 1 << ' ';
return 0;
}
cout << l << endl;
cout << 1 << endl;
cout << l << ' ';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using dl = double;
const int N = 2e5 + 10;
ll aarray[200000 + 10];
ll magic[101][101];
vector<ll> primes;
bool prime[1000001];
int main() {
ios_base::sync_with_stdio(false);
string str;
ll i, j, n, m, k, t;
char ch1, ch2;
str = "v<^>v<^";
cin >> ch1 >> ch2;
cin >> n;
n %= 4;
ll flag = 0, fl = 0;
for (i = 0; i < str.length(); i++) {
if (str[i] == ch1 && str[i + n] == ch2) {
flag++;
}
if (str[i] == ch1 && str[i - n] == ch2 && i - n >= 0) {
fl++;
}
}
if (fl && flag) {
cout << "undefined" << endl;
return 0;
}
if (flag) {
cout << "cw" << endl;
return 0;
}
if (fl) {
cout << "ccw" << endl;
return 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int sl = 160000;
int X[sl], P[sl];
int n, m, K;
long long F[sl];
long long pw[sl][20];
long long bw[sl][20];
long long ew[sl][20];
long long tw[sl][20];
int main() {
int a, b;
long long tres = 0;
scanf("%d%d%d", &n, &m, &K);
for (int i = 1; i <= n; i++) scanf("%d", &X[i]);
for (int i = 1; i < n; i++) scanf("%d", &P[i]);
for (int i = 2; i <= n; i++)
F[i] = ((long long)(X[i] - X[i - 1]) * 50 - (long long)K * P[i - 1]);
for (int i = 2; i <= n; i++) {
tw[i][0] = F[i];
pw[i][0] = bw[i][0] = ew[i][0] = max(F[i], (long long)0);
}
for (int q = 1; q <= 20; q++)
for (int i = 2; i <= n; i++)
if ((i + (1 << q) - 1) <= n) {
pw[i][q] = max(pw[i][q - 1], pw[i + (1 << (q - 1))][q - 1]);
pw[i][q] = max(pw[i][q], ew[i][q - 1] + bw[i + (1 << (q - 1))][q - 1]);
ew[i][q] = max(ew[i + (1 << (q - 1))][q - 1],
ew[i][q - 1] + tw[i + (1 << (q - 1))][q - 1]);
bw[i][q] =
max(bw[i][q - 1], tw[i][q - 1] + bw[i + (1 << (q - 1))][q - 1]);
tw[i][q] = tw[i][q - 1] + tw[i + (1 << (q - 1))][q - 1];
}
while (m--) {
scanf("%d%d", &a, &b);
long long res = 0, cres = 0;
int cur = a + 1;
for (int i = 20; i >= 0; i--)
if ((cur + (1 << i) - 1) <= b) {
res = max(res, pw[cur][i]);
res = max(res, cres + bw[cur][i]);
cres = max(cres + tw[cur][i], ew[cur][i]);
cur = cur + (1 << i);
}
tres += res;
}
printf("%.10f", 1.0 * tres / 100.0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int t(int a, int b) {
int s = 1;
for (int i = 0; i < b; i++) {
s *= a;
}
return s;
}
long long dp[1000000];
int main() {
string s;
cin >> s;
string j;
if (s.size() < 5) {
cout << 0;
return 0;
}
for (int i = 0; i < s.size() - 4; i++) {
string tmp;
tmp += s[i];
tmp += s[i + 1];
tmp += s[i + 2];
tmp += s[i + 3];
tmp += s[i + 4];
if (tmp == "heavy") j += '0';
if (tmp == "metal") j += '1';
}
string j1;
for (int i = j.size() - 1; i >= 0; i--) {
j1 += j[i];
}
long long t = 0;
for (int i = 0; i < j1.size(); i++) {
if (j1[i] == '1') t++;
dp[i] = t;
}
long long fiinally = 0;
for (int i = j1.size() - 1; i >= 0; i--) {
if (j1[i] == '0') {
fiinally += dp[i];
}
}
cout << fiinally;
}
| 2 |
#include<bits/stdc++.h>
// #pragma optimize("-O3")
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC target("sse,sse2,sse3,sse4,popcnt,abm,avx,mmx,tune=native")
using namespace std;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define INF 1e9
#define BIG_INF 1e18
#define vi vector<ll>
#define sz(a) ll((a).size())
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1)
// #include <ext/pb_ds/assoc_container.hpp> // Common file
// #include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
// typedef tree<
// ll,
// null_type,
// less<ll>,
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
typedef long long ll;
ll mod = 1e9 + 7;
long long fast_exp(long long a, long long b)
{
if(b <= 0)
return 1;
else
{
long long res = 1;
res = fast_exp(a,b/2);
res = (res*res)%mod;
if(b%2 == 1)
res = (res*a)%mod;
return res;
}
}
typedef long double ld;
const long long N = 5e5+1000;
const long double pi = acos(-1.0);
// struct node{
// ll random = 0;
// ll dist = 0;
// ll num;
// bool operator < (node b)
// {
// if(a.)
// }
// }
vector <int> edge[N];
int vis[N] = {};
int cnt = 0;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
// freopen("area1.in","r",stdin);
// freopen("area1.out","w",stdout);
int t;
cin >> t;
while(t--)
{
cnt = 0;
int n, m;
cin >> n >> m;
for(int i = 1; i<=n; i++)
{
edge[i].clear();
vis[i] = 0;
}
int u, v;
vector <pair<int,int>> vec;
for(int i = 0; i<m; i++)
{
cin >> u >> v;
edge[v].pb(u);
edge[u].pb(v);
}
set <int> black_set, white_set;
int start = 1;
black_set.insert(start);
vector<int> final_list;
map <int,int> col;
int poss = 1;
while(!black_set.empty())
{
int cur = *black_set.begin();
black_set.erase(cur);
final_list.pb(cur);
vis[cur] = 1;
cnt++;
for(auto e: edge[cur])
{
if(vis[e] == 0)
{
vis[e] = 1;
cnt++;
if(black_set.find(e) != black_set.end())
black_set.erase(e);
for(auto ed: edge[e])
{
if(vis[ed] == 0)
black_set.insert(ed);
}
}
else
{
// if(col[e] == 1)
// {
// poss = 0;
// break;
// }
}
}
}
if(cnt == n && poss == 1)
{
cout << "YES\n";
cout << final_list.size() << '\n';
for(auto e: final_list)
cout << e << " ";
cout << '\n';
}
else
cout << "NO\n";
}
// cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, a, b, T[100005], ID[100005], nrout[100005];
vector<int> v[100005], v2[100005];
bool uz[100005];
vector<vector<int> > ans;
vector<int> H;
void dfs(int nod) {
uz[nod] = 1;
for (auto it : v[nod]) {
if (uz[it]) continue;
dfs(it);
}
H.push_back(nod);
}
void dfs2(int nod) {
uz[nod] = 1;
for (auto it : v2[nod]) {
if (uz[it]) continue;
dfs2(it);
}
ans.back().push_back(nod);
}
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> T[i];
}
for (int i = 1; i <= m; i++) {
cin >> a >> b;
if ((T[a] + 1) % h == T[b]) v[a].push_back(b), v2[b].push_back(a);
if ((T[b] + 1) % h == T[a]) v[b].push_back(a), v2[a].push_back(b);
}
for (int i = 1; i <= n; i++)
if (!uz[i]) dfs(i);
memset(uz, 0, sizeof(uz));
for (auto it = H.rbegin(); it != H.rend(); it++) {
if (!uz[*it]) {
ans.push_back(*new vector<int>);
dfs2(*it);
}
}
for (int i = 0; i < ans.size(); i++) {
for (auto it : ans[i]) {
ID[it] = i;
}
}
for (int i = 1; i <= n; i++) {
for (auto it : v[i]) {
if (ID[i] != ID[it]) nrout[ID[i]]++;
}
}
int mn = 1e9, sav = 0;
for (int i = 0; i < ans.size(); i++) {
if (nrout[i] == 0) {
if (ans[i].size() < mn) {
mn = ans[i].size();
sav = i;
}
}
}
cout << mn << '\n';
for (auto it : ans[sav]) cout << it << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
int n, m, T;
char a[1001], b[1001];
map<long long, bool> p;
inline void init() {
scanf("%s", a + 1);
n = strlen(a + 1);
m = 0;
for (int i = 1; i <= n; i++) {
while (m > 0 && b[m] == 'k' && a[i] == 'h') m--;
if (a[i] == 'u') {
b[++m] = 'o';
b[++m] = 'o';
} else {
b[++m] = a[i];
}
}
ans = 0;
for (int i = 1; i <= m; i++) ans = ans * 1000000007 + b[i];
p[ans] = 1;
}
int main() {
scanf("%d", &T);
for (int i = 1; i <= T; i++) init();
printf("%d\n", p.size());
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
inline int addmod(int x) { return x >= mod ? x - mod : x; }
inline int submod(int x) { return x < 0 ? x + mod : x; }
int fpow(int x, long long y) {
int ans = 1;
while (y) {
if (y & 1) ans = 1ll * ans * x % mod;
x = 1ll * x * x % mod;
y /= 2;
}
return ans;
}
int n, a[100005], pn = 1e5, mu[100005], p[100005], prime[100005], pt;
int pw[100005];
inline int F(int x, int y) {
if (!x) return 1;
return addmod(1ll * y * fpow(2, x - 1) % mod + fpow(2, x));
}
int solve(int ct, int cct, int sum, int sum2) {
if (ct <= 1) return 0;
return addmod(1ll * submod(1ll * sum * sum % mod - sum2) *
F(ct - 2, cct - 2) % mod +
1ll * sum2 * (cct - 1) % mod * fpow(2, ct - 2) % mod);
}
int main() {
pw[0] = 1;
mu[1] = 1;
for (int i = 1; i <= pn; i++) pw[i] = 2 * pw[i - 1] % mod;
for (int i = 2; i <= pn; i++) {
if (!p[i]) prime[++pt] = i, mu[i] = -1;
for (int j = 1; j <= pt && i * prime[j] <= pn; j++) {
p[i * prime[j]] = 1;
if (i % prime[j] == 0) {
mu[i * prime[j]] = 0;
break;
}
mu[i * prime[j]] = -mu[i];
}
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x] = y;
}
int ans = 0;
for (int i = 1; i <= pn; i++)
if (mu[i]) {
int sum = 0, sum2 = 0;
int ct = 0, cct = 0;
for (int j = i; j <= pn; j += i) {
ct = ct + a[j];
while (ct > mod + 1000) ct -= (mod - 1);
cct = (cct + a[j]) % mod;
sum = addmod(sum + 1ll * j * a[j] % mod);
sum2 = addmod(sum2 + 1ll * j * j % mod * a[j] % mod);
}
int q = solve(ct, cct, sum, sum2);
if (mu[i] == 1)
ans = addmod(ans + q);
else if (mu[i] == -1)
ans = submod(ans - q);
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3030;
const long long inf = 1e12;
long long a[N], b[N], c[N], ans[N][4], n;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 0; i < (n); ++i) cin >> a[i + 1];
for (long long i = 0; i < (n); ++i) cin >> b[i + 1];
for (long long i = 0; i < (n); ++i) cin >> c[i + 1];
memset(ans, 0, sizeof(ans));
if (n == 1) {
cout << a[1];
return 0;
}
ans[1][0] = a[1];
ans[1][2] = b[1];
ans[1][1] = ans[1][3] = -inf;
for (int i = 2; i <= n; i++) {
ans[i][0] = max(ans[i - 1][2], ans[i - 1][3]) + a[i];
ans[i][1] = max(ans[i - 1][0], ans[i - 1][1]) + b[i];
if (i != n) ans[i][2] = max(ans[i - 1][2], ans[i - 1][3]) + b[i];
if (i != n) ans[i][3] = max(ans[i - 1][0], ans[i - 1][1]) + c[i];
}
long long mx = 0;
for (long long i = 0; i < (4); ++i) mx = max(mx, ans[n][i]);
cout << mx << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const double eps = 1e-8;
const int maxn = 30000;
int main() {
int k;
while (cin >> k) {
if (k % 2) {
cout << -1 << endl;
continue;
}
for (int i = (1); i <= (k / 2); ++i) {
if (i % 2 == 0) {
for (int j = (1); j <= (k); ++j) {
for (int a = (1); a <= (k / 2); ++a) {
if (j % 2) {
if (a % 2)
cout << "bb";
else
cout << "ww";
} else {
if (a % 2 == 0)
cout << "bb";
else
cout << "ww";
}
}
cout << endl;
}
cout << endl;
for (int j = (1); j <= (k); ++j) {
for (int a = (1); a <= (k / 2); ++a) {
if (j % 2) {
if (a % 2)
cout << "bb";
else
cout << "ww";
} else {
if (a % 2 == 0)
cout << "bb";
else
cout << "ww";
}
}
cout << endl;
}
cout << endl;
} else {
for (int j = (1); j <= (k); ++j) {
for (int a = (1); a <= (k / 2); ++a) {
if (j % 2 == 0) {
if (a % 2)
cout << "bb";
else
cout << "ww";
} else {
if (a % 2 == 0)
cout << "bb";
else
cout << "ww";
}
}
cout << endl;
}
cout << endl;
for (int j = (1); j <= (k); ++j) {
for (int a = (1); a <= (k / 2); ++a) {
if (j % 2 == 0) {
if (a % 2)
cout << "bb";
else
cout << "ww";
} else {
if (a % 2 == 0)
cout << "bb";
else
cout << "ww";
}
}
cout << endl;
}
cout << endl;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
;
long long m;
cin >> m;
;
vector<string> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
set<char> s;
long long ans = 1;
for (long long i = 0; i < m; i++) {
s.clear();
for (long long j = 0; j < n; j++) s.insert(v[j][i]);
long long val = s.size();
ans = (ans * val) % 1000000007;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int c = 100002;
int n, rf[c], hol[c], cent, cnt;
int si[c], db2[2 * c], maxi, pos, ans[c];
priority_queue<int, vector<int>, greater<int> > q;
long long sum;
vector<int> sz[c], s[c], csop[c];
bool v[c], v2[c], h[c];
void dfs(int a) {
v[a] = true;
rf[a] = 1;
for (int i = 0; i < sz[a].size(); i++) {
int x = sz[a][i];
long long y = s[a][i];
if (!v[x]) {
dfs(x);
sum += y * min(rf[x], n - rf[x]);
rf[a] += rf[x];
}
}
if (!cent && 2 * rf[a] >= n) {
cent = a;
}
}
void dfs2(int a) {
v2[a] = true;
csop[cnt].push_back(a), hol[a] = cnt;
for (int x : sz[a]) {
if (!v2[x]) {
dfs2(x);
}
}
}
void cl(int a) {
db2[si[a]]--;
si[a]--;
if (si[a] < 0) {
}
db2[si[a]]++;
if (!db2[maxi]) {
maxi--;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
if (n == 1) {
cout << 0 << "\n" << 1 << "\n";
return 0;
}
for (int i = 1; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
sz[a].push_back(b), sz[b].push_back(a);
s[a].push_back(c), s[b].push_back(c);
}
dfs(1);
cout << 2 * sum << "\n";
csop[1].push_back(cent);
v2[cent] = 1, hol[cent] = 1;
cnt = 1;
for (int x : sz[cent]) {
cnt++;
dfs2(x);
}
for (int i = 1; i <= cnt; i++) {
si[i] = 2 * (csop[i].size());
db2[si[i]]++;
sort(csop[i].rbegin(), csop[i].rend());
q.push(csop[i].back());
csop[i].pop_back();
maxi = max(maxi, si[i]);
}
si[1] = 0, db2[2]--;
while (maxi < n - pos) {
pos++;
int ert = q.top(), spec = 0;
if (pos == 736) {
}
if (pos != cent && hol[pos] == hol[ert]) {
if (pos == 736) {
}
spec = ert;
q.pop();
ert = q.top();
}
q.pop();
if (spec) {
q.push(spec);
}
ans[pos] = ert;
h[ert] = 1;
int p = hol[ert];
cl(hol[pos]), cl(p);
if (csop[p].size() > 0) {
q.push(csop[p].back());
csop[p].pop_back();
}
}
if (n == 1000) {
}
int spec = 0;
for (int i = 1; i <= cnt; i++) {
if (si[i] == maxi) {
spec = i;
}
}
vector<int> mcs, mas;
for (int i = 1; i <= n; i++) {
if (!h[i]) {
if (hol[i] == spec) {
mcs.push_back(i);
} else {
mas.push_back(i);
}
}
}
int pos1 = 0, pos2 = 0;
for (int i = pos + 1; i <= n; i++) {
if (hol[i] == spec) {
ans[i] = mas[pos2];
pos2++;
} else {
ans[i] = mcs[pos1];
pos1++;
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k;
cin >> n;
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
reverse(arr, arr + n);
if (1 & n) {
cout << arr[((n + 1) / 2) - 1];
} else {
cout << arr[n / 2];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct qry {
int o, l, r;
} q[100100];
map<int, int> hook, person, mp;
struct data {
int sz, st, ed;
};
bool operator<(data a, data b) {
if (a.sz == b.sz) return a.ed > b.ed;
return a.sz > b.sz;
}
set<data> S;
data pack(int x, int y, int z) {
data tmp;
tmp.sz = x;
tmp.st = y;
tmp.ed = z;
return tmp;
}
vector<int> v;
int tree[1000100];
void up(int x, int v) {
while (x < 1000000) {
tree[x] += v;
x += (x & -x);
}
}
int read(int x) {
int sum = 0;
while (x) {
sum += tree[x];
x -= (x & -x);
}
return sum;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
S.insert(pack(n, 1, n));
hook[1] = hook[n] = n;
for (int qq = 1; qq <= m; qq++) {
scanf("%d", &q[qq].o);
if (!q[qq].o) {
scanf("%d %d", &q[qq].l, &q[qq].r);
v.push_back(q[qq].l), v.push_back(q[qq].r);
} else {
if (!person[q[qq].o]) {
data tt = *S.begin();
int len = (tt.ed - tt.st + 1);
int ind = tt.st + len / 2;
hook[ind] = -1;
int l = len / 2, r = len / 2;
if (!(len & 1)) r--;
if (ind > tt.st) hook[tt.st] = hook[ind - 1] = l;
if (ind < tt.ed) hook[ind + 1] = hook[tt.ed] = r;
S.erase(S.begin());
if (ind > tt.st) S.insert(pack(l, tt.st, ind - 1));
if (ind < tt.ed) S.insert(pack(r, ind + 1, tt.ed));
person[q[qq].o] = ind;
v.push_back(ind);
q[qq].l = 1, q[qq].r = ind;
} else {
int hispos = person[q[qq].o];
v.push_back(hispos);
q[qq].l = 0, q[qq].r = hispos;
person[q[qq].o] = 0;
if (hook[hispos - 1] > 0 && hook[hispos + 1] > 0) {
hook[hispos] = 0;
int l = hook[hispos - 1];
int r = hook[hispos + 1];
hook[hispos - l] = l + r + 1;
hook[hispos + r] = l + r + 1;
S.erase(pack(l, hispos - l, hispos - 1));
S.erase(pack(r, hispos + 1, hispos + r));
S.insert(pack(l + r + 1, hispos - l, hispos + r));
} else if (hook[hispos - 1] > 0) {
int l = hook[hispos - 1];
hook[hispos - l] = l + 1;
hook[hispos] = l + 1;
S.erase(pack(l, hispos - l, hispos - 1));
S.insert(pack(l + 1, hispos - l, hispos));
} else if (hook[hispos + 1] > 0) {
int r = hook[hispos + 1];
hook[hispos + r] = r + 1;
hook[hispos] = r + 1;
S.erase(pack(r, hispos + 1, hispos + r));
S.insert(pack(r + 1, hispos, hispos + r));
} else {
hook[hispos] = 1;
S.insert(pack(1, hispos, hispos));
}
}
}
}
sort(v.begin(), v.end());
int nsz = unique(v.begin(), v.end()) - v.begin();
for (int i = 0; i < v.size(); i++) mp[v[i]] = i + 1;
for (int i = 1; i <= m; i++) {
if (!q[i].o) {
printf("%d\n", read(mp[q[i].r]) - read(mp[q[i].l] - 1));
} else {
if (q[i].l)
up(mp[q[i].r], 1);
else
up(mp[q[i].r], -1);
}
}
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, a, b;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
if (a == 1 || b == 1 || (a == 2 && b == 2))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7f7f7f7f;
int main() {
int n;
while (~scanf("%d", &n)) {
int t[4];
memset(t, 0, sizeof(t));
vector<int> v[5100];
memset(v, 0, sizeof(v));
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
t[x]++;
v[x].push_back(i);
}
int r = INF;
for (int i = 1; i <= 3; i++) {
r = min(r, t[i]);
}
cout << r << endl;
for (int j = 0; j < r; j++) {
for (int i = 1; i <= 3; i++) {
cout << v[i][j] << " ";
}
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535897;
long long n, m, k, ans;
int f(long long v) {
long long l = k - 1;
long long r = n - k;
long long sum = v;
if (r > v - 1) {
sum += (v - 1) * v / 2 + r - (v - 1);
} else if (r <= v - 1) {
sum += (v - 1 + v - r) * r / 2;
}
if (l > v - 1) {
sum += (v - 1) * v / 2 + l - (v - 1);
} else if (l <= v - 1) {
sum += (v - 1 + v - l) * l / 2;
}
if (sum <= m) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
long long l = 1, r = 1e9 + 10;
while (l < r) {
long long mid = (l + r) / 2;
if (f(mid)) {
l = mid + 1;
ans = mid;
} else {
r = mid;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 1;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long d, m;
cin >> d >> m;
long long mn = 1;
for (; (1 << (mn - 1)) <= d; mn++)
;
--mn;
vector<vector<long long> > dp(mn + 1, vector<long long>(mn, 0));
for (long long i = 0; i < mn - 1; i++) dp[1][i] = (1 << i);
dp[1][mn - 1] = (d == 1 ? 1 : d % (1 << (mn - 1)) + 1);
for (long long n = 2; n <= mn; n++) {
for (long long i = 0; i < mn; i++)
for (long long j = 0; j < i; j++)
dp[n][i] =
(dp[n][i] + min((1ll << i), d - (1 << i) + 1) * dp[n - 1][j]) % m;
}
long long ans = 0;
for (long long n = 1; n <= mn; n++)
for (long long i = 0; i < mn; i++) ans = (ans + dp[n][i]) % m;
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> sieve;
vector<long long int>* Sieve(int N) {
const long long int maxn = N;
sieve.resize(maxn);
for (long long int(i) = 0; (i) < (maxn); ++(i)) sieve[i] = 1;
sieve[1] = 0;
sieve[0] = 0;
for (long long int(i) = 2; (i) <= (maxn); (i) += (1))
if (1 == sieve[i])
for (long long int j = i * i; j < maxn; j += i) sieve[j] = 0;
vector<long long int>* primes = new vector<long long int>();
primes->push_back(2);
for (int i = 3; i < maxn; i += 2)
if (sieve[i]) {
primes->push_back(i);
}
return primes;
}
long long int extended_GCD(long long int a, long long int b, long long int& x,
long long int& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long int x1, y1;
long long int gcd = extended_GCD(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
}
long long int ncr(long long int n, long long int k) {
long long int r = 1;
if (k > n - k) k = n - k;
for (long long int i = 0; i < k; i++) {
r *= (n - i);
r /= (i + 1);
}
return r;
}
long long int power(long long int a, long long int b,
long long int m = 1000000007) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
long long int modinv(long long int a, long long int mod = 1000000007) {
long long int x, y;
extended_GCD(a, mod, x, y);
if (x < 0) x += mod;
return x;
}
bool prime(int n) {
int c = 0;
for (int i = 2; (i * i) <= n; i++) {
if (n % i == 0) {
c++;
return false;
}
}
if (c == 0) return true;
}
vector<int> v[200006];
int vis[200006];
int c;
void dfs(int n) {
vis[n] = 1;
c++;
for (int i : v[n]) {
if (!vis[i]) dfs(i);
}
}
void solve() {
int n;
cin >> n;
vector<long long int> a(n), b(n);
for (auto& i : a) cin >> i;
;
sort(a.begin(), a.end());
long long int k = 0;
for (long long int(i) = 1; (i) <= (n - 1); (i) += (2)) {
b[i] = a[k++];
}
for (long long int(i) = 0; (i) <= (n - 1); (i) += (2)) {
b[i] = a[k++];
}
k = 0;
for (long long int(i) = 1; (i) <= (n - 2); (i) += (1)) {
if (b[i] < b[i + 1] && b[i] < b[i - 1]) k++;
}
cout << k << "\n";
for (auto i : b) cout << i << " ";
cout << "\n";
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
ios::sync_with_stdio(false);
int n, a, b, res = 0;
cin >> n;
vector<int> v;
int cnt = 1;
for (int i = 0; i < (n); i++) {
cin >> a >> b;
if (b == 0) {
v.push_back(a);
continue;
}
res += a;
cnt += b - 1;
}
sort(v.rbegin(), v.rend());
int sz = v.size();
__f("cnt, sz", cnt, sz);
for (int i = 0; i < min(sz, cnt); i++) {
res += v[i];
}
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
pair<int, int> p[100100];
map<pair<int, int>, int> mp;
map<int, vector<int> > X, Y;
map<int, int> xvst, yvst;
int root[100100], cnt[100100];
int find_root(int u) { return u == root[u] ? u : root[u] = find_root(root[u]); }
void link(int u, int v) {
u = find_root(u);
v = find_root(v);
if (u == v) return;
if (cnt[u] < cnt[v]) swap(u, v);
root[v] = u;
cnt[u] += cnt[v];
}
vector<int> con[100100];
int main() {
int n;
gn(n);
for (int i = 0; i < n; i++) {
gn(p[i].first, p[i].second);
X[p[i].first].push_back(p[i].second);
Y[p[i].second].push_back(p[i].first);
mp[p[i]] = i;
}
for (int i = 0; i < n; i++) root[i] = i, cnt[i] = 1;
for (map<int, vector<int> >::iterator it = X.begin(); it != X.end(); it++) {
vector<int> &vec = it->second;
for (int i = 1; i < vec.size(); i++)
link(mp[pair<int, int>(it->first, vec[i - 1])],
mp[pair<int, int>(it->first, vec[i])]);
}
for (map<int, vector<int> >::iterator it = Y.begin(); it != Y.end(); it++) {
vector<int> &vec = it->second;
for (int i = 1; i < vec.size(); i++)
link(mp[pair<int, int>(vec[i - 1], it->first)],
mp[pair<int, int>(vec[i], it->first)]);
}
for (int i = 0; i < n; i++) con[find_root(i)].push_back(i);
int ans = 1;
for (int i = 0; i < n; i++)
if (root[i] == i) {
xvst.clear();
yvst.clear();
for (int j = 0; j < con[i].size(); j++) {
xvst[p[con[i][j]].first] = 1;
yvst[p[con[i][j]].second] = 1;
}
int m = xvst.size() + yvst.size();
int tot = 0;
for (int j = 0, c = 1; j <= m && j <= cnt[i]; j++) {
tot += c;
if (tot >= 1000000007) tot -= 1000000007;
c = (long long)c * (m - j) % 1000000007 *
power(j + 1, 1000000007 - 2, 1000000007) % 1000000007;
}
ans = (long long)ans * tot % 1000000007;
}
println(ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5, inf = 1e9 + 7;
int n, k, i, j;
int dp1[N], dp2[N], m;
map<string, int> mp, done;
bitset<41> A, mat[41], is;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int i, j, a, s, cur, ans = 0, cnt = 0;
string b;
cin >> n >> m;
while (n--) {
cin >> a;
if (a == 1)
for (i = 1; i < m + 1; i++) A[i - 1] = 0;
else {
cin >> b;
if (!done[b]) mp[b] = cnt++;
done[b] = 1;
a = mp[b];
for (i = 0; i < m; i++)
if (i != a && A[i]) mat[a][i] = mat[i][a] = 1;
A[a] = 1;
}
}
n = m;
for (i = 0; i < 1 << n / 2; i++) {
for (j = 0; j < n / 2; j++)
if (i >> j & 1)
for (k = j + 1; k < n / 2; k++)
if ((i >> k & 1) && mat[j][k]) dp1[i] = -1;
if (dp1[i] != -1) {
for (j = n / 2; j < n; j++) is[j] = 0;
for (j = 0; j < n / 2; j++)
if (i >> j & 1)
for (k = n / 2; k < n; k++)
if (mat[j][k]) is[k] = 1;
for (j = n / 2; j < n; j++)
if (!is[j]) dp1[i] += 1 << j - n / 2;
}
}
for (i = 0; i < 1 << n - n / 2; i++) {
for (j = 0; j < n - n / 2; j++)
if (i >> j & 1)
for (k = j + 1; k < n - n / 2; k++)
if ((i >> k & 1) && mat[j + n / 2][k + n / 2]) dp2[i] = -1;
if (dp2[i] != -1) dp2[i] = __builtin_popcount(i);
ans = max(ans, dp2[i]);
}
for (int i = 0; i < n - n / 2; ++i)
for (int mask = 0; mask < (1 << n - n / 2); ++mask) {
if (mask & (1 << i)) dp2[mask] = max(dp2[mask], dp2[mask ^ (1 << i)]);
}
for (i = 0; i < 1 << n / 2; i++)
if (dp1[i] != -1) {
ans = max(ans, __builtin_popcount(i) + dp2[dp1[i]]);
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, co = 0;
cin >> a >> b;
for (int i = 1; i * i <= b; i++) {
if (b % i == 0 && b / i <= a && i <= a) {
if (i == b / i) co--;
co += 2;
}
}
printf("%d\n", co);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n;
vector<pair<int, int> > v(n + 1);
for (int i = 1; i < n + 1; i++) {
cin >> a;
v[i] = make_pair(a, i);
}
sort(v.begin() + 1, v.end());
for (int i = 1; i <= n / 2; i++) {
cout << v[i].second << " " << v[n + 1 - i].second << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a, b, c, d;
cin >> a >> b >> c >> d;
int ans = max(abs(a - c), abs(b - d));
cout << ans << endl;
for (;;) {
if (a == c and b == d) break;
if (a > c) {
cout << "L";
a--;
}
if (c > a) {
cout << "R";
a++;
}
if (b > d) {
cout << "D";
b--;
}
if (b < d) {
cout << "U";
b++;
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
const int INF = 2139062143;
template <typename T>
void read(T &x) {
x = 0;
bool f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = 0;
} while (ch > '9' || ch < '0');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
x = f ? x : -x;
}
template <typename T>
void write(T x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e5 + 7;
const int P = 1e6 + 7;
const int M = 1e7 + 1;
const int mod = 1e9 + 7;
const int LOG = 20 + 5;
int n, m, E, tot, a[N], w[N], ans[N], dep[N], head[N], prime[P], f[N][LOG],
cnt[P][LOG];
vector<int> q[N];
bool vis[M];
struct EDGE {
int to, nxt;
} edge[N << 1];
inline void addedge(int u, int v) {
edge[++E].to = v;
edge[E].nxt = head[u];
head[u] = E;
}
inline void lca_dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
f[u][0] = fa;
for (int i = 1; i <= 20; i++) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v == fa) continue;
lca_dfs(v, u);
}
}
inline int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 20; i >= 0; i--) {
if (dep[f[u][i]] >= dep[v]) u = f[u][i];
if (u == v) return u;
}
if (u == v) return u;
for (int i = 20; i >= 0; i--) {
if (f[u][i] != f[v][i]) {
u = f[u][i];
v = f[v][i];
}
}
return f[u][0];
}
inline void init(int NN) {
for (int i = 2; i <= NN; i++) {
if (!vis[i]) {
prime[++tot] = i;
}
for (int j = 1; j <= tot && prime[j] * i <= NN; j++) {
vis[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
}
inline int qpow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return ret % mod;
}
inline void add(int val, int opt) {
for (int i = 1; 1ll * prime[i] * prime[i] <= val && i <= tot; i++) {
if (val % prime[i]) continue;
int p = 0;
while (val % prime[i] == 0) {
val /= prime[i];
p++;
}
cnt[i][p] += opt;
}
if (val != 1) {
int pos = lower_bound(prime + 1, prime + tot + 1, val) - prime;
cnt[pos][1] += opt;
}
}
inline int gcd(int x, int y) {
if (x < y) swap(x, y);
return y == 0 ? x : gcd(y, x % y);
}
inline int sqr(int x) { return 1ll * x * x % mod; }
inline int query(int val) {
int ans = 1;
for (int i = 1; 1ll * prime[i] * prime[i] <= val && i <= tot; i++) {
if (val % prime[i]) continue;
int p = 0;
while (val % prime[i] == 0) {
val /= prime[i];
p++;
}
int s = 0;
for (int j = 1; j <= p; j++) s += cnt[i][j] * j;
for (int j = p + 1; j < LOG; j++) s += cnt[i][j] * p;
ans = 1ll * ans * qpow(prime[i], s) % mod;
}
if (val != 1) {
int pos = lower_bound(prime + 1, prime + tot + 1, val) - prime;
int s = 0;
for (int j = 1; j < LOG; j++) s += cnt[pos][j];
ans = 1ll * ans * qpow(val, s) % mod;
}
return ans;
}
inline void dfs(int u, int f) {
add(a[u], 1);
for (int i = 0, sz = q[u].size(); i < sz; i++) {
int id = q[u][i];
int x = query(w[abs(id)]);
if (id > 0) ans[id] = 1ll * ans[id] % mod * x % mod;
if (id < 0)
ans[-id] = 1ll * ans[-id] % mod * qpow(1ll * x * x % mod, mod - 2) % mod *
gcd(w[-id], a[u]) % mod;
}
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v == f) continue;
dfs(v, u);
}
add(a[u], -1);
}
int main() {
read(n);
init(1e7);
for (int i = 1, u, v; i < n; i++) {
read(u);
read(v);
addedge(u, v);
addedge(v, u);
}
lca_dfs(1, 0);
for (int i = 1; i <= n; i++) read(a[i]);
read(m);
for (int i = 1, x, y, z; i <= m; i++) {
read(x);
read(y);
read(z);
int LCA = lca(x, y);
w[i] = z;
ans[i] = 1;
q[LCA].push_back(-i);
q[x].push_back(i);
q[y].push_back(i);
}
dfs(1, 0);
for (int i = 1; i <= m; i++) printf("%d\n", (ans[i] % mod + mod) % mod);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long A = 100000000000000LL, N = 1228228;
long long a[N], l, r, c, k, i, j, n, m, o;
int check(int c) {
j = c, k = 1;
for (i = 0; i < c; i++) {
while (j < n && a[i] * 2 > a[j]) j++;
if (j == n) k = 0;
j++;
}
return k;
}
int main() {
cin >> n;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
l = 0, r = n;
while (r - l > 1) {
c = (l + r) / 2;
if (check(c))
l = c;
else
r = c;
}
if (check(l))
cout << l + (n - l * 2) << "\n";
else
cout << r + (n - r * 2) << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
static void redirect(int argc, const char **argv) {
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
}
static int count_levels(int N) {
int lvls = 1;
while (N > 1) {
lvls++;
N = (N + 1) / 2;
}
return lvls;
}
struct node {
int paths[3][3];
};
static int mul(long long x, long long y) { return (x * y) % 777777777; }
static int N, L;
static int lucky[3][3] = {{}};
static vector<vector<node> > levels;
static void fix(int lvl, int idx) {
node &cur = levels[lvl][idx];
int a = 2 * idx;
int b = a + 1;
if (b >= ((int)(levels[lvl - 1]).size()))
cur = levels[lvl - 1][a];
else {
const node &sa = levels[lvl - 1][a];
const node &sb = levels[lvl - 1][b];
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
long long sum = 0;
for (int k = 0; k < 3; k++)
for (int l = 0; l < 3; l++)
if (lucky[k][l]) sum += mul(sa.paths[i][k], sb.paths[l][j]);
cur.paths[i][j] = sum % 777777777;
}
}
}
int main(int argc, const char **argv) {
redirect(argc, argv);
int M;
cin >> N >> M;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
cin >> lucky[i][j];
}
L = count_levels(N);
levels.resize(L);
for (int i = 0; i < L; i++) {
int mask = (1 << i);
int sz = (N + mask - 1) >> i;
levels[i].resize(sz);
}
for (int j = 0; j < N; j++)
for (int k = 0; k < 3; k++)
for (int l = 0; l < 3; l++) levels[0][j].paths[k][l] = (k == l);
for (int i = 1; i < L; i++)
for (int j = 0; j < ((int)(levels[i]).size()); j++) {
fix(i, j);
}
for (int i = 0; i < M; i++) {
int v, t;
cin >> v >> t;
v--;
t--;
for (int k = 0; k < 3; k++) levels[0][v].paths[k][k] = (t == -1 || t == k);
for (int j = 1; j < L; j++) {
fix(j, v >> j);
}
long long sum = 0;
for (int k = 0; k < 3; k++)
for (int l = 0; l < 3; l++) sum += levels[L - 1][0].paths[k][l];
sum %= 777777777;
cout << sum << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
void print(int num) {
if (num == -1)
puts("errtype");
else {
printf("void");
while (num--) printf("*");
puts("");
}
}
int digicalize(string s) {
int f, t, i;
for (i = 0; s[i] == '&'; i++)
;
f = i;
for (i = s.size() - 1; s[i] == '*'; i--)
;
t = i;
int n1 = f;
int n2 = s.size() - 1 - t;
int n = n2 - n1;
string tem = s.substr(f, t - f + 1);
if (m.find(tem) == m.end()) return -1;
if (m[tem] == -1) return -1;
return max(-1, n + m[tem]);
}
int main() {
m["void"] = 0;
m["errtype"] = -1;
int T;
cin >> T;
string d1, d2, d3;
while (T--) {
cin >> d1;
if (d1.compare("typedef") == 0) {
cin >> d2 >> d3;
m[d3] = digicalize(d2);
} else {
cin >> d2;
print(digicalize(d2));
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int dx8[] = {1, -1, 0, 0, 1, -1, 1, -1};
const int dy8[] = {0, 0, 1, -1, 1, -1, -1, 1};
const int dx4[] = {1, -1, 0, 0};
const int dy4[] = {0, 0, 1, -1};
using namespace std;
void task() {
long long a, b;
cin >> a >> b;
string k, s = "0";
cin >> k;
s += k;
int n = s.size();
long long cost = 0;
s += "0";
vector<pair<int, int>> mines;
for (int i = 0; i < n; i++) {
if (s[i] == '0' && s[i + 1] == '1') {
int st = i + 1;
i++;
while (s[i] == '1') {
i++;
}
mines.push_back(make_pair(st, i - 1));
i--;
}
}
n = mines.size();
if (n == 0) {
cout << "0\n";
return;
}
if (n == 1) {
cout << a << "\n";
return;
}
mines.push_back(make_pair(INT_MAX, 0));
bool blast = false;
for (int i = 0; i < n; i++) {
if (a < (b * (mines[i + 1].first - mines[i].second - 1))) {
blast = true;
cost += a;
} else {
blast = false;
cost += (b * (mines[i + 1].first - mines[i].second - 1));
}
}
if (!blast) {
cost += a;
}
cout << cost << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int TT = 1;
cin >> TT;
while (TT--) {
task();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000;
map<int, int> mapa;
map<pair<int, int>, vector<int>> pos;
vector<int> g[MAXN];
int ptr[MAXN];
int used[MAXN];
void euler(int v, vector<int> &res) {
used[v] = true;
for (; ptr[v] < (int)(g[v]).size();) {
++ptr[v];
int u = g[v][ptr[v] - 1];
euler(u, res);
res.push_back(u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, s;
cin >> n >> s;
int k = 0;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> b = a;
sort((b).begin(), (b).end());
int m = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == b[i]) {
continue;
}
++m;
if (!mapa.count(b[i])) {
mapa[b[i]] = k++;
}
}
if (m > s) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
if (a[i] == b[i]) {
continue;
}
a[i] = mapa[a[i]];
b[i] = mapa[b[i]];
g[b[i]].push_back(a[i]);
pos[{b[i], a[i]}].push_back(i);
}
vector<vector<int>> cycles;
for (int i = 0; i < k; ++i) {
if (!used[i]) {
vector<int> arr;
euler(i, arr);
reverse((arr).begin(), (arr).end());
cycles.push_back({});
for (int i = 0; i < (int)(arr).size(); ++i) {
int j = (i + 1) % (int)(arr).size();
cycles.back().push_back(pos[{arr[i], arr[j]}].back());
pos[{arr[i], arr[j]}].pop_back();
}
}
}
vector<vector<int>> res;
if (s - m > 1 && (int)(cycles).size() > 1) {
int len = min((int)(cycles).size(), s - m);
res.push_back({});
vector<int> newcycle;
for (int i = (int)(cycles).size() - len; i < (int)(cycles).size(); ++i) {
res.back().push_back(cycles[i].back());
for (int j : cycles[i]) {
newcycle.push_back(j);
}
}
reverse((res.back()).begin(), (res.back()).end());
for (int i = 0; i < len; ++i) {
cycles.pop_back();
}
cycles.push_back(newcycle);
}
for (int i = 0; i < (int)(cycles).size(); ++i) {
res.push_back(cycles[i]);
}
cout << (int)(res).size() << endl;
for (int i = 0; i < (int)(res).size(); ++i) {
cout << (int)(res[i]).size() << endl;
for (int j : res[i]) {
cout << j + 1 << " ";
}
cout << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int n, q, tot, dist[maxn], siz[maxn];
vector<int> E[maxn];
map<int, int> Q;
int dfs(int x) {
dist[x] = tot;
Q[tot] = x;
tot++;
int l = E[x].size() - 1;
for (int i = 0; i <= l; i++) {
int y = E[x][i];
siz[x] += dfs(y);
}
if (l == -1)
return 1;
else
return siz[x] + 1;
}
int main(int argc, char const *argv[]) {
cin >> n >> q;
tot = 1;
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
E[x].push_back(i);
}
dfs(1);
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
y--;
if (dist[x] > n - y)
cout << "-1" << endl;
else {
if (y > siz[x])
cout << "-1" << endl;
else
cout << Q[dist[x] + y] << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double c[101010 * 5][6];
int a[101010], b[101010];
double dp[101010][101];
int main() {
for (int i = 0; i < 101010 * 5; i++) {
for (int j = 0; j < 6; j++) {
if (i == j || j == 0)
c[i][j] = 1;
else
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
}
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
double ans = 0;
for (int i = 1; i <= n; i++) {
b[i] = a[i];
dp[i][a[i]] = 1;
if (!a[i]) ans += 1;
}
int q, u, v, k;
for (scanf("%d", &q); q--;) {
scanf("%d%d%d", &u, &v, &k);
double *d = dp[u];
ans -= d[0];
for (int i = 0; i <= a[u]; i++) {
d[i] = d[i] * c[b[u] - i][k] / c[b[u]][k];
for (int j = 1, ed = min(k, min(a[u], b[u]) - i); j <= ed; j++) {
d[i] += d[j + i] * c[i + j][j] / c[b[u]][k] * c[b[u] - i - j][k - j];
}
}
b[u] -= k;
b[v] += k;
ans += d[0];
printf("%.10lf\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (ar[j] > ar[i]) count++;
}
cout << count + 1 << endl;
count = 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int b, cap, id;
edge() {}
edge(int b, int cap, int id) : b(b), cap(cap), id(id) {}
};
int n;
pair<int, int> a[5005];
vector<edge> e[5005];
int cur[5005];
edge par[5005];
int pos[5005], ans[5005];
void dfs(int v) {
for (int i = 0; i < e[v].size(); i++) {
if (e[v][i].id == par[v].id) continue;
par[e[v][i].b] = edge(v, e[v][i].cap, e[v][i].id);
dfs(e[v][i].b);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
pos[i] = i;
}
sort(a + 1, a + n + 1);
for (int i = 1, u, v, c; i < n; i++) {
cin >> u >> v >> c;
e[u].push_back(edge(v, c, i));
e[v].push_back(edge(u, c, i));
}
dfs(1);
for (int ct = 1, day = 1; ct < n; day++) {
memset(cur, 0, sizeof(cur));
for (int j = 1; j <= n; j++) {
int i = a[j].second;
if (pos[i] == 1 || cur[par[pos[i]].id] >= par[pos[i]].cap) continue;
cur[par[pos[i]].id]++;
pos[i] = par[pos[i]].b;
if (pos[i] == 1) {
ct++;
ans[i] = day;
}
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 10e9 + 7;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long test;
cin >> test;
while (test--) {
long long n, second;
cin >> n >> second;
long long m = n / 2 + 1;
cout << (long long)(floor(second / m)) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct laptop {
long a, b;
};
bool compare(laptop const& i, laptop const& j) { return (i.a < j.a); }
int main() {
long n, i, j;
laptop x[100000];
cin >> n;
for (i = 0; i < n; i++) cin >> x[i].a >> x[i].b;
sort(x, x + n, &compare);
if (n == 1) {
cout << "Poor Alex";
return 0;
}
for (i = 1; i < n; i++)
if (x[i - 1].b > x[i].b) {
cout << "Happy Alex";
return 0;
}
{
cout << "Poor Alex";
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int mapp[405][405];
int vis[405];
int v[405];
struct node {
int u;
int c;
node() {}
node(int _u, int _c) : c(_c), u(_u) {}
};
queue<node> q;
int bfs(int t) {
int cnt = 0;
int pos;
node no;
no.u = 1;
no.c = 0;
while (!q.empty()) {
q.pop();
}
q.push(no);
memset(v, 0, sizeof(v));
v[1] = 1;
while (!q.empty()) {
cnt = q.front().c + 1;
pos = q.front().u;
q.pop();
for (int j = 1; j <= n; j++) {
if (mapp[pos][j] == t && (j == n || vis[j] != cnt) && v[j] == 0) {
v[j] = cnt;
vis[j] = cnt;
q.push(node(j, cnt));
if (j == n) {
return cnt;
}
}
}
}
return -1;
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
memset(mapp, 0, sizeof(mapp));
for (int i = 0, a, b; i < m; i++) {
scanf("%d%d", &a, &b);
mapp[a][b] = 1;
mapp[b][a] = 1;
}
memset(vis, 0, sizeof(vis));
int bus = bfs(0);
int tran = bfs(1);
if (bus == -1 || tran == -1) {
printf("-1\n");
} else {
printf("%d\n", max(bus, tran));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long n;
long long ans[2002];
void solve(long long x, long long y, long long st) {
if (x >= y) return;
long long yo;
if (st == 0)
yo = 100;
else
yo = -1;
for (long long i = y; i >= x; i--) {
if (st == 1) {
yo = max(yo, (long long)(s[i] - 'a'));
} else if (st == 0) {
yo = min(yo, (long long)(s[i] - 'a'));
}
}
for (long long i = y; i >= x; i--) {
if ((long long)(s[i] - 'a') == yo) {
ans[i] = 1;
solve(x, i - 1, 1 - st);
return;
}
}
}
int main() {
cin >> s;
n = s.length();
solve(0, n - 1, 0);
for (long long i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
int s;
s = 0;
while (b != 0) {
s = s * 10 + b % 10;
b = b / 10;
}
cout << s + a;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline long long minize(long long& a, long long b) {
return a = (a > b ? b : a);
}
inline long long maxize(long long& a, long long b) {
return a = (a < b ? b : a);
}
inline string toString(long long n) {
stringstream ss;
ss << n;
return ss.str();
}
double const eps = 1e-6;
long long const Base = 1e9 + 7, oo = 1e17, MAXN = 1e6;
long long A[MAXN + 5], C[MAXN + 5], lev;
vector<long long> dske[MAXN + 5];
bitset<MAXN + 5> bi;
pair<long long, long long> go(long long x) {
bi[x] = 1;
long long v = (C[x] ? oo : 0), sum = 0, flag = 0;
for (long long i = 0; i < dske[x].size(); i++) {
if (bi[dske[x][i]]) continue;
flag = 1;
pair<long long, long long> xx = go(dske[x][i]);
if (C[x])
minize(v, xx.first);
else
v += xx.first;
sum += xx.second;
}
if (!flag) {
lev++;
return make_pair(1, 1);
}
return make_pair(v, sum);
}
long long Solves() {
long long n, m, k, cnt = 0, ans = 0, x, y, q, c, sum = 0, v, t;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> C[i];
for (long long i = 2; i <= n; i++) {
cin >> x;
dske[x].push_back(i);
}
ans = go(1).first;
assert(ans >= 1 and ans <= lev);
cout << (lev - ans + 1) << endl;
return 0;
}
int main() {
long long JUDGE_ONLINE = 1;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long test = 1;
for (long long T = 1; T <= test; T++) {
Solves();
}
if (!JUDGE_ONLINE)
cout << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e7 + 4;
int solve() {
int n;
scanf("%d", &n);
int req = 0;
int a[n + 1];
for (int i = 1; i < n + 1; i++) scanf("%d", &a[i]), req ^= a[i];
if (n % 2 == 0 and req != 0) {
printf("NO\n");
return 0;
}
printf("YES\n");
vector<tuple<int, int, int>> v;
int i = 1, j;
for (i = 1; i + 2 <= n; i += 2) {
j = i;
v.push_back({i, i + 1, i + 2});
}
for (i = j; i - 2 >= 1; i -= 2) v.push_back({i, i - 1, i - 2});
printf("%d\n", (int)v.size());
for (auto it : v) printf("%d %d %d\n", get<0>(it), get<1>(it), get<2>(it));
return 0;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int i, j, k, n, x;
long long ans = 0;
scanf("%d%d", &n, &x);
v.clear();
for (i = 0; i < n; i++) {
scanf("%d", &j);
v.push_back(j);
}
sort(v.begin(), v.end());
int sz = v.size();
for (i = 0; i < sz; i++) {
if (x <= 1) x = 1;
ans += (long long)x * v[i];
x--;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
int a[maxn];
int main() {
int n;
while (~scanf("%d", &n)) {
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == -1) continue;
int flag = 0;
int temp = a[i];
for (int j = i + 1; j <= n; j++) {
while (temp == a[j] || a[j] == -1) {
j++;
}
if (j <= n) {
temp = a[j];
a[j] = -1;
flag = 1;
ans++;
}
}
if (!flag) break;
a[i] = -1;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int get_need(long long int v) {
long long int cur = 1;
while ((1LL << cur) < v) cur++;
return cur;
}
int main() {
int n;
cin >> n;
map<long long int, int> mp;
vector<long long int> needs(60);
vector<long long int> store(60);
for (int i = 0; i < n; i++) {
long long int a;
cin >> a;
mp[a]++;
needs[get_need(a)]++;
}
int cnt = 0;
for (int c = 1; c <= n; c++) {
if (mp[1] == 0) break;
long long int cur = 0;
while (mp[1LL << cur]) {
mp[1LL << cur]--;
needs[get_need(1LL << cur)]--;
cur++;
}
store[cur]++;
long long int sum_store = 0;
bool can = true;
for (int z = 59; z >= 0; z--) {
sum_store += store[z];
sum_store -= needs[z];
if (sum_store < 0) {
can = false;
break;
}
}
if (can) {
cnt++;
cout << c << " ";
}
}
if (!cnt) cout << -1;
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long summ = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch) && ch != '-'; ch = getchar())
;
if (ch == '-') f = -1, ch = getchar();
for (; isdigit(ch); ch = getchar())
summ = (summ << 3) + (summ << 1) + ch - 48;
return summ * f;
}
const long long M = 5e5 + 5;
long long n, m, ok, head[M], siz[M], nex[M], no, go[M], a[M], etot, f[M],
flag[M], g[M], fa[M], vis[M], dfn[M], out[M], is[M];
long long dep[M], son[M], tp[M];
stack<long long> s;
vector<long long> G[M];
inline void Addedge(long long u, long long v) {
nex[++etot] = head[u];
head[u] = etot;
go[etot] = v;
}
void dfs1(long long u, long long father) {
dep[u] = dep[father] + 1;
siz[u] = 1;
fa[u] = father;
dfn[u] = ++no;
long long maxson = -1;
for (long long i = head[u]; i; i = nex[i]) {
long long v = go[i];
if (v == fa[u]) continue;
dfs1(v, u);
siz[u] += siz[v];
if (siz[v] > maxson) maxson = siz[v], son[u] = v;
}
out[u] = ++no;
}
void dfs2(long long u, long long topfa) {
tp[u] = topfa;
if (son[u]) dfs2(son[u], topfa);
for (long long i = head[u]; i; i = nex[i]) {
long long v = go[i];
if (v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
inline long long Getlca(long long x, long long y) {
while (tp[x] != tp[y]) {
if (dep[tp[x]] > dep[tp[y]])
x = fa[tp[x]];
else
y = fa[tp[y]];
}
if (dep[x] > dep[y]) swap(x, y);
return x;
}
inline bool cmp1(long long x, long long y) { return dfn[x] < dfn[y]; }
inline bool cmp2(long long x, long long y) {
long long xx = (x > 0) ? dfn[x] : out[-x], yy = (y > 0) ? dfn[y] : out[-y];
return xx < yy;
}
void dfsdp(long long u) {
long long cnt = 0;
for (long long i = 0; i < G[u].size(); i++) {
long long v = G[u][i];
dfsdp(v);
f[u] += f[v];
if (g[v] || is[v]) cnt++;
}
if (is[u])
f[u] += cnt;
else if (cnt == 1)
g[u] = 1;
else if (cnt > 1)
f[u]++, g[u] = 0;
}
inline long long Solve() {
long long q = getint();
for (long long i = 1; i <= q; i++)
a[i] = getint(), vis[a[i]] = 1, is[a[i]] = 1, flag[fa[a[i]]] = 1;
for (long long i = 1; i <= q; i++)
if (flag[a[i]]) {
for (long long j = 1; j <= q; j++)
if (a[j] > 0) vis[a[j]] = is[a[j]] = flag[fa[a[j]]] = 0;
return -1;
}
sort(a + 1, a + q + 1, cmp1);
for (long long i = 2; i <= q; i++) {
long long lca = Getlca(a[i - 1], a[i]);
if (!vis[lca]) {
a[++q] = lca;
vis[lca] = 1;
}
}
long long nq = q;
for (long long i = 1; i <= nq; i++) a[++q] = -a[i];
if (!vis[1]) a[++q] = 1, a[++q] = -1;
sort(a + 1, a + q + 1, cmp2);
while (!s.empty()) s.pop();
for (long long i = 1; i <= q; i++) {
if (a[i] > 0)
s.push(a[i]);
else {
long long v = s.top();
s.pop();
if (!s.empty()) {
long long u = s.top();
G[u].push_back(v);
}
}
}
dfsdp(1);
long long ans = f[1];
for (long long i = 1; i <= q; i++)
if (a[i] > 0)
vis[a[i]] = is[a[i]] = flag[fa[a[i]]] = f[a[i]] = g[a[i]] = 0,
G[a[i]].clear();
return ans;
}
signed main() {
cin >> n;
for (long long i = 1, u, v; i < n; i++) {
u = getint();
v = getint();
Addedge(u, v);
Addedge(v, u);
}
dfs1(1, 0);
dfs2(1, 1);
cin >> m;
while (m--) {
cout << Solve() << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long a[300000], ind[300000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
long long a[n + 1][m + 1], ans[n + 1][m + 1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
vector<vector<long long> > row(n + 1), col(m + 1);
set<long long>::iterator it;
for (int i = 1; i <= n; i++) {
set<long long> st;
for (int j = 1; j <= m; j++) st.insert(a[i][j]);
for (it = st.begin(); it != st.end(); it++) row[i].push_back(*(it));
}
for (int j = 1; j <= m; j++) {
set<long long> st;
for (int i = 1; i <= n; i++) st.insert(a[i][j]);
for (it = st.begin(); it != st.end(); it++) col[j].push_back(*(it));
}
vector<long long>::iterator itr, itc;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
long long rl, cl, rm, cm;
itr = lower_bound(row[i].begin(), row[i].end(), a[i][j]);
rl = itr - row[i].begin();
itc = lower_bound(col[j].begin(), col[j].end(), a[i][j]);
cl = itc - col[j].begin();
itr = upper_bound(row[i].begin(), row[i].end(), a[i][j]);
if (itr == row[i].end())
rm = 0;
else
rm = row[i].size() - (itr - row[i].begin());
itc = upper_bound(col[j].begin(), col[j].end(), a[i][j]);
if (itc == col[j].end())
cm = 0;
else
cm = col[j].size() - (itc - col[j].begin());
ans[i][j] = max(rl, cl) + 1 + max(cm, rm);
cout << ans[i][j] << " ";
}
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
char ibuf[(1 << 18)], *iS, *iT, obuf[(1 << 18)],
*oS = obuf, *oT = oS + (1 << 18) - 1, c, qu[55];
int f, qr;
inline void flush(void) {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
return;
}
inline char getch(void) {
return (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, (1 << 18), stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void putch(char x) {
*oS++ = x;
if (oS == oT) flush();
return;
}
void putstr(string str, int begin = 0, int end = -1) {
if (end == -1) end = str.size();
for (register int i = begin; i < end; i++) putch(str[i]);
return;
}
template <typename T>
inline T read() {
register T x = 0;
for (f = 1, c = getch(); c < '0' || c > '9'; c = getch())
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = getch()) x = x * 10 + (c & 15);
x *= f;
return x;
}
template <typename T>
inline void write(const T& t) {
register T x = t;
if (!x) putch('0');
if (x < 0) putch('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) putch(qu[qr--]);
return;
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io::getch;
using io::putch;
using io::putstr;
using io::read;
using io::write;
template <int mod, int base>
class Hash {
private:
int f[100005], p[100005];
public:
void init(string s, int n) {
p[0] = 1;
for (register int i = 1; i <= n; i++) {
f[i] = (1LL * f[i - 1] * base + s[i] - 'a') % mod;
p[i] = 1LL * p[i - 1] * base % mod;
}
return;
}
inline int get(int l, int r) {
return ((f[r] - 1LL * f[l - 1] * p[r - l + 1]) % mod + mod) % mod;
}
};
string S, T;
int f[100005], g[100005], pos[100005];
Hash<1000000007, 31> hashs1, hasht1;
Hash<1000000009, 31> hashs2, hasht2;
int main() {
ios::sync_with_stdio(false);
cin >> S >> T;
int n = S.size(), m = T.size();
S = ' ' + S, T = ' ' + T;
hashs1.init(S, n), hashs2.init(S, n);
hasht1.init(T, m), hasht2.init(T, m);
int hash1 = hasht1.get(1, m), hash2 = hasht2.get(1, m);
for (register int i = 1; i <= n; i++)
if (i >= m && hashs1.get(i - m + 1, i) == hash1 &&
hashs2.get(i - m + 1, i) == hash2)
pos[i] = i - m + 1;
else
pos[i] = pos[i - 1];
f[0] = g[0] = 1;
for (register int i = 1; i <= n; i++) {
f[i] = f[i - 1];
if (pos[i]) f[i] = (f[i] + g[pos[i] - 1]) % 1000000007;
g[i] = (g[i - 1] + f[i]) % 1000000007;
}
write((f[n] - 1 + 1000000007) % 1000000007), putch('\n');
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct bian {
int next, point, w;
} b[210000];
int bo[110000], p[110000], n, len, m, u, v, del, pdu, pdv, pd[110000], an0, an1,
tot, dp[110000][2][2];
const int mo = 1e9 + 7;
void ade(int k1, int k2, int k3) {
b[++len] = (bian){p[k1], k2, k3};
p[k1] = len;
}
void add(int k1, int k2, int k3, int k4) {
k1 = abs(k1);
k2 = abs(k2);
ade(k1, k2, k3);
ade(k2, k1, k4);
}
void dfs(int k, int pre) {
tot -= 2;
pd[k] = 1;
for (int i = p[k]; i != -1; i = b[i].next) {
int j = b[i].point;
tot++;
if (j == k) tot++;
if (pd[j] == 0)
dfs(j, i);
else if (i != (pre ^ 1)) {
u = k;
v = j;
del = i;
}
}
}
int check(int k1, int k2, int k3) {
if ((k3 & 2) == 0) k1 ^= 1;
if ((k3 & 1) == 0) k2 ^= 1;
return (k1 | k2);
}
void treedp(int k1, int k2) {
for (int i = p[k1]; i != -1; i = b[i].next) {
int j = b[i].point;
if (j == k2 || i == del || (i ^ 1) == del) continue;
treedp(j, k1);
}
memset(dp[k1], 0x00, sizeof dp[k1]);
for (int w = 0; w < 2; w++) {
if (k1 == u && w != pdu) continue;
if (k1 == v && w != pdv) continue;
int ans0 = 1, ans1 = 0;
for (int i = p[k1]; i != -1; i = b[i].next) {
int j = b[i].point;
if (j == k2 || i == del || (i ^ 1) == del) continue;
int an0 = ans0, an1 = ans1;
ans0 = 0;
ans1 = 0;
for (int w1 = 0; w1 < 2; w1++) {
int a = dp[j][w1][0], bb = dp[j][w1][1];
if (check(w, w1, b[i].w)) swap(a, bb);
ans0 = (ans0 + 1ll * a * an0 + 1ll * bb * an1) % mo;
ans1 = (ans1 + 1ll * a * an1 + 1ll * bb * an0) % mo;
}
}
if (bo[k1] & (1 << w)) swap(ans0, ans1);
dp[k1][w][0] = (dp[k1][w][0] + ans0) % mo;
dp[k1][w][1] = (dp[k1][w][1] + ans1) % mo;
}
}
void solve(int k) {
tot = 0;
del = -100;
dfs(k, -1);
int ans0 = 0, ans1 = 0;
if (del == -100) {
v = 0;
u = k;
pdu = 0;
pdv = 1;
del = -100;
treedp(k, 0);
ans0 = (ans0 + 1ll * dp[k][0][0] + dp[k][1][0]) % mo;
ans1 = (ans1 + 1ll * dp[k][0][1] + dp[k][1][1]) % mo;
pdu = 1;
treedp(k, 0);
ans0 = (ans0 + 1ll * dp[k][0][0] + dp[k][1][0]) % mo;
ans1 = (ans1 + 1ll * dp[k][0][1] + dp[k][1][1]) % mo;
} else {
for (pdu = 0; pdu < 2; pdu++)
for (pdv = 0; pdv < 2; pdv++) {
treedp(u, 0);
if (check(pdu, pdv, b[del].w)) {
swap(dp[u][0][0], dp[u][0][1]);
swap(dp[u][1][0], dp[u][1][1]);
}
ans0 = (ans0 + 1ll * dp[u][0][0] + dp[u][1][0]) % mo;
ans1 = (ans1 + 1ll * dp[u][0][1] + dp[u][1][1]) % mo;
}
}
int k1 = an0, k2 = an1;
an0 = (1ll * k1 * ans0 + 1ll * k2 * ans1) % mo;
an1 = (1ll * k2 * ans0 + 1ll * k1 * ans1) % mo;
}
int main() {
len = -1;
memset(p, 0xff, sizeof p);
scanf("%d%d", &m, &n);
for (; m; m--) {
int k1;
scanf("%d", &k1);
if (k1 == 1) {
int k2;
scanf("%d", &k2);
if (k2 > 0)
bo[k2] |= 2;
else
bo[-k2] |= 1;
} else if (k1 == 2) {
int k2;
scanf("%d%d", &k1, &k2);
if (k1 < 0 && k2 < 0) add(k1, k2, 0, 0);
if (k1 < 0 && k2 > 0) add(k1, k2, 1, 2);
if (k1 > 0 && k2 < 0) add(k1, k2, 2, 1);
if (k1 > 0 && k2 > 0) add(k1, k2, 3, 3);
}
}
an0 = 1;
an1 = 0;
for (int i = 1; i <= n; i++)
if (pd[i] == 0) solve(i);
printf("%d\n", an1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x = 0, i;
string s;
int n;
cin >> n;
while (n--) {
cin >> s;
for (i = 0; i < s.length(); i++) {
if (s[i] == '+') {
x = x + 1;
break;
} else if (s[i] == '-') {
x = x - 1;
break;
}
}
}
cout << x << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, x, y;
string s;
int main() {
cin >> n >> s;
for (int i = 0; i < n; ++i) {
if (s[i] == 'L') x--;
if (s[i] == 'R') x++;
if (s[i] == 'U') y++;
if (s[i] == 'D') y--;
}
ans = n - abs(x) - abs(y);
cout << ans << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct Linear_Basis {
long long b[63], nb[63], tot;
void init() {
tot = 0;
memset(b, 0, sizeof(b));
memset(nb, 0, sizeof(nb));
}
bool Insert(long long x) {
for (int i = 62; i >= 0; i--) {
if (x & (1LL << i)) {
if (!b[i]) {
b[i] = x;
break;
}
x ^= b[i];
}
}
return x > 0;
}
long long Max(long long x) {
long long ret = x;
for (int i = 62; i >= 0; i--) ret = max(ret, ret ^ b[i]);
return ret;
}
long long Min(long long x) {
long long ret = x;
for (int i = 0; i <= 62; i++)
if (b[i]) ret ^= b[i];
return ret;
}
void rebuild() {
for (int i = 62; i >= 0; i--)
for (int j = i - 1; j >= 0; j--)
if (b[i] & (1LL << j)) b[i] ^= b[j];
for (int i = 0; i <= 62; i++)
if (b[i]) nb[tot++] = b[i];
}
long long K_Min(long long k) {
long long res = 0;
if (k >= (1LL << tot)) return -1;
for (int i = 62; i >= 0; i--)
if (k & (1LL << i)) res ^= nb[i];
return res;
}
} LB;
int main() {
int n, t, m, i, j, k, l, r;
cin >> n;
string s[55];
for (i = 0; i < n; i++) cin >> s[i];
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
if (s[i][j] == '.') {
if (j + 1 < n && j - 1 >= 0 && i + 2 < n && s[i + 1][j] == '.' &&
s[i + 1][j - 1] == '.' && s[i + 1][j + 1] == '.' &&
s[i + 2][j] == '.') {
s[i][j] = s[i + 1][j] = s[i + 1][j - 1] = s[i + 1][j + 1] =
s[i + 2][j] = '#';
} else {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 22) + 5;
int n, m, ara[N], has[N], vis[N], M;
bool Check(int num, int pos) { return num & (1 << pos); }
int Set(int num, int pos) { return num | (1 << pos); }
void dfs(int s) {
if (vis[s]) return;
vis[s] = 1;
if (has[s]) dfs(M - s);
for (int i = 0; i < n; i++)
if (Check(s, i)) dfs(s ^ (1 << i));
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &ara[i]);
has[ara[i]] = 1;
}
M = (1 << n) - 1;
int ans = 0;
for (int i = 0; i <= M; i++) {
if (!has[i] or vis[i]) continue;
dfs(M - i);
ans++;
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
long long a[100005], c[100005];
pair<long long, long long> inp[100005];
int main() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%lld", a + i);
}
for (int i = 1; i <= N; i++) {
scanf("%lld", c + i);
inp[i] = {c[i], i};
}
sort(inp + 1, inp + N + 1);
int j = 1;
while (M--) {
int t;
long long d;
scanf("%d %lld", &t, &d);
long long A = min(a[t], d);
a[t] -= A;
d -= A;
long long remain = 0;
while (j <= N && d) {
long long B = min(a[inp[j].second], d);
d -= B;
a[inp[j].second] -= B;
remain += B * inp[j].first;
if (!d) break;
j++;
}
printf("%lld\n", d ? 0 : A * c[t] + remain);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long sol[n];
int left = 0, right = n / 2;
int k = 0;
while (left < n / 2) {
sol[k++] = arr[right];
sol[k++] = arr[left];
left++;
right++;
}
if (n % 2 != 0) {
sol[k] = arr[right];
}
int cnt = 0;
for (int i = 1; i < n - 1; i++) {
if (sol[i] < sol[i + 1] && sol[i] < sol[i - 1]) {
cnt++;
}
}
cout << cnt << endl;
for (int i = 0; i < n; i++) {
cout << sol[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
static int aQWEs = []() -> int {
ios::sync_with_stdio(false);
cin.tie(NULL);
return 0;
}();
long long int power(long long int a, long long int p,
long long int m = 1000000007) {
a %= m;
long long int val = 1;
while (p > 0) {
if (p & 1) {
val = (val * a) % m;
}
a = (a * a) % m;
p >>= 1;
}
return (val);
}
int dfs(const vector<int>& v, std::vector<bool>& vis, int cur, int depth) {
vis[cur] = 1;
if (!vis[v[cur]]) return dfs(v, vis, v[cur], depth + 1);
return depth;
}
int main() {
long long int i, j;
int T = 1;
while (T--) {
int n;
cin >> n;
std::vector<int> v(n + 1);
std::vector<bool> vis(n + 1);
int ans = 0;
for (i = 1; i <= n; ++i) {
cin >> v[i];
}
for (i = 1; i <= n; ++i) {
if (!vis[i]) ans += dfs(v, vis, i, 0);
}
if (!((3 * n - ans) & 1)) {
cout << "Petr\n";
} else
cout << "Um_nik\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
template <class T>
bool get_max(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
template <class T>
bool get_min(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
int main() {
int a, b, n, i, c;
cin >> a >> b >> n;
i = 0;
while (i < n) {
c = a + b;
a = b;
b = c;
i++;
}
cout << a << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 9;
unordered_map<int, unordered_map<int, int>> segtree;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int q;
cin >> q;
int a, t, x;
int lf, rf, ans;
for (int i = 0; i < q; i++) {
cin >> a >> t >> x;
if (a != 3) {
t += MOD;
if (a == 1) segtree[x][t]++;
if (a == 2) segtree[x][t]--;
t /= 2;
while (t >= 1) {
segtree[x][t] = segtree[x][t * 2] + segtree[x][t * 2 + 1];
t /= 2;
}
} else {
lf = 1, rf = t;
lf += MOD;
rf += MOD;
ans = 0;
while (lf <= rf) {
if (lf % 2 == 1) {
ans += segtree[x][lf];
lf++;
}
if (rf % 2 == 0) {
ans += segtree[x][rf];
rf--;
}
lf /= 2;
rf /= 2;
}
cout << ans << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c, d;
cin >> a >> b >> c >> d;
printf("%.10lf", (a * d) / (b * d - (b - a) * (d - c)));
}
| 2 |
#include <bits/stdc++.h>
const int SMALL_LOOKUP_TABLE = 1000;
const int BIG_LOOKUP_TABLE = 1000000;
const int BIG_INT = (1 << 31) - 1;
const int SMALL_INT = BIG_INT + 1;
const long long BIG_LL = ((long long)1 << (long long)63) - 1;
const long long SMALL_LL = BIG_LL + 1;
using namespace std;
string replace(string w, string pat, string repl) {
int i = w.find(pat);
int j = pat.length();
if (i == -1) {
return w;
} else {
return w.replace(i, j, repl);
}
}
string replacify(string w, string pat, string repl) {
string new_w = "";
while (w != new_w) {
new_w = w;
w = replace(w, pat, repl);
}
return w;
}
int main() {
int j, i, last_i, n;
cin >> n;
vector<string> words(n);
for ((i) = 0; (i) < (n); (i)++) cin >> words[i];
for ((i) = 0; (i) < (n); (i)++) {
words[i] = replacify(words[i], "u", "oo");
words[i] = replacify(words[i], "kh", "h");
words[i] = replacify(words[i], "oo", "u");
}
sort(words.begin(), words.end());
last_i = 0;
j = 1;
for ((i) = (1); (i) < (n); (i)++) {
if (words[i] != words[last_i]) {
last_i = i;
j++;
}
}
cout << j << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(pair<int64_t, int64_t> a, pair<int64_t, int64_t> b) {
return (a.second < b.second);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int64_t n, a = 0, b = 0;
string s;
cin >> n >> s;
if (n % 2) return cout << ":(", 0;
for (auto c : s) a += (c == '(');
a = n / 2 - a;
for (auto& c : s) {
if (c == '?') {
if (a)
c = '(', a--;
else
c = ')';
}
}
a = 0;
for (int64_t i = 0; i < n - 1; i++) {
a += (s[i] == '(' ? 1 : -1);
if (a <= 0) return cout << ":(", 0;
}
a += (s.back() == '(' ? 1 : -1);
if (a) return cout << ":(", 0;
cout << s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d", &x, &y);
}
for (int i = 0; i < n; i++) {
printf("%d", i % 2);
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 100000;
for (int i = 0; i < n - 1; i++) {
ans = min(ans, max(a[i], a[i + 1]));
}
int z = min(a[0], a[n - 1]);
cout << min(ans, z);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXPRIME = 1000000;
const int MAXPRIMECNT = 78498;
bool tagPrime[MAXPRIME];
int primeCnt, prime[MAXPRIMECNT];
void initPrime() {
tagPrime[0] = tagPrime[1] = true;
for (int i = 2; i < MAXPRIME; i++) {
if (tagPrime[i]) continue;
prime[primeCnt++] = i;
if (i >= MAXPRIME / i) continue;
for (int j = i * i; j < MAXPRIME; j += i) {
tagPrime[j] = true;
}
}
}
long long A;
vector<vector<long long> > candidates;
void initPossible() {
for (int i = (0); i < (primeCnt); i++) {
long long value = prime[i];
bool first = true;
while (true) {
if (!(A % (value + 1))) {
if (first) candidates.push_back(vector<long long>());
first = false;
candidates.back().push_back(value + 1);
}
if (value <= A / prime[i])
value *= prime[i];
else
break;
}
}
}
vector<long long> factors;
void initFactor() {
for (long long i = 1; i <= A / i; i++)
if (!(A % i)) {
factors.push_back(i);
if (i != A / i) factors.push_back(A / i);
}
sort(((factors).begin()), ((factors).end()));
}
vector<long long> ways;
long long calc1() {
ways = vector<long long>(((int)(factors).size()));
ways[0] = 1;
for (__typeof((candidates).begin()) it = (candidates).begin();
it != (candidates).end(); it++) {
for (int i = ((int)(factors).size()) - 1; i >= 0; i--) {
for (__typeof((*it).begin()) jt = (*it).begin(); jt != (*it).end(); jt++)
if (!(factors[i] % *jt)) {
int idx = lower_bound(factors.begin(), factors.begin() + i,
factors[i] / *jt) -
factors.begin();
ways[i] += ways[idx];
}
}
}
return ways.back();
}
struct MillerRabinULL {
static const int _MAXPRIME = 10;
static const unsigned long long _PRIME[_MAXPRIME];
static unsigned long long _powerMod(unsigned long long a,
unsigned long long b,
unsigned long long c) {
unsigned long long ret = 1LL;
for (unsigned long long mul = a; b > 0LL; b >>= 1) {
if (b & 1LL) ret = _productMod(ret, mul, c);
mul = _productMod(mul, mul, c);
}
return ret;
}
static unsigned long long _productMod(unsigned long long a,
unsigned long long b,
unsigned long long c) {
unsigned long long ret = 0LL;
for (unsigned long long add = a; b > 0LL; b >>= 1) {
if (b & 1LL) ret = (ret + add) % c;
add = (add << 1) % c;
}
return ret;
}
static bool isPrime(unsigned long long n) {
if (n < 2LL) return false;
if (n == 2LL) return true;
if ((n & 1LL) == 0LL) return false;
unsigned long long k = 0, m, a;
m = n - 1;
while ((m & 1LL) == 0LL) {
m >>= 1;
k++;
}
for (int i = 0; i < _MAXPRIME; i++) {
if (_PRIME[i] >= n) return true;
a = _powerMod((unsigned long long)_PRIME[i], m, n);
if (a == 1LL) continue;
unsigned long long j = 0;
for (; j < k; j++) {
if (a == n - 1LL) break;
a = _productMod(a, a, n);
}
if (j < k) continue;
return false;
}
return true;
}
};
const unsigned long long MillerRabinULL::_PRIME[] = {2, 3, 5, 7, 11,
13, 17, 19, 23, 29};
long long calc2() {
long long res = 0;
for (__typeof((factors).begin()) it = (factors).begin();
it != (factors).end(); it++)
if (*it - 1 > MAXPRIME && MillerRabinULL::isPrime(*it - 1)) {
int factorIdx =
lower_bound(((factors).begin()), ((factors).end()), A / *it) -
((factors).begin());
res += ways[factorIdx];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
initPrime();
cin >> A;
initPossible();
initFactor();
cout << calc1() + calc2() << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long double EPS = 1e-11;
const long long INFL = 1e16;
const int INF = 2e9 + 7;
mt19937 rnd((unsigned)chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
ans += a[i];
}
map<char, int> paired;
map<char, vector<int>> legal;
for (int i = 0; i < n / 2; ++i) {
if (s[i] == s[n - i - 1]) {
ans -= min(a[i], a[n - i - 1]);
if (paired.count(s[i]) == 0) {
paired[s[i]] = 1;
} else {
++paired[s[i]];
}
} else {
for (char c = 'a'; c <= 'z'; ++c) {
if (c == s[i] || c == s[n - i - 1]) {
continue;
}
if (legal.count(c) == 0) {
legal[c] = {min(a[i], a[n - i - 1])};
} else {
legal[c].push_back(min(a[i], a[n - i - 1]));
}
}
}
}
int needp = 0;
vector<pair<int, char>> ccou;
for (auto it = paired.begin(); it != paired.end(); ++it) {
ccou.push_back({it->second, it->first});
needp += it->second;
}
sort(ccou.begin(), ccou.end());
for (char c = 'a'; c <= 'z'; ++c) {
if (legal.count(c) == 0) {
legal[c] = {INF};
} else {
legal[c].push_back(INF);
sort(legal[c].begin(), legal[c].end());
}
}
if (ccou.size() > 0 && ccou.back().first * 2 >= needp) {
for (int i = 0; i < ccou.back().first * 2 - needp; ++i) {
ans -= legal[ccou.back().second][i];
}
}
cout << ans << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
long long int binsearch(long long int a[], long long int n, long long int x) {
long long int low = 1;
long long int high = n;
long long int ans;
while (low <= high) {
long long int mid = (low + high) / 2;
if (a[mid] == x)
return mid;
else if (a[mid] > x) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long int i, n = s.length();
vector<long long int> v;
long long int p;
for (i = n - 1; i >= 0; i--) {
if (s[i] == 'b') {
p = i + 1;
break;
}
}
for (i = 0; i < p; i++) {
if (s[i] == 'a') v.push_back(i + 1);
}
long long int l = v.size();
long long int d;
long long int ans = p - v[l - 1];
if (l == 1)
cout << ans << endl;
else {
long long int x = ans * 2;
for (i = l - 2; i > 0; i--) {
d = v[i + 1] - v[i] - 1;
x += d;
ans = (ans % 1000000007 + x % 1000000007) % 1000000007;
x = (x % 1000000007 * 2) % 1000000007;
}
d = v[1] - v[0] - 1;
x += d;
ans = (ans % 1000000007 + x % 1000000007) % 1000000007;
cout << ans % 1000000007 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
if (k > n / 2) {
cout << n * (n - 1) / 2;
} else {
long long a = n * (n - 1) / 2;
long long b = (n / 2 - k) * 2 + (n % 2);
cout << a - (b * (b - 1) / 2);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, l, i, j, mas[100001] = {0}, k, d;
char ch_1, ch_2, ch_3;
int main() {
cin >> n >> m;
while (true)
for (i = 1; i <= n; i++) {
if (m < i) {
cout << m;
return 0;
goto iq;
}
m = m - i;
}
iq:
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long int u, v, w;
node() {}
node(long long int _u, long long int _v, long long int _w) {
u = _u;
v = _v;
w = _w;
}
bool operator<(const node &a) const { return w < a.w; }
};
vector<node> e;
vector<long long int> station;
vector<pair<long long int, long long int> > wire;
long long int p[2005], x[2005], y[2005], c[2005], km[2005], n;
long long int find(long long int x) {
if (p[x] == x) return x;
return p[x] = find(p[x]);
}
long long int kruskal() {
long long int i, j, sz, a, b, cnt = 0, ans = 0, u, v;
sort(e.begin(), e.end());
sz = e.size();
for (j = 0; j < sz; j++) {
a = find(e[j].u);
b = find(e[j].v);
if (a != b) {
p[a] = b;
ans += e[j].w;
if (e[j].u == 0)
station.push_back(e[j].v);
else if (e[j].v == 0)
station.push_back(e[j].u);
else
wire.push_back(make_pair(e[j].u, e[j].v));
cnt++;
}
if (cnt == n) break;
}
if (cnt == n) return ans;
}
int main() {
long long int i, j, k, l, m, u, v, w, ans = 0, temp;
cin >> n;
for (i = 1; i <= n; i++) cin >> x[i] >> y[i];
for (i = 1; i <= n; i++) cin >> c[i];
for (i = 1; i <= n; i++) cin >> km[i];
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
temp = (abs(x[i] - x[j]) + abs(y[i] - y[j])) * (km[i] + km[j]);
e.push_back(node(i, j, temp));
e.push_back(node(j, i, temp));
}
}
for (i = 1; i <= n; i++) {
e.push_back(node(0, i, c[i]));
e.push_back(node(i, 0, c[i]));
p[i] = i;
}
ans = kruskal();
cout << ans << endl;
cout << station.size() << endl;
for (i = 0; i < station.size(); i++) cout << station[i] << " ";
cout << endl;
cout << wire.size() << endl;
for (i = 0; i < wire.size(); i++)
cout << wire[i].first << " " << wire[i].second << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
int sum = 0;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
sum += x;
}
printf("%d\n", min(sum, m));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) { return a > b ? a : b; }
int t, n, k, x[200009], head[200009], tail[200009], head_max[200009];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &x[i]);
int lowest_y = 1e9 + 1, y;
for (int i = 0, y; i < n; ++i) {
scanf("%d", &y);
}
sort(x + 1, x + n + 1);
int end = n;
head[n + 1] = 0;
for (int i = n; i >= 1; --i) {
head[i] = head[i + 1] + 1;
while (x[end] - x[i] > k) {
--head[i];
--end;
}
}
int start = 1;
tail[0] = 0;
for (int i = 1; i <= n; ++i) {
tail[i] = tail[i - 1] + 1;
while (x[i] - x[start] > k) {
--tail[i];
++start;
}
}
head_max[n + 1] = 0;
for (int i = n; i >= 1; --i) {
head_max[i] = max(head[i], head_max[i + 1]);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
ans = max(ans, tail[i] + head_max[i + 1]);
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<long long, vector<long long>> M;
bool res[100010];
int main() {
long long n;
long long k;
cin >> n >> k;
long long S = 0;
for (long long i = 1; i <= n; i++) {
long long a;
cin >> a;
M[a].push_back(i);
S += a;
}
if (S < k) {
cout << "-1";
return (0);
}
if (S == k) return (0);
long long lv_prev = 0;
long long tmp = n;
map<long long, vector<long long>>::iterator it = M.begin();
while (true) {
long long lv = it->first;
if (k >= (lv - lv_prev) * tmp) {
k -= ((lv - lv_prev) * tmp);
tmp -= it->second.size();
} else
break;
it++;
lv_prev = lv;
}
long long dlt = k / tmp + lv_prev;
k %= tmp;
vector<pair<long long, long long>> V;
for (; it != M.end(); it++) {
for (long long i = 0; i < it->second.size(); i++) {
V.push_back(make_pair(it->second[i], it->first - dlt));
}
}
sort(V.begin(), V.end());
cout << "";
for (int i = 0; i < k; i++) {
V[i].second -= 1;
V.push_back(V[i]);
}
for (int i = k; i < V.size(); i++)
if (V[i].second > 0) cout << V[i].first << " ";
exit:
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long MX = 2e5 + 5;
inline void norm(long long &a) {
a %= mod;
(a < 0) && (a += mod);
}
inline long long modAdd(long long a, long long b) {
a %= mod, b %= mod;
norm(a), norm(b);
return (a + b) % mod;
}
inline long long modSub(long long a, long long b) {
a %= mod, b %= mod;
norm(a), norm(b);
return (a - b) % mod;
}
inline long long modMul(long long a, long long b) {
a %= mod, b %= mod;
norm(a), norm(b);
return (a * b) % mod;
}
long long bigMod(long long N, long long P) {
if (P == 0) return 1;
if (P % 2 == 0) {
long long ret = bigMod(N, P / 2);
return modMul(ret, ret);
} else
return modMul(N, bigMod(N, P - 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tc;
cin >> tc;
while (tc--) {
long long n, m;
cin >> n >> m;
long long ar[n][m];
long long mn = INT_MAX;
long long sum = 0;
long long cnt = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> ar[i][j];
cnt += (ar[i][j] < 0);
sum += abs(ar[i][j]);
mn = min(mn, abs(ar[i][j]));
}
}
if (cnt % 2) sum -= 2 * mn;
cout << sum << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, b, d, x, sum, ans;
int main() {
cin >> n >> b >> d;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x > b) continue;
if (sum + x > d) {
ans++;
sum = 0;
} else
sum += x;
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> G[100001];
vector<long long int> changed;
long long int visited[100001], level[100001], initial[100001], goal[100001], n,
a, b, answer;
void init() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(level, -1, sizeof(level));
memset(visited, -1, sizeof(visited));
answer = 0;
}
void findlevel(long long int i) {
if (i == 1) {
level[i] = 0;
visited[i] = 1;
}
for (long long int j = 0; j < G[i].size(); j++) {
if (visited[G[i][j]] == -1) {
visited[i] = 1;
level[G[i][j]] = level[i] + 1;
findlevel(G[i][j]);
}
}
}
void bfs(long long int i, long long int change, long long int rem) {
if (level[i] % 2 != rem) {
visited[i] = 1;
for (long long int j = 0; j < G[i].size(); j++) {
bfs(G[i][j], change, rem);
}
return;
}
if (change == 0) {
if (initial[i] == goal[i]) {
for (long long int j = 0; j < G[i].size(); j++) {
if (visited[G[i][j]] == -1) {
bfs(G[i][j], 0, rem);
}
}
} else {
changed.push_back(i);
answer++;
for (long long int j = 0; j < G[i].size(); j++) {
if (visited[G[i][j]] == -1) {
bfs(G[i][j], 1, rem);
}
}
}
} else {
if (initial[i] == goal[i]) {
changed.push_back(i);
answer++;
for (long long int j = 0; j < G[i].size(); j++) {
if (visited[G[i][j]] == -1) {
bfs(G[i][j], 0, rem);
}
}
} else {
for (long long int j = 0; j < G[i].size(); j++) {
if (visited[G[i][j]] == -1) {
bfs(G[i][j], 1, rem);
}
}
}
}
}
signed main() {
init();
cin >> n;
for (long long int i = 0; i < n - 1; i++) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
for (long long int i = 1; i <= n; i++) {
cin >> initial[i];
}
for (long long int i = 1; i <= n; i++) {
cin >> goal[i];
}
findlevel(1);
memset(visited, -1, sizeof(visited));
visited[1] = 1;
bfs(1, 0, 0);
memset(visited, -1, sizeof(visited));
visited[1] = 1;
bfs(1, 0, 1);
cout << answer << endl;
for (long long int i = 0; i < changed.size(); i++) {
cout << changed[i] << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1001000];
bool vis[1001000], judge[1001000];
int main() {
int p, k;
cin >> p >> k;
long long ans = 1;
for (int i = 0; i < p - 1; i++)
a[i] = (long long)k * i % p, ans = (ans * p) % 1000000007;
a[p - 1] = (long long)(p - 1) * k % p;
if (!k) {
cout << ans << endl;
return 0;
}
ans = 1;
memset(vis, false, sizeof(vis));
memset(judge, false, sizeof(judge));
judge[0] = 1;
long long pre = 1;
int flag = 0;
for (int i = 1; i <= p; i++) {
pre = (pre * k) % p;
if (pre == 1) judge[i] = 1;
}
for (int i = 0; i < p; i++) {
if (vis[i]) continue;
int x = i, num = 0;
while (!vis[x]) {
vis[x] = 1;
num++;
x = a[x];
}
if (num == 0) flag++;
if (judge[num]) ans = (ans * p) % 1000000007;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 112345;
int n, m, a, b, vis[MAX], dis[MAX];
vector<int> adj[MAX];
queue<int> q;
void bfs(int v) {
memset(dis, 0, sizeof(dis));
memset(vis, 0, sizeof(dis));
q.push(v);
vis[v] = 1;
while (!q.empty()) {
int top = q.front();
q.pop();
int tam = adj[top].size();
for (int i = 0; i < tam; i++) {
int u = adj[top][i];
if (!vis[u]) {
dis[u] = dis[top] + 1;
vis[u] = 1;
q.push(u);
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
bfs(1);
int nxt = 0, ans = 0;
for (int i = 0; i <= n; i++)
if (dis[i] > dis[nxt]) nxt = i;
bfs(nxt);
for (int i = 0; i <= n; i++) ans = max(ans, dis[i]);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
long long n, x, y, d;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n >> x >> y >> d;
if (abs(x - y) % d == 0) {
cout << abs(x - y) / d << endl;
} else if ((y - 1) % d != 0 && (n - y) % d != 0) {
cout << "-1" << endl;
} else {
long long b = n;
if ((y - 1) % d == 0) {
b = (y - 1) / d + ceil(x * 1.0 / d);
}
if ((n - y) % d == 0) {
long long b1 = ((n - y) / d + ceil((n - x) * 1.0 / d));
b = min(b, b1);
}
cout << b << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long INF = -1;
const int M = 1e5 + 5;
long long now[M];
int main() {
int n, x;
scanf("%d%d", &n, &x);
long long minn = INF >> 1, loc, dis = INF >> 1;
x--;
for (int i = 0; i < n; i++) {
scanf("%I64d", &now[i]);
long long tmp = x - i;
if (tmp < 0) {
tmp += n;
}
if (minn > now[i]) {
minn = now[i];
loc = i;
dis = tmp;
} else if (minn == now[i] && dis > tmp) {
loc = i;
dis = tmp;
}
}
long long num = minn * n + dis;
int c = (loc + 1) % n;
for (int i = 0; i < n; i++) {
now[i] -= minn;
}
for (long long i = 0; i < dis; i++) {
now[c]--;
c = (c + 1) % n;
}
now[loc] = num;
for (int i = 0; i < n - 1; i++) {
printf("%I64d ", now[i]);
}
printf("%I64d\n", now[n - 1]);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.