solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10;
vector<int> num;
long long dp[1 << 20], c[21];
long long w[21][21], val[1 << 20][21];
int vis[21], b[21], a[maxn], sum[21];
bool vit[21];
void judge(int x) {
num.clear();
for (int i = 1; x; i++) {
if (x & 1) num.push_back(i);
x >>= 1;
}
}
int main() {
int n, len = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (!vit[a[i]]) b[++len] = a[i];
vit[a[i]] = 1;
}
sort(b + 1, b + 1 + len);
for (int i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + 1 + len, a[i]) - b;
for (int i = 1; i <= n; i++) {
sum[a[i]]++;
for (int j = 1; j <= len; j++) {
if (j == a[i]) continue;
w[a[i]][j] += sum[j];
}
}
memset(dp, 0x3f3f3f3f3f3f3f3f, sizeof(dp));
for (int i = 1; i <= n; i++) {
c[a[i]] += i - 1 - vis[a[i]];
vis[a[i]]++;
}
for (int i = 1; i <= len; i++) dp[1 << (i - 1)] = c[i];
for (int i = 0; i < (1 << len); i++) {
judge(i);
for (int j = 1; j <= len; j++) {
long long x = c[j];
int tmp = 1 << (j - 1);
if ((tmp | i) == i) continue;
for (int k = 0; k < num.size(); k++) x -= w[j][num[k]];
val[i][j] = x;
}
}
for (int i = 0; i < (1 << len); i++) {
for (int j = 1; j <= len; j++) {
int tmp1 = 1 << (j - 1);
if ((tmp1 | i) == i) continue;
if (dp[i] >= 0x3f3f3f3f3f3f3f3f) continue;
tmp1 |= i;
dp[tmp1] = min(dp[tmp1], dp[i] + val[i][j]);
}
}
printf("%lld\n", dp[(1 << len) - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int flag[100005];
int x1, x2, x3;
bool w, r, b;
int main() {
cin >> n >> m;
memset(flag, 0, sizeof(flag));
for (int i = 1; i <= m; i++) {
cin >> x1 >> x2 >> x3;
w = false;
r = false;
b = false;
if (flag[x1] == 1 || flag[x2] == 1 || flag[x3] == 1) w = true;
if (flag[x1] == 2 || flag[x2] == 2 || flag[x3] == 2) r = true;
if (flag[x1] == 3 || flag[x2] == 3 || flag[x3] == 3) b = true;
if (!flag[x1])
if (!w) {
flag[x1] = 1;
w = true;
} else if (!r) {
flag[x1] = 2;
r = true;
} else if (!b) {
flag[x1] = 3;
b = true;
}
if (!flag[x2])
if (!w) {
flag[x2] = 1;
w = true;
} else if (!r) {
flag[x2] = 2;
r = true;
} else if (!b) {
flag[x2] = 3;
b = true;
}
if (!flag[x3])
if (!w) {
flag[x3] = 1;
w = true;
} else if (!r) {
flag[x3] = 2;
r = true;
} else if (!b) {
flag[x3] = 3;
b = true;
}
}
for (int i = 1; i <= n; i++)
if (flag[i])
cout << flag[i] << " ";
else
cout << "1 ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, i, j, max, min, temp, a[105];
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) scanf("%d", &a[i]);
max = 0;
min = 2000;
for (i = 1; i < n - 1; i++) {
max = 0;
for (j = 1; j < n; j++) {
if (j == i) {
j++;
temp = abs(a[j] - a[j - 2]);
} else {
temp = abs(a[j] - a[j - 1]);
}
max = max > temp ? max : temp;
}
if (max < min) {
min = max;
}
}
printf("%d\n", min);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long a, b, c;
cin >> a >> b;
vector<int> v1, v2;
c = (a - b);
if (c % 2)
cout << -1;
else
cout << c / 2 << ' ' << (a + b) / 2;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = ({
int x;
scanf("%d", &x);
x;
});
string s;
cin >> s;
string ans = "no";
for (int d = (1); d < (30); d += (1)) {
for (int i = (0); i < (n); i += (1)) {
int g = 1;
for (int j = (0); j < (5); j += (1)) {
if (i + j * d >= n || s[i + j * d] == '.') {
g = 0;
}
}
if (g) {
ans = "yes";
break;
}
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[100005];
int main() {
long long int n, k, p;
long long int a[100005];
long long int count = 0, i, len, b[100005], j, sum1 = 0;
cin >> n >> k >> p;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2) count++;
}
if (count < k - p)
printf("NO\n");
else if ((count - k + p) % 2 == 1)
printf("NO\n");
else if ((count - k + p) / 2 + (n - count) < p)
printf("NO\n");
else {
for (i = 0; i <= n; i++) b[i] = 1;
printf("YES\n");
len = 0;
for (i = 1; i <= k - p && len < n; i = i + 0) {
if (a[len] % 2) {
v[i].push_back(a[len]);
i++;
b[len] = 0;
}
len++;
}
len = 0, sum1 = 0;
for (i = k - p + 1; i < k && len < n; i = i) {
if (b[len]) {
if (a[len] % 2) {
v[i].push_back(a[len]);
sum1 += a[len];
b[len] = 0;
if (sum1 % 2 == 0) {
i++;
sum1 = 0;
}
}
}
len++;
}
len = 0;
for (j = i; j < k && len < n; j = j) {
if (b[len]) {
v[j].push_back(a[len]);
j++;
b[len] = 0;
}
len++;
}
for (i = 0; i < n; i++)
if (b[i]) v[k].push_back(a[i]);
for (i = 1; i <= k; i++) {
len = v[i].size();
cout << len << " ";
for (j = 0; j < len; j++) cout << v[i][j] << " ";
printf("\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-8;
int main() {
int m;
scanf("%d", &m);
int c[m];
int s = 0;
int sum = 0;
int temp = 0;
int z = 0;
for (int i = 0; i < m; i++) {
scanf("%d", &c[i]);
s += c[i];
}
int x, y;
scanf("%d %d", &x, &y);
for (int i = 0; i < m; i++) {
sum += c[i];
temp = s - sum;
if (sum <= y && sum >= x && temp <= y && temp >= x) {
z = 1;
cout << i + 2 << endl;
break;
}
}
if (z == 0) {
cout << "0" << endl;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
void solve(){
int r, b, d;
cin>>r>>b>>d;
long double diff = max(r, b) - min(r, b);
if (diff/min(r, b)<=d)
cout<<"YES\n";
else
cout<<"NO\n";
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t=1;
cin>>t;
while(t--)
{
solve();
}
return(0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, d, m, l;
bool thoa(long long j1, long long j2) {
long double l1 = j1;
l1 /= d;
long double l2 = j2;
l2 /= d;
for (long long i = (long long)l1; i <= (long long)l2; i++)
if ((i - l1) >= 1e-9 && (l2 - i) >= 1e-9) return true;
return false;
}
int main() {
cin >> n >> d >> m >> l;
bool tot = false;
for (int i = 1; i < n; i++) {
long long j1 = ((i - 1) * m + l);
long long j2 = i * m;
if (thoa(j1, j2)) {
j1 = (i - 1) * m + l + 1;
while (j1 % d) j1++;
cout << j1;
tot = true;
break;
}
}
if (!tot) {
long long j1 = (n - 1) * m + l + 1;
while (j1 % d) j1++;
cout << j1;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct rcm {
int r, c, m;
} p;
int dx[] = {0, 0, 1, 1, 1, 0, -1, -1, -1};
int dy[] = {0, 1, 1, 0, -1, -1, -1, 0, 1};
int main() {
char buffer[100];
char map[15][15];
char enemy[100][15][15];
memset(enemy, '.', sizeof(enemy));
bool visited[100][15][15] = {false};
int curX, curY;
int finX = 0;
int finY = 7;
for (int i = 0; i < 8; i++) {
gets(buffer);
for (int j = 0; j < strlen(buffer); j++) {
map[i][j] = buffer[j];
enemy[0][i][j] = buffer[j];
if (map[i][j] == 'M') {
curX = i;
curY = j;
}
}
}
for (int i = 0; i < 99; i++) {
for (int j = 0; j < 15; j++) {
for (int k = 0; k < 15; k++) {
if (enemy[i][j][k] == 'S' && (j + 1) < 15) {
enemy[i + 1][j + 1][k] = 'S';
}
}
}
}
rcm p = (rcm){curX, curY, 0};
stack<rcm> st;
st.push((rcm){p.r, p.c, p.m});
string res = "LOSE";
while (!st.empty()) {
p = st.top();
st.pop();
if (enemy[p.m][p.r][p.c] != 'S') {
for (int i = 0; i < 9; i++) {
curX = p.r + dx[i];
curY = p.c + dy[i];
if (curX >= 0 && curX < 8 && curY >= 0 && curY < 8) {
if (map[curX][curY] == 'A') {
res = "WIN";
}
if (enemy[p.m][curX][curY] != 'S' && !visited[p.m + 1][curX][curY]) {
visited[p.m + 1][curX][curY] = true;
st.push((rcm){curX, curY, p.m + 1});
}
}
}
}
}
printf("%s\n", res.c_str());
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int mod = 1000000007;
int z[100005][2] = {0};
char a[1024] = {0}, b[1024] = {0};
int main() {
int n = 0, our = 0, i = 0, j = 0, k = 0;
while (scanf("%s%s%d", a, b, &k) == 3) {
n = strlen(a);
if (n != strlen(b)) {
printf("%d\n", 0);
continue;
}
our = 0;
memset(z, 0, sizeof(z));
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (a[(i + j) % n] != b[j]) {
break;
}
}
if (i == 0) {
if (j == n) {
z[0][1] = 1;
} else {
z[0][0] = 1;
}
}
if (j == n) {
our++;
}
}
if (our == 0) {
printf("%d\n", 0);
continue;
}
for (i = 1; i <= k; i++) {
z[i][0] = (z[i - 1][0] * (long long)(n - our - 1) % mod +
z[i - 1][1] * (long long)(n - our) % mod) %
mod;
z[i][1] = (z[i - 1][0] * (long long)our % mod +
z[i - 1][1] * (long long)(our - 1) % mod) %
mod;
}
printf("%d\n", z[k][1]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[10], t[10];
int n, m, k, i, a[31];
void f(int w, int u, int v) {
m = (u + v) / 2;
cout << k - m << " " << m << endl;
cin >> s;
if (w < n) {
if (s[0] == t[0])
f(w + 1, u, m);
else
f(w + 1, m, v);
} else {
if (s[0] == t[0])
cout << k - m + 1 << " " << m << " 1 0" << endl;
else if (k - m != 1)
cout << k - m << " " << m + 1 << " 1 0" << endl;
else
cout << "0 " << k << " 1 0" << endl;
return;
}
}
int main() {
cin >> n;
cout << "0 0" << endl;
cin >> t;
k = (1 << (n - 1));
if (n == 1) {
cout << "0 1 1 1" << endl;
return 0;
}
f(2, 0, k);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double Pi = 4.0 * atan(1.0);
const long long inf = 1e15 + 10;
const int fix = 1e8 + 5;
const int N = 3e5 + 10;
const int M = 1e7 + 5;
const int mod = 1e9 + 7;
long long n, m, k, t, T, len, op, x, y, z;
long long a[N], b[N], c[N], d[N];
long long read() {
long long yy = 0, flag = 1;
char ch = getchar();
while ((ch > '9' || ch < '0') && ch != '-') ch = getchar();
if (ch == '-') flag = -1, ch = getchar();
while (ch >= '0' && ch <= '9') yy = yy * 10 + ch - '0', ch = getchar();
return yy * flag;
}
void DO() {
n = read(), k = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) x = read();
sort(a + 1, a + 1 + n);
long long ans = 0;
c[n + 1] = 0;
for (int i = 1; i <= n; i++) {
x = upper_bound(a + i, a + 1 + n, a[i] + k) - a;
if (x > n)
x = n;
else
x--;
c[i] = x - i + 1;
}
for (int i = n - 1; i >= 1; i--) c[i] = max(c[i], c[i + 1]);
for (int i = 1; i <= n; i++) {
x = upper_bound(a + i, a + 1 + n, a[i] + k) - a;
if (x > n)
x = n;
else
x--;
ans = max(ans, x - i + 1 + c[x + 1]);
}
printf("%lld\n", ans);
}
int main() {
int o;
scanf("%d", &o);
while (o--) {
DO();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int req, d;
};
data v[1001];
int main() {
int n, i, data = 0, turns = 0, plus = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> v[i].req;
}
i = 1;
while (data < n) {
if ((data >= v[i].req) && (v[i].d == 0)) {
v[i].d = 1;
data++;
}
if (plus == 0) i++;
if (i == n + 1) {
if (data != n) turns++;
plus = 1;
}
if (plus == 1) i--;
if (i == 0) {
if (data != n) turns++;
i++;
plus = 0;
}
}
cout << turns;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool u[1001];
bool isPrime(int n) {
if (n == 2) return 1;
if (n == 1 || n % 2 == 0) return 0;
for (int i = 3; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
if (isPrime(i)) {
for (int j = i; j <= n; j *= i) {
u[j] = 1;
}
}
}
int cnt = 0;
for (int i = 2; i <= n; i++) {
cnt += u[i];
}
printf("%d ", cnt);
printf("\n");
for (int i = 1; i <= n; i++) {
if (u[i]) printf("%d ", i);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long sum = 0;
long long mid = n / 2;
for (long long i = 0; i < mid; i++)
sum += (a[i] + a[n - i - 1]) * (a[i] + a[n - i - 1]);
if (n % 2 != 0) sum += a[mid] * a[mid];
cout << sum << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long add(long long a, long long b, long long mod) {
return ((a % mod) + (b % mod)) % mod;
}
long long sub(long long a, long long b, long long mod) {
return ((a % mod) - (b % mod) + mod) % mod;
}
long long mul(long long a, long long b, long long mod) {
return ((a % mod) * (b % mod)) % mod;
}
long long expo(long long base, long long exponent, long long mod) {
long long ans = 1;
while (exponent != 0) {
if ((exponent & 1) == 1) {
ans = ans * base;
ans = ans % mod;
}
base = base * base;
base %= mod;
exponent >>= 1;
}
return ans % mod;
}
int main() {
string s;
int v[1000000];
long long a, b, i, j;
cin >> s;
cin >> a >> b;
long long n = s.length();
for (i = 0; i < n; i++) v[i] = s[i] - '0';
long long r1 = 0, r2 = 0;
i = 0;
while (v[i + 1] == 0) i++;
for (j = i; j >= 0; j--) {
r1 = add(r1, mul(expo(10, i - j, a), v[j], a), a);
}
for (j = n - 1; j > i; j--) {
r2 = add(r2, mul(expo(10, n - 1 - j, b), v[j], b), b);
}
i++;
long long x;
while ((r1 != 0 || r2 != 0) && i < n - 1) {
x = 0;
r1 = add(mul(10, r1, a), v[i], a);
r2 = sub(r2, mul(expo(10, n - 1 - i, b), v[i], b), b);
while (v[i + 1] == 0) {
x++;
i++;
}
r1 = mul(expo(10, x, a), r1, a);
i++;
}
if ((r1 == 0 && r2 == 0) && i <= n) {
cout << "YES" << endl;
for (j = 0; j < i; j++) cout << v[j];
cout << endl;
for (j = i; j < n; j++) cout << v[j];
cout << endl;
} else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
cin >> tt;
while (tt--) {
int n, m;
cin >> n >> m;
if (n == 1 || m == 1)
cout << "YES" << endl;
else if (n == 2 && m == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3", "unroll-loops")
using namespace std;
template <typename T1, typename T2>
inline void chmin(T1& a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1& a, T2 b) {
if (a < b) a = b;
}
const long long MOD = 1e9 + 7;
const long long MAX = 200010;
const double pi = acos(-1);
const long long MAX_N = 1 << 21;
const long long MAX_V = 200010;
long long n, dat[2 * MAX_N - 1];
long long id[MAX_V];
void init(long long n_) {
n = 1;
while (n < n_) n *= 2;
for (long long i = 0; i < 2 * n - 1; i++) dat[i] = INT_MAX;
}
void update(long long k, long long a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
long long query(long long a, long long b, long long k, long long l,
long long r) {
if (r <= a || b <= l) return INT_MAX;
if (a <= l && r <= b)
return dat[k];
else {
long long vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
long long vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
}
set<long long> st[200020];
long long p[200020], A[200020];
long long nxt[200020][30];
long long next_number[200020];
void solve() {
long long N, M, Q;
cin >> N >> M >> Q;
for (long long i = 0; i < N; i++) cin >> p[i];
for (long long i = 0; i < N; i++) {
next_number[p[i]] = p[(i + 1) % N];
}
for (long long i = 0; i < M; i++) {
cin >> A[i];
st[A[i]].insert(i);
}
for (long long i = 0; i < M; i++) {
long long num = next_number[A[i]];
auto itr = st[num].upper_bound(i);
if (itr == st[num].end()) {
nxt[i][0] = M;
} else
nxt[i][0] = *itr;
}
init(M + 1);
for (long long d = 0; d < 25; d++) {
nxt[M][d] = M;
for (long long i = 0; i < M; i++) {
long long tmp = nxt[i][d];
nxt[i][d + 1] = nxt[tmp][d];
}
}
vector<long long> res(M);
for (long long i = 0; i < M; i++) {
long long idx = i;
long long rem = N - 1;
for (long long d = 24; d >= 0; d--) {
if ((1 << d) <= rem) {
rem -= (1 << d);
idx = nxt[idx][d];
}
}
res[i] = idx;
update(i, idx);
}
string ans;
for (long long i = 0; i < Q; i++) {
long long l, r;
cin >> l >> r;
l--;
long long res = query(l, r, 0, 0, n);
if (res < r) {
ans += '1';
} else
ans += '0';
}
cout << ans << '\n';
;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
double l, x[1009], b[1009], dp[1009][1009];
int pre[1009][1009];
double check(double m, bool flag) {
memset(pre, 0, sizeof(pre));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dp[i][j] = 1e19;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i - 1; j++) {
dp[i][j] = dp[i - 1][j];
if (dp[i][i] > sqrt(fabs(x[i] - x[j] - l)) - m * b[i] + dp[i - 1][j]) {
dp[i][i] = sqrt(fabs(x[i] - x[j] - l)) - m * b[i] + dp[i - 1][j];
pre[i][i] = j;
}
}
}
return dp[n][n];
}
void output(int x) {
if (x == 0) return;
output(pre[x][x]);
printf("%d ", x);
}
int main() {
scanf("%d%lf", &n, &l);
for (int i = 1; i <= n; i++) scanf("%lf%lf", &x[i], &b[i]);
double L = 0, R = 2e9;
while (R - L > 1e-10) {
double M = (L + R) / 2;
if (check(M, 0) < 0)
R = M;
else
L = M;
}
check(L, 1);
output(n);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3,unroll-loops,no-stack-protector")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int> dis(1, 1000);
const int N = 3005;
int n, note[N];
template <class C, class F>
struct Mcmf {
static constexpr F eps = (F)1e-9;
struct Edge {
int u, v, inv;
F cap, flow;
C cost;
Edge(int u, int v, C cost, F cap, int inv)
: u(u), v(v), cost(cost), cap(cap), flow(0), inv(inv) {}
};
int second, t, tm, n, m = 0;
vector<vector<Edge> > g;
vector<Edge*> prev;
vector<C> cost;
vector<int> state;
Mcmf(int n, int ss = -1, int tt = -1)
: n(n), g(n + 5), cost(n + 5), state(n + 5), prev(n + 5) {
second = n + 1;
t = n + 2;
tm = n + 3;
}
void add(int u, int v, C cost, F cap) {
g[u].push_back(Edge(u, v, cost, cap, int(g[v].size())));
g[v].push_back(Edge(v, u, -cost, 0, int(g[u].size()) - 1));
m += 2;
}
bool bfs() {
fill(begin(state), end(state), 0);
fill(begin(cost), end(cost), numeric_limits<C>::max());
deque<int> qu;
qu.push_back(second);
state[second] = 1, cost[second] = 0;
while (int(qu.size())) {
int u = qu.front();
qu.pop_front();
state[u] = 2;
for (Edge& e : g[u])
if (e.cap - e.flow > eps)
if (cost[u] + e.cost < cost[e.v]) {
cost[e.v] = cost[u] + e.cost;
prev[e.v] = &e;
if (state[e.v] == 2 ||
(int(qu.size()) && cost[qu.front()] > cost[e.v]))
qu.push_front(e.v);
else if (state[e.v] == 0)
qu.push_back(e.v);
state[e.v] = 1;
}
}
return cost[t] != numeric_limits<C>::max();
}
pair<C, F> minCostFlow() {
C cost = 0;
F flow = 0;
while (bfs()) {
F nflow = numeric_limits<F>::max();
for (Edge* e = prev[t]; e != nullptr; e = prev[e->u])
nflow = min(nflow, e->cap - e->flow);
for (Edge* e = prev[t]; e != nullptr; e = prev[e->u]) {
e->flow += nflow;
g[e->v][e->inv].flow -= nflow;
cost += e->cost * nflow;
}
flow += nflow;
}
return make_pair(cost, flow);
}
};
int main() {
cin.tie(0)->sync_with_stdio(0), cout.tie(0);
while (cin >> n) {
Mcmf<int, int> g(2 * n + 5);
for (auto i = (1) - ((1) > (n + 1)); i != n + 1 - ((1) > (n + 1));
i += 1 - 2 * ((1) > (n + 1))) {
cin >> note[i];
g.add(g.second, i, 0, 1);
g.add(i, i + n, -1, 1);
g.add(i + n, g.tm, 0, 1);
}
for (auto i = (1) - ((1) > (n + 1)); i != n + 1 - ((1) > (n + 1));
i += 1 - 2 * ((1) > (n + 1)))
for (auto j = (i + 1) - ((i + 1) > (n + 1));
j != n + 1 - ((i + 1) > (n + 1)); j += 1 - 2 * ((i + 1) > (n + 1)))
if ((abs(note[j] - note[i]) <= 1) || (note[j] % 7 == note[i] % 7))
g.add(i + n, j, 0, 1);
g.add(g.tm, g.t, 0, 4);
auto res = g.minCostFlow();
cout << -res.first << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int od[500005], ev[500005], n1, n, m, m1, a[4 * 500005][4], last[2 * 500005],
ans, pt[2 * 500005], sz[2 * 500005];
struct node {
int w;
friend bool operator<(node x, node y) { return a[x.w][2] > a[y.w][2]; }
};
priority_queue<node> h;
vector<int> d[2 * 500005];
int lev(int k) { return (k & 1) ? k + 1 : k; }
int lod(int k) { return (k & 1) ? k : k + 1; }
int sev(int k) { return (k & 1) ? k - 1 : k; }
int sod(int k) { return (k & 1) ? k : k - 1; }
void read(int &x) {
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
}
void link(int x, int y, int l, int r) {
if (l > r) return;
a[++m1][0] = x, a[m1][1] = y, a[m1][2] = l, a[m1][3] = r;
h.push((node){m1});
}
void update(int k, int st) {
while (pt[k] < sz[k] && a[d[k][pt[k]]][2] <= last[k]) {
int q = d[k][pt[k]];
pt[k]++;
a[q][2] = max(a[q][2], st);
if (a[q][2] <= a[q][3]) h.push((node){q});
}
}
int main() {
cin >> n >> m;
if (n == 1) {
printf("0\n");
return 0;
}
for (int i = 1; i <= n; ++i) od[i] = ++n1, ev[i] = ++n1;
for (int i = 1; i <= m; ++i) {
int x, y, l, r;
read(x), read(y), read(l), read(r);
r--;
link(od[x], ev[y], lod(l), sod(r));
link(ev[x], od[y], lev(l), sev(r));
link(od[y], ev[x], lod(l), sod(r));
link(ev[y], od[x], lev(l), sev(r));
}
memset(last, 128, sizeof(last));
last[ev[1]] = 0;
while (!h.empty()) {
int w = h.top().w;
h.pop();
if (last[a[w][0]] >= a[w][2]) {
if (a[w][1] == od[n] || a[w][1] == ev[n]) {
ans = a[w][2] + 1;
printf("%d\n", ans);
return 0;
}
last[a[w][0]] = max(last[a[w][0]], a[w][3]);
last[a[w][1]] = max(last[a[w][1]], a[w][3] + 1);
update(a[w][1], a[w][2] + 1);
} else
d[a[w][0]].push_back(w), sz[a[w][0]]++;
}
printf("-1\n");
}
| 12 |
#include <bits/stdc++.h>
#pragma optimize("O2")
using namespace std;
set<pair<long long, long long>> A;
int32_t main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
long long n, q;
cin >> n >> q;
long long block = 0;
for (long long i = 0; i < q; i++) {
long long x, y;
cin >> x >> y;
if (A.find({x, y}) == A.end()) {
A.insert({x, y});
if (A.find({3 - x, y - 1}) != A.end()) {
block++;
}
if (A.find({3 - x, y}) != A.end()) {
block++;
}
if (A.find({3 - x, y + 1}) != A.end()) {
block++;
}
} else {
A.erase({x, y});
if (A.find({3 - x, y - 1}) != A.end()) {
block--;
}
if (A.find({3 - x, y}) != A.end()) {
block--;
}
if (A.find({3 - x, y + 1}) != A.end()) {
block--;
}
}
if (block == 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:36777216")
template <class T>
inline void RD(T &);
template <class T>
inline void OT(const T &);
inline long long RD() {
long long x;
RD(x);
return x;
}
template <class T>
inline T &_RD(T &x) {
RD(x);
return x;
}
inline void RC(char &c) { scanf(" %c", &c); }
inline char RC() {
char c;
RC(c);
return c;
}
inline char _RC(char &c) {
RC(c);
return c;
}
inline void RF(double &x) { scanf("%lf", &x); };
inline double RF() {
double x;
RF(x);
return x;
}
inline double _RF(double &x) {
RD(x);
return x;
}
inline void RS(char *s) { scanf("%s", s); }
inline char *_RS(char *s) {
scanf("%s", s);
return s;
}
template <class T0, class T1>
inline void RD(T0 &x0, T1 &x1) {
RD(x0), RD(x1);
}
template <class T0, class T1, class T2>
inline void RD(T0 &x0, T1 &x1, T2 &x2) {
RD(x0), RD(x1), RD(x2);
}
template <class T0, class T1, class T2, class T3>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
RD(x0), RD(x1), RD(x2), RD(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);
}
template <class T0, class T1>
inline void OT(T0 &x0, T1 &x1) {
OT(x0), OT(x1);
}
template <class T0, class T1, class T2>
inline void OT(T0 &x0, T1 &x1, T2 &x2) {
OT(x0), OT(x1), OT(x2);
}
template <class T0, class T1, class T2, class T3>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
OT(x0), OT(x1), OT(x2), OT(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);
}
inline void RF(double &a, double &b) { RF(a), RF(b); }
inline void RF(double &a, double &b, double &c) { RF(a), RF(b), RF(c); }
inline void RS(char *s1, char *s2) { RS(s1), RS(s2); }
inline void RS(char *s1, char *s2, char *s3) { RS(s1), RS(s2), RS(s3); }
template <class T>
inline void RST(T &A) {
memset(A, 0, sizeof(A));
}
template <class T0, class T1>
inline void RST(T0 &A0, T1 &A1) {
RST(A0), RST(A1);
}
template <class T0, class T1, class T2>
inline void RST(T0 &A0, T1 &A1, T2 &A2) {
RST(A0), RST(A1), RST(A2);
}
template <class T0, class T1, class T2, class T3>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
RST(A0), RST(A1), RST(A2), RST(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, less<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(T &A) {
A.clear();
}
template <class T0, class T1>
inline void CLR(T0 &A0, T1 &A1) {
CLR(A0), CLR(A1);
}
template <class T0, class T1, class T2>
inline void CLR(T0 &A0, T1 &A1, T2 &A2) {
CLR(A0), CLR(A1), CLR(A2);
}
template <class T0, class T1, class T2, class T3>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);
}
template <class T>
inline void CLR(T &A, int n) {
for (int i = 0; i < int(n); ++i) CLR(A[i]);
}
template <class T>
inline void FLC(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T0, class T1>
inline void FLC(T0 &A0, T1 &A1, int x) {
FLC(A0, x), FLC(A1, x);
}
template <class T0, class T1, class T2>
inline void FLC(T0 &A0, T1 &A1, T2 &A2) {
FLC(A0), FLC(A1), FLC(A2);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5), FLC(A6);
}
template <class T>
inline void SRT(T &A) {
sort(A.begin(), A.end());
}
template <class T, class C>
inline void SRT(T &A, C B) {
sort(A.begin(), A.end(), B);
}
int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-9;
const double OO = 1e15;
const double PI = acos(-1.0);
template <class T>
inline void checkMin(T &a, const T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMax(T &a, const T b) {
if (b > a) a = b;
}
template <class T, class C>
inline void checkMin(T &a, const T b, C c) {
if (c(b, a)) a = b;
}
template <class T, class C>
inline void checkMax(T &a, const T b, C c) {
if (c(a, b)) a = b;
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T>
inline T cub(T a) {
return a * a * a;
}
int Ceil(int x, int y) { return (x - 1) / y + 1; }
inline bool _1(int x, int i) { return x & 1 << i; }
inline bool _1(long long x, int i) { return x & 1LL << i; }
inline long long _1(int i) { return 1LL << i; }
inline long long _U(int i) { return _1(i) - 1; };
template <class T>
inline T low_bit(T x) {
return x & -x;
}
template <class T>
inline T high_bit(T x) {
T p = low_bit(x);
while (p != x) x -= p, p = low_bit(x);
return p;
}
template <class T>
inline T cover_bit(T x) {
T p = 1;
while (p < x) p <<= 1;
return p;
}
inline int count_bits(int x) {
x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1);
x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2);
x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4);
x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8);
x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16);
return x;
}
inline int count_bits(long long x) {
x = (x & 0x5555555555555555LL) + ((x & 0xaaaaaaaaaaaaaaaaLL) >> 1);
x = (x & 0x3333333333333333LL) + ((x & 0xccccccccccccccccLL) >> 2);
x = (x & 0x0f0f0f0f0f0f0f0fLL) + ((x & 0xf0f0f0f0f0f0f0f0LL) >> 4);
x = (x & 0x00ff00ff00ff00ffLL) + ((x & 0xff00ff00ff00ff00LL) >> 8);
x = (x & 0x0000ffff0000ffffLL) + ((x & 0xffff0000ffff0000LL) >> 16);
x = (x & 0x00000000ffffffffLL) + ((x & 0xffffffff00000000LL) >> 32);
return x;
}
int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
long long reverse_bits(long long x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
inline void INC(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline int sum(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline void DEC(int &a, int b) {
a -= b;
if (a < 0) a += MOD;
}
inline int dff(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline void MUL(int &a, int b) { a = (long long)a * b % MOD; }
inline int pdt(int a, int b) { return (long long)a * b % MOD; }
inline int sum(int a, int b, int c) { return sum(sum(a, b), c); }
inline int sum(int a, int b, int c, int d) { return sum(sum(a, b), sum(c, d)); }
inline int pow(int a, long long b) {
int c(1);
while (b) {
if (b & 1) MUL(c, a);
MUL(a, a), b >>= 1;
}
return c;
}
template <class T>
inline T pow(T a, long long b) {
T c(1);
while (b) {
if (b & 1) c *= a;
a *= a, b >>= 1;
}
return c;
}
inline int _I(int b) {
int a = MOD, x1 = 0, x2 = 1, q;
while (true) {
q = a / b, a %= b;
if (!a) return (x2 + MOD) % MOD;
DEC(x1, pdt(q, x2));
q = b / a, b %= a;
if (!b) return (x1 + MOD) % MOD;
DEC(x2, pdt(q, x1));
}
}
inline void DIA(int &a, int b) { MUL(a, _I(b)); }
inline int qtt(int a, int b) { return pdt(a, _I(b)); }
inline int sqr(int x) { return pdt(x, x); }
inline int rand32() {
return (bool(rand() & 1) << 30) | (rand() << 15) + rand();
}
inline int random32(int l, int r) { return rand32() % (r - l + 1) + l; }
inline int random(int l, int r) { return rand() % (r - l + 1) + l; }
int dice() { return rand() % 6; }
bool coin() { return rand() % 2; }
template <class T>
inline void RD(T &x) {
char c;
for (c = getchar(); c < '0'; c = getchar())
;
x = c - '0';
for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
}
int ____Case;
template <class T>
inline void OT(const T &x) {
printf("%d\n", x);
}
const long long MAXN = 1 << 20;
pair<int, int> f(long long x) {
if (!x) return make_pair(0, 1);
if (x & 1) {
pair<int, int> u = f(x - 1);
return make_pair(u.second, sum(u.first, u.second));
}
pair<int, int> u = f(x / 2);
return make_pair(pdt(u.first, dff(sum(u.second, u.second), u.first)),
sum(sqr(u.first), sqr(u.second)));
}
int main() {
if (_RD(MOD) == 1) {
puts("0");
return 0;
}
long long l, r, k, d = 1;
RD(l, r, k);
for (long long s = 1; s < MAXN; ++s) {
long long t = r / (s + k - 1);
if (s * t >= l) {
d = max(d, t);
break;
}
}
for (long long t = sqrt(r); t >= 1; --t) {
long long s = r / t - (k - 1);
if (s * t >= l) {
d = max(d, t);
break;
}
}
OT(f(d).first);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const int maxn = 3e5 + 111;
pair<int, int> point[maxn];
int pre[maxn], suf[maxn];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++)
scanf("%d%d", &point[i].first, &point[i].second);
sort(point + 1, point + n + 1);
pre[0] = suf[n + 1] = inf;
for (int i = 1; i <= n; i++) pre[i] = min(pre[i - 1], point[i].second);
for (int i = n; i >= 1; i--) suf[i] = min(suf[i + 1], point[i].second);
int Max = max(0, pre[n - 1] - point[n - 1].first);
for (int i = 1; i < n; i++) {
int pref = point[i - 1].first;
int pret = pre[i - 1];
int suff = point[n].first;
int suft = suf[i + 1];
Max = max(Max, min(pret, suft) - suff);
}
printf("%d\n", Max);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int maxn = 100010;
const double eps = 1e-10;
const double eps2 = 1e-16;
int mi[maxn] = {};
int vi[maxn] = {};
int n, k, h;
struct item {
int m, ind, num;
item() {}
item(int m, int ind, int num) : m(m), ind(ind), num(num) {}
bool operator<(const item &oth) const {
return m < oth.m || (m == oth.m && num < oth.num);
}
};
item a[maxn] = {};
int res[maxn] = {};
int KK;
bool can(double t) {
for (int i = 0; i < n; ++i) {
a[i].m = mi[i];
a[i].ind = i;
double ttt = vi[i] * t / h + eps2;
if (ttt > k)
a[i].num = k;
else
a[i].num = (int)(ttt);
}
sort(a, a + n);
reverse(a, a + n);
int need = k;
int lstm = INF;
KK = 0;
for (int i = 0; i < n; ++i) {
if (a[i].num < need) continue;
if (a[i].m <= lstm) {
res[KK++] = a[i].ind;
need--;
if (need == 0) return true;
lstm = a[i].m;
}
}
return false;
}
int main() {
scanf("%d%d%d", &n, &k, &h);
for (int i = 0; i < n; ++i) scanf("%d", &mi[i]);
for (int i = 0; i < n; ++i) scanf("%d", &vi[i]);
double r = 1e10;
double l = 0;
for (int it = 0; it < 100; ++it) {
double m = (l + r) / 2.0;
if (can(m))
r = m;
else
l = m;
}
can(r);
for (int i = KK - 1; i >= 0; --i) printf("%d ", res[i] + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
void debug() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
int dx[]{1, -1, 0, 0};
int dy[]{0, 0, 1, -1};
using namespace std;
int Ms[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int countDays(int year, int month, int day) {
long long s = 0;
s += (year - 1) * 365;
s += (year - 1) / 4;
s += (year - 1) / 400;
s -= (year - 1) / 100;
s += day;
for (int i = 0; i < month - 1; i++) {
s += Ms[i];
}
if (month > 2) {
if (year % 4 == 0) s++;
if (year % 100 == 0) s--;
if (year % 400 == 0) s++;
}
return s;
}
int main() {
int d1, d2, m1, m2, y1, y2;
scanf("%d:%d:%d", &y1, &m1, &d1);
scanf("%d:%d:%d", &y2, &m2, &d2);
cout << abs(countDays(y1, m1, d1) - countDays(y2, m2, d2)) << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, n, m, a[100005], b[100005];
;
int cases, tc;
cin >> tc;
for (cases = 1; cases <= tc; cases++) {
cin >> n >> m;
cout << 9 * (n - 1) + m << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
string s;
const int m_ = 2010;
long long int mm = (long long int)(1e9 + 7);
long long int dp[m_][m_];
int main() {
cin >> n >> m;
cin >> s;
for (int i = 0; i <= 2000; i++) {
for (int j = 0; j <= 2000; j++) {
dp[i][j] = 0;
}
}
dp[0][0] = 1;
for (int i = 1; i <= n - m; i++) {
for (int j = 0; j <= i; j++) {
if (j - 1 >= 0) {
dp[i][j] = dp[i - 1][j - 1];
}
if (j + 1 <= i) {
dp[i][j] += dp[i - 1][j + 1];
}
dp[i][j] %= mm;
}
}
int b = 0;
int mb = 0;
for (int i = 0; i < m; i++) {
if (s[i] == '(') {
b++;
} else {
b--;
}
mb = min(mb, b);
}
long long int ans = 0;
for (int i = 0; i <= n - m; i++) {
for (int j = 0; j <= i; j++) {
if (j + mb >= 0) {
if (j + b <= (n - m - i) && j + b >= 0) {
ans = (ans + (dp[i][j] * dp[n - m - i][j + b]) % mm) % mm;
}
}
}
}
cout << (ans % mm) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double ans[200000 + 10];
map<double, int> mp;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
double a = 0, b = 0, c = 0;
string s;
cin >> s;
int cnt = 1;
for (cnt = 1; cnt < 10; cnt++) {
if (s[cnt] == '+') break;
a *= 10;
a += s[cnt] - '0';
}
cnt++;
for (; cnt < 10; cnt++) {
if (s[cnt] == ')') break;
b *= 10;
b += s[cnt] - '0';
}
cnt += 2;
for (; cnt < s.length(); cnt++) {
c *= 10;
c += s[cnt] - '0';
}
ans[i] = 1.0 * (a + b) / c;
mp[ans[i]]++;
}
for (int i = 0; i < n; i++) {
printf("%d ", mp[ans[i]]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> jatk, jdef, catk;
int n, m;
int gao() {
if (catk.size() < jdef.size() + jatk.size()) return 0;
multiset<int> catks;
for (int i = 0; i < catk.size(); ++i) catks.insert(catk[i]);
for (int i = 0; i < jdef.size(); ++i) {
auto it = catks.upper_bound(jdef[i]);
if (it == catks.end()) return 0;
catks.erase(it);
}
int dam = 0;
for (int i = 0; i < jatk.size(); ++i) {
auto it = catks.lower_bound(jatk[i]);
if (it == catks.end()) return 0;
dam += *it - jatk[i];
catks.erase(it);
}
for (auto it = catks.begin(); it != catks.end(); ++it) dam += *it;
return dam;
}
int main() {
char type[8];
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
int x;
scanf("%s%d", type, &x);
if (type[0] == 'A')
jatk.push_back(x);
else if (type[0] == 'D')
jdef.push_back(x);
}
for (int i = 0; i < m; ++i) {
int x;
scanf("%d", &x);
catk.push_back(x);
}
sort(jatk.begin(), jatk.end());
sort(jdef.begin(), jdef.end());
sort(catk.begin(), catk.end());
int maxDam = 0;
int dp[128][128];
for (int i = 0; i < min(jatk.size(), catk.size()); ++i) {
for (int j = 0; j <= i + 1; ++j) {
for (int k = 0; k <= i + 1; ++k) {
if (k == 0 || j == 0)
dp[j][k] = 0;
else {
dp[j][k] = max(dp[j - 1][k], dp[j][k - 1]);
int ja = jatk[j - 1];
int ca = catk[catk.size() - i - 1 + k - 1];
if (ja <= ca) {
dp[j][k] = max(dp[j][k], dp[j - 1][k - 1] + ca - ja);
}
}
maxDam = max(dp[j][k], maxDam);
}
}
}
maxDam = max(maxDam, gao());
printf("%d\n", maxDam);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x, y, n, m, hh, tt, tot, q[1001000], d[1001000], ans, fa[1001000],
cnt[1001000];
int find(int x) {
if (fa[x] == x)
return x;
else {
fa[x] = find(fa[x]);
return fa[x];
}
}
void insert(int x) {
tt++;
d[tt] = x;
x = tt;
while (x > 1 && d[x] < d[x / 2]) {
int tmp = d[x];
d[x] = d[x / 2];
d[x / 2] = tmp;
x = x / 2;
}
}
void down(int x) {
while ((x * 2 <= tt && d[x * 2] < d[x]) ||
(x * 2 + 1 <= tt && d[x * 2 + 1] < d[x])) {
if (x * 2 + 1 <= tt && d[x * 2 + 1] < d[x * 2]) {
int tmp = d[x];
d[x] = d[x * 2 + 1];
d[x * 2 + 1] = tmp;
x = x * 2 + 1;
} else {
int tmp = d[x];
d[x] = d[x * 2];
d[x * 2] = tmp;
x = x * 2;
}
}
}
int main() {
cin >> n >> m >> hh;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
x = find(x);
y = find(y);
fa[x] = y;
}
for (int i = 1; i <= n; i++) {
fa[i] = find(i);
cnt[fa[i]]++;
}
for (int i = 1; i <= n; i++) {
if (cnt[i]) {
tot++;
q[tot] = cnt[i];
}
}
sort(&q[1], &q[tot + 1]);
int p = min(hh, q[tot]);
insert(q[tot]);
for (int i = tot - 1; i >= 1; i--) {
if (p) {
p--;
insert(q[i]);
p += min(q[i] - 1, hh - 1);
} else {
int oo = d[1];
ans++;
if (oo < hh) p += min(hh - oo, q[i]);
d[1] = q[i] + oo;
down(1);
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 17, maxd = 1e5 + 10;
int n, m, a[maxd], ipt[maxd];
struct SegTree {
long long sum[maxd << 2], lmax[maxd << 2], rmax[maxd << 2];
void build(int l, int r, int rt) {
if (l == r) {
sum[rt] = lmax[rt] = rmax[rt] = a[l];
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
pushUp(l, r, mid, rt);
return;
}
void pushUp(int l, int r, int m, int rt) {
sum[rt] =
sum[rt << 1] + sum[rt << 1 | 1] + rmax[rt << 1] * lmax[rt << 1 | 1];
lmax[rt] = lmax[rt << 1];
if (lmax[rt] == m - l + 1) {
lmax[rt] += lmax[rt << 1 | 1];
}
rmax[rt] = rmax[rt << 1 | 1];
if (rmax[rt] == r - m) {
rmax[rt] += rmax[rt << 1];
}
}
void update(int x, int d, int l, int r, int rt) {
if (l == r) {
sum[rt] = lmax[rt] = rmax[rt] = d;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update(x, d, l, mid, rt << 1);
else
update(x, d, mid + 1, r, rt << 1 | 1);
pushUp(l, r, mid, rt);
return;
}
} segtree[maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &ipt[i]);
}
for (int i = 0; i < maxn; ++i) {
for (int j = 1; j <= n; ++j) {
a[j] = (ipt[j] >> i) & 1;
}
segtree[i].build(1, n, 1);
}
int x, d;
long long ans = 0;
while (m--) {
ans = 0;
scanf("%d%d", &x, &d);
for (int i = 0; i < maxn; ++i) {
segtree[i].update(x, (d >> i) & 1, 1, n, 1);
ans += segtree[i].sum[1] << i;
}
printf("%I64d\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.);
const int maxn = 200100;
long long a[maxn], b[maxn];
int main() {
{
srand(time(0));
const string file = "";
if (!file.empty()) {
freopen((file + ".in").c_str(), "r", stdin);
freopen((file + ".out").c_str(), "w", stdout);
}
}
int n, k;
scanf("%d%d", &n, &k);
n++;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
b[i] = a[i];
}
for (int i = 0; i < n - 1; i++) {
a[i + 1] += a[i] / 2;
a[i] %= 2;
if (a[i] == -1) {
a[i] = 1;
a[i + 1] += -1;
}
}
if (a[n - 1] < 0) {
for (int i = 0; i < n; i++) {
b[i] = -b[i];
a[i] = b[i];
}
for (int i = 0; i < n - 1; i++) {
a[i + 1] += a[i] / 2;
a[i] %= 2;
if (a[i] == -1) {
a[i] = 1;
a[i + 1] += -1;
}
}
}
int st = 0;
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
st = i;
break;
}
}
long long cnt = 0, q = 1, qq = 0;
for (int i = st; cnt <= 2 * k && i < n; i++, q *= 2, qq++) {
if (qq > 33 && a[i] != 0) {
cnt = mod * 1ll * mod;
break;
}
cnt += q * a[i];
}
long long ans = 0;
while (((cnt) < 0 ? -(cnt) : (cnt)) <= 5ll * mod && st >= 0) {
if (cnt == b[st] && st == n - 1) {
} else
ans += (((b[st] - cnt) < 0 ? -(b[st] - cnt) : (b[st] - cnt)) <= k);
cnt *= 2;
st--;
}
printf("%lld", max(ans, ans));
return (0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const long long mod = 1000000007;
inline int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
inline int LCM(int x, int y) { return x / gcd(x, y) * y; }
void cases() {
int n, k;
cin >> n >> k;
vector<int> a, b;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x > 0) a.push_back(x);
if (x < 0) b.push_back(-x);
}
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
long long int ans = 0;
for (int i = a.size() - 1; i >= 0; i -= k) ans += 2 * a[i];
for (int i = b.size() - 1; i >= 0; i -= k) ans += 2 * b[i];
int mx = 0;
if (a.size() > 0) mx = a[a.size() - 1];
if (b.size() > 0) mx = max(b[b.size() - 1], mx);
ans -= mx;
cout << ans << "\n";
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
for (int i = 0; i < t; i++) {
cases();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int recur(int n);
int has(int n);
int main() {
int n, ans;
cin >> n;
ans = recur(n);
cout << ans + n << endl;
return 0;
}
int recur(int n) {
int a, b;
b = has(n);
if (b == 0) {
return 1;
}
a = n / b;
n /= b;
if (n != 1) a += recur(n);
return a;
}
int has(int n) {
for (int i = 2; i < n - 1; ++i)
if (n % i == 0) return i;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int meow() {
string mp[8];
for (int i = 0; i < 8; ++i) cin >> mp[i];
int dp[8][8] = {0}, n = 8;
memset(dp, -1, sizeof(dp));
for (int i = 0, _dwj = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j) {
if (mp[i][j] == 'K' and !_dwj) {
_dwj = 1;
dp[i][j] = 0;
queue<int> q;
q.push(i);
q.push(j);
while (q.size()) {
int x = q.front();
q.pop();
int y = q.front();
q.pop();
if (x > 1) {
if (y > 1 and dp[x - 2][y - 2] == -1) {
dp[x - 2][y - 2] = dp[x][y] + 1;
q.push(x - 2);
q.push(y - 2);
}
if (y < n - 2 and dp[x - 2][y + 2] == -1) {
dp[x - 2][y + 2] = dp[x][y] + 1;
q.push(x - 2);
q.push(y + 2);
}
}
if (x < n - 2) {
if (y > 1 and dp[x + 2][y - 2] == -1) {
dp[x + 2][y - 2] = dp[x][y] + 1;
q.push(x + 2);
q.push(y - 2);
}
if (y < n - 2 and dp[x + 2][y + 2] == -1) {
dp[x + 2][y + 2] = dp[x][y] + 1;
q.push(x + 2);
q.push(y + 2);
}
}
}
}
}
}
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j) {
if (mp[i][j] == 'K' and dp[i][j]) {
if (dp[i][j] == -1) return cout << "NO" << endl, 0;
if (dp[i][j] & 1) return cout << "NO" << endl, 0;
return cout << "YES" << endl, 0;
}
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
meow();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int INF = 0x3f3f3f3f;
template <class T>
inline bool RD(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1, ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void PT(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) PT(x / 10);
putchar(x % 10 + '0');
}
const int N = 2e5 + 100;
long long ans;
int mm[N], maxn[N][20], val[N][20], var[N][20];
int a[N];
int pre[N], suf[N];
void cal(int l, int r) {
if (l > r) return;
int k = mm[r - l + 1];
int id = a[maxn[l][k]] < a[maxn[r - (1 << k) + 1][k]]
? maxn[r - (1 << k) + 1][k]
: maxn[l][k];
int lb = id, ub = id;
for (int i = 19, cur = a[id]; i >= 0; i--)
if ((cur | val[lb - 1][i]) <= a[id]) {
cur |= val[lb - 1][i];
lb = max(l, lb - (1 << i));
}
for (int i = 19, cur = a[id]; i >= 0; i--)
if ((cur | var[ub + 1][i]) <= a[id]) {
cur |= var[ub + 1][i];
ub = min(r, ub + (1 << i));
}
ans +=
(id - l + 1) * 1LL * (r - id + 1) - (id - lb + 1) * 1LL * (ub - id + 1);
cal(l, id - 1);
cal(id + 1, r);
}
int main() {
mm[0] = -1;
for (int i = 1; i <= N - 1; i++)
mm[i] = (((i - 1) & i) == 0) ? mm[i - 1] + 1 : mm[i - 1];
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
val[i][0] = a[i];
for (int j = 1; j < 20; j++)
val[i][j] = val[i][j - 1] | val[max(1, i - (1 << (j - 1)))][j - 1];
}
for (int i = n; i >= 1; i--) {
var[i][0] = a[i];
for (int j = 1; j < 20; j++)
var[i][j] = var[i][j - 1] | var[min(n, i + (1 << (j - 1)))][j - 1];
}
for (int i = 1; i <= n; i++) maxn[i][0] = i;
for (int j = 1; j < 20; j++)
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
int x = maxn[i][j - 1], y = maxn[i + (1 << (j - 1))][j - 1];
maxn[i][j] = a[x] < a[y] ? y : x;
}
cal(1, n);
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x;
vector<int> v;
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> x;
if (x) v.push_back(i), ans = 1;
}
for (int i = 0; i < v.size(); i++) {
if (i != v.size() - 1) {
ans += min(2, v[i + 1] - v[i]);
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int n = 0;
int m = 0;
cin >> n;
int tmp = 0;
for (int i = 0; i < n; i++) {
cin >> tmp;
if (tmp == 0) {
m++;
}
if (m > 2) {
cout << "NO" << endl;
return 0;
}
}
if (n == 1) {
cout << ((m == 0) ? "YES" : "NO") << endl;
} else {
cout << ((m == 1) ? "YES" : "NO") << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long a[N], n, k, maxn[N][32], ai[N][32], sum[N];
long long xb[N];
void st() {
for (int i = 1; i <= n - k + 1; i++) {
maxn[i][0] = xb[i];
ai[i][0] = i;
}
for (int i = 1; (1 << i) <= n - k + 1; i++) {
for (int j = 1; j + (1 << i) - 1 <= n - k + 1; j++) {
if (maxn[j][i - 1] >= maxn[j + (1 << (i - 1))][i - 1]) {
maxn[j][i] = maxn[j][i - 1];
ai[j][i] = ai[j][i - 1];
} else {
maxn[j][i] = maxn[j + (1 << (i - 1))][i - 1];
ai[j][i] = ai[j + (1 << (i - 1))][i - 1];
}
}
}
}
inline pair<long long, long long> work(int l, int r) {
int k = log2(r - l + 1);
long long f, s;
if (maxn[l][k] >= maxn[r - (1 << k) + 1][k]) {
f = maxn[l][k];
s = ai[l][k];
} else {
f = maxn[r - (1 << k) + 1][k];
s = ai[r - (1 << k) + 1][k];
}
return {f, s};
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n - k + 1; i++) xb[i] = sum[i + k - 1] - sum[i - 1];
long long ansa, ansb, tot = -1;
st();
for (int i = 1; i <= n - 2 * k + 1; i++) {
pair<long long, long long> pp = work(i + k, n - k + 1);
if (pp.first + xb[i] > tot) {
tot = pp.first + xb[i];
ansa = i;
ansb = pp.second;
}
}
cout << ansa << " " << ansb << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e9 + 1;
struct Node;
typedef Node* pNode;
struct Node {
pNode l, r;
long long sum;
int cnt;
Node() {
l = NULL, r = NULL;
sum = cnt = 0;
}
};
pNode root = NULL;
inline void add(long long x, long long val, pNode& v = root, long long L = 0,
long long R = N) {
if (v == NULL) {
v = new Node();
}
v->cnt += val;
v->sum += val * x;
if (L + 1 == R) return;
long long M = (L + R) / 2;
if (x < M) {
add(x, val, v->l, L, M);
} else {
add(x, val, v->r, M, R);
}
}
long long get_sum(pNode v) {
if (v == NULL) {
return 0;
}
return v->sum;
}
long long get_cnt(pNode v) {
if (v == NULL) {
return 0;
}
return v->cnt;
}
inline long long sum(long long k, pNode v, int L = 0, int R = N) {
if (v == NULL || k == 0) return 0;
if (R - L == 1) {
return L * k;
}
int M = (L + R) / 2;
if (get_cnt(v->l) >= k) {
return sum(k, v->l, L, M);
}
return get_sum(v->l) + sum(k - get_cnt(v->l), v->r, M, R);
}
int main() {
ios_base::sync_with_stdio(false);
long long n, w;
cin >> n >> w;
vector<pair<pair<int, int>, int> > v;
for (long long i = 0; i < n; ++i) {
long long a, b;
cin >> a >> b;
add(a, 1);
v.push_back(make_pair(make_pair(b, a), i));
}
vector<short> anss(n, 0);
long long ans = 1e15;
sort(v.begin(), v.end());
long long sma = 0;
long long bp = 0;
for (int p = 0; p <= n; ++p) {
if (w - p <= n) {
long long cost = sum(w - p, root);
if (cost + sma < ans) {
ans = cost + sma;
bp = p;
}
}
pair<int, int> pr = v[p].first;
long long i = v[p].second;
long long a = pr.second, b = pr.first;
sma += a;
add(a, -1);
add(b - a, 1);
}
cout << ans << endl;
vector<pair<int, int> > vv;
for (int p = 0; p < bp; ++p) {
pair<int, int> pr = v[p].first;
long long i = v[p].second;
long long a = pr.second, b = pr.first;
anss[i] = 1;
vv.push_back(make_pair(b - a, i));
}
for (int p = bp; p < n; ++p) {
pair<int, int> pr = v[p].first;
long long i = v[p].second;
long long a = pr.second, b = pr.first;
vv.push_back(make_pair(a, i));
}
sort(vv.begin(), vv.end());
for (long long i = 0; i < w - bp; ++i) {
int ii = vv[i].second;
anss[ii]++;
}
for (int i = 0; i < n; ++i) cout << anss[i];
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n;
;
long long ans, k;
map<int, long long> r, r1;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
if (a % k == 0) {
ans += (r1[a / k]);
r1[a] += r[a / k];
}
r[a]++;
}
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55, P = 998244353;
int n, T, x[maxn], y[maxn], tag[maxn << 1];
vector<pair<int, int>> V[maxn << 1];
int qp(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1LL * x * x % P) {
if (y & 1) z = 1LL * z * x % P;
}
return z;
}
int main() {
scanf("%d %d", &n, &T);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x[i], &y[i]);
}
auto F = [&](int t) {
vector<int> V1, V2;
for (int i = 1; i <= n; i++) {
V1.push_back(x[i] - t), V1.push_back(x[i] + t + 1);
V2.push_back(y[i] - t), V2.push_back(y[i] + t + 1);
}
sort(V1.begin(), V1.end()), sort(V2.begin(), V2.end());
V1.resize(unique(V1.begin(), V1.end()) - V1.begin());
V2.resize(unique(V2.begin(), V2.end()) - V2.begin());
for (int i = 0; i < V1.size(); i++) {
V[i].clear();
}
for (int i = 1; i <= n; i++) {
int l = lower_bound(V1.begin(), V1.end(), x[i] - t) - V1.begin(),
r = lower_bound(V1.begin(), V1.end(), x[i] + t + 1) - V1.begin();
V[l].emplace_back(i, 1), V[r].emplace_back(i, -1);
}
memset(tag, 0, sizeof(tag));
int ans = 0;
for (int i = 0; i < V1.size() - 1; i++) {
for (auto p : V[i]) {
int l = lower_bound(V2.begin(), V2.end(), y[p.first] - t) - V2.begin(),
r = lower_bound(V2.begin(), V2.end(), y[p.first] + t + 1) -
V2.begin();
tag[l] += p.second, tag[r] -= p.second;
}
for (int j = 0, cur = 0; j < V2.size() - 1; j++) {
if (cur += tag[j])
ans = (ans + 1LL * (V1[i + 1] - V1[i]) * (V2[j + 1] - V2[j])) % P;
}
}
return ans;
};
auto lagrange = [&](int n, vector<int> V) {
int ans = 0;
for (int i = 0; i < 4; i++) {
int sum = 1;
for (int j = 0; j < 4; j++)
if (i ^ j) {
sum = 1LL * sum * (n - j + P) % P * qp(i - j + P, P - 2) % P;
}
ans = (ans + 1LL * V[i] * sum) % P;
}
return ans;
};
auto solve = [&](int l, int r) {
if (r - l <= 2) {
int ans = 0;
for (int i = l; i <= r; i++) {
(ans += F(i)) %= P;
}
return ans;
}
vector<int> V = {F(l), F(l + 1), F(l + 2), F(l + 3)};
for (int i = 1; i < 4; i++) (V[i] += V[i - 1]) %= P;
return lagrange(r - l, V);
};
int ans = 1LL * T * F(T) % P;
vector<int> tim = {0, T};
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int t = max(abs(x[i] - x[j]) + 1, abs(y[i] - y[j]) + 1) >> 1;
if (t < T) tim.push_back(t);
}
}
sort(tim.begin(), tim.end());
tim.resize(unique(tim.begin(), tim.end()) - tim.begin());
for (int i = 0; i < tim.size() - 1; i++) {
ans = (ans - solve(tim[i], tim[i + 1] - 1) + P) % P;
}
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, m;
cin >> s;
m = s;
int a[s.length()], k = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'h' || s[i] == 'e' || s[i] == 'i' || s[i] == 'd' ||
s[i] == 'i') {
m[k] = s[i];
k++;
}
}
m = m.substr(0, k);
int l = 0, i = 0;
string p = "heidi";
for (int j = 0; j < 5; j++) {
for (; i < m.length() - 1; i++) {
if (p[j] == m[i] && m[i] != m[i + 1]) {
l++;
break;
} else if (i == m.length() - 2 && (m[i] == p[j] || m[i + 1] == p[j])) {
l++;
}
}
}
if (l == 5)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct p {
int x;
int y;
int i;
};
vector<p> sp[300000], sn[400000];
int flagsp[300000], flagsn[400000];
long long int val[1000000];
int yd = 200000;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
sp[x + y].push_back({x, y, i});
sn[y - x + yd].push_back({x, y, i});
val[i] = -1;
}
int x = 0, y = 0;
long long int t = 0;
int v = 1, h = 1;
do {
int x1, y1;
int z1 = x, z2 = y;
if (v == 1 && h == 1) {
y1 = m;
x1 = y1 - y + x;
v = 1;
h = 0;
if (x1 < 0 || x1 > n) {
x1 = n;
y1 = y - x + x1;
h = 1;
v = 0;
}
for (int l = 0; l < sn[y - x + yd].size() && flagsn[y - x + yd] == 0;
l++) {
long long int ans = abs(sn[y - x + yd][l].x - x) + t;
if (val[sn[y - x + yd][l].i] == -1) val[sn[y - x + yd][l].i] = ans;
}
flagsn[y - x + yd] = 1;
x = x1;
y = y1;
} else if (v == 1 && h == 0) {
y1 = 0;
x1 = -y1 + y + x;
v = 1;
h = 1;
if (x1 > n || x1 < 0) {
x1 = n;
y1 = y + x - x1;
v = 0;
h = 0;
}
for (int l = 0; l < sp[y + x].size() && flagsp[y + x] == 0; l++) {
long long int ans = abs(sp[y + x][l].x - x) + t;
if (val[sp[y + x][l].i] == -1) val[sp[y + x][l].i] = ans;
}
flagsp[y + x] = 1;
x = x1;
y = y1;
} else if (v == 0 && h == 1) {
y1 = m;
x1 = -y1 + y + x;
v = 0;
h = 0;
if (x1 > n || x1 < 0) {
x1 = 0;
y1 = y + x - x1;
v = 1;
h = 1;
}
for (int l = 0; l < sp[y + x].size() && flagsp[y + x] == 0; l++) {
long long int ans = abs(sp[y + x][l].x - x) + t;
if (val[sp[y + x][l].i] == -1) val[sp[y + x][l].i] = ans;
}
flagsp[y + x] = 1;
x = x1;
y = y1;
} else if (v == 0 && h == 0) {
y1 = 0;
x1 = y1 - y + x;
v = 0;
h = 1;
if (x1 > n || x1 < 0) {
x1 = 0;
y1 = y - x + x1;
v = 1;
h = 0;
}
for (int l = 0; l < sn[y - x + yd].size() && flagsn[y - x + yd] == 0;
l++) {
long long int ans = abs(sn[y - x + yd][l].x - x) + t;
if (val[sn[y - x + yd][l].i] == -1) val[sn[y - x + yd][l].i] = ans;
}
flagsn[y - x + yd] = 1;
x = x1;
y = y1;
}
t += abs(x1 - z1);
} while ((x != 0 || y != 0) && (x != 0 || y != m) && (x != n || y != 0) &&
(x != n || y != m));
for (int i = 0; i < k; i++) {
cout << val[i] << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
cin >> n >> s;
int num = 0, MAX = 0;
bool f = 0, g = 0;
int ans = 0;
for (long long i = 0; i < (n); i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] -= 'A';
s[i] += 'a';
}
}
for (long long i = 0; i < (n); i++) {
if (s[i] == '(') {
f = 1;
g = 1;
MAX = max(num, MAX);
num = 0;
continue;
} else if (s[i] == ')') {
f = 0;
continue;
}
if (f) {
if (s[i] >= 'a' && s[i] <= 'z') {
if (g) {
g = 0;
ans++;
}
} else {
g = 1;
}
} else {
if (s[i] >= 'a' && s[i] <= 'z') {
num++;
} else {
MAX = max(num, MAX);
num = 0;
}
}
}
MAX = max(num, MAX);
cout << MAX << " " << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n + 1];
for (long long i = 1; i <= n; i++) cin >> a[i];
long long b[n];
for (long long i = 1; i < n; i++) b[i] = abs(a[i] - a[i + 1]);
long long mx[n + 1], mn[n + 1];
mx[n] = 0;
mn[n] = 0;
long long ans = LLONG_MIN;
for (long long i = n - 1; i >= 1; i--) {
mx[i] = b[i] - mn[i + 1];
mn[i] = b[i] - mx[i + 1];
mx[i] = max(mx[i], b[i]);
ans = max(ans, mx[i]);
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, kd;
};
vector<node> g[1010];
int n;
int cmp1(node x, node y) { return x.y < y.y; }
int cmp2(node x, node y) { return x.y > y.y; }
int main() {
node tmp;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &tmp.x, &tmp.y);
tmp.kd = i;
g[tmp.x / 1000].push_back(tmp);
}
for (int i = 0; i <= 1000; i++) {
if (i & 1) {
sort(g[i].begin(), g[i].end(), cmp1);
} else {
sort(g[i].begin(), g[i].end(), cmp2);
}
}
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j < g[i].size(); j++) {
printf("%d ", g[i][j].kd);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int bell[30][30];
int m, n = 26;
int main() {
memset(bell, 0x3f, sizeof(bell));
cin >> a >> b;
cin >> m;
for (int i = 0; i < m; i++) {
int u, v, w;
char c, d;
cin >> c >> d >> w;
u = c - 'a';
v = d - 'a';
bell[u][v] = min(bell[u][v], w);
}
for (int i = 0; i < n; i++) bell[i][i] = 0;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
bell[i][j] = min(bell[i][j], bell[i][k] + bell[k][j]);
long long cnt = 0;
int id[100005];
if (a.length() != b.length()) {
cout << -1;
return 0;
}
for (int i = 0; i < a.length(); i++) {
int u = a[i] - 'a';
int v = b[i] - 'a';
int mina = 1000000000;
for (int k = 0; k < n; k++) {
if (bell[u][k] + bell[v][k] < mina)
mina = bell[u][k] + bell[v][k], id[i] = k;
}
if (mina == 1000000000) {
cout << -1;
return 0;
}
cnt += mina;
}
cout << cnt << endl;
for (int i = 0; i < a.length(); i++) cout << char(id[i] + 'a');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, s[N];
int a[N], flag[N] = {0};
vector<int> lucky;
void init() {
queue<int> que;
que.push(4);
que.push(7);
while (!que.empty()) {
int u = que.front();
que.pop();
flag[u] = 1;
for (int i = 4; i <= 7; i += 3) {
int v = u * 10 + i;
if (v < 0 || v > 10000) continue;
que.push(v);
}
}
}
void add(int x, int val) {
for (int i = x; i <= n; i += ((i) & (-(i)))) s[i] += val;
}
int sum(int x) {
int ret = 0;
for (int i = x; i; i -= ((i) & (-(i)))) ret += s[i];
return ret;
}
int main() {
init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (flag[a[i]]) add(i, 1);
}
while (m--) {
char str[10];
int l, r, d;
scanf("%s", str);
if (str[0] == 'c') {
scanf("%d%d", &l, &r);
printf("%d\n", sum(r) - sum(l - 1));
} else {
scanf("%d%d%d", &l, &r, &d);
for (int i = l; i <= r; i++) {
if (flag[a[i]]) add(i, -1);
if (flag[a[i] + d]) add(i, 1);
a[i] += d;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int mod = 1e9 + 7;
vector<int> ff[1005];
vector<int> ss[1005];
vector<int> res1, res2;
int main() {
string s;
cin >> s;
int n = s.length();
int afterDot = 0;
int cnt = -1;
for (int i = 0; i < n; i++) {
int val = s[i] - 'a';
if (val < 26 and val >= 0) {
afterDot = 0;
int temp = s[i + 1] - 'a';
if (temp < 26 and temp >= 0) {
;
} else {
cnt++;
}
continue;
}
if (s[i] == '.') {
if (i + 3 == n)
afterDot = 1;
else {
int temp = s[i + 3] - 'a';
if (temp < 26 and temp >= 0) {
afterDot = 1;
}
}
} else {
if (afterDot)
ss[cnt].push_back(s[i] - '0');
else
ff[cnt].push_back(s[i] - '0');
}
}
long long int dollars, cents;
dollars = 0LL;
cents = 0LL;
for (int i = 0; i <= cnt; i++) {
if (ss[i].size() == 2) {
cents += ss[i][0] * 10 + ss[i][1];
}
if (1) {
int sz = ff[i].size();
int sum = 0;
for (int j = 0; j < sz; j++) {
sum = sum * 10 + ff[i][j];
}
dollars += sum;
}
}
int temp = cents;
dollars += temp / 100;
cents = cents % 100;
temp = dollars;
while (dollars) {
res1.push_back(dollars % 10);
dollars /= 10;
}
while (cents) {
res2.push_back(cents % 10);
cents /= 10;
}
int sz = res1.size();
cnt = 0;
int firstDot = sz % 3;
if (firstDot == 0) firstDot = 3;
int flag = 0;
reverse(res1.begin(), res1.end());
reverse(res2.begin(), res2.end());
int nextPos = -1;
for (int i = 0; i < sz; i++) {
cout << res1[i];
cnt++;
if (cnt == firstDot and i != sz - 1) {
cout << ".";
flag = 1;
nextPos = i + 3;
}
if (i == nextPos and i != sz - 1 and flag == 1) {
cout << ".";
nextPos = i + 3;
}
}
if (sz == 0) cout << "0";
sz = res2.size();
if (sz) cout << ".";
if (sz == 1) cout << "0";
for (int i = 0; i < sz; i++) {
cout << res2[i];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, v[101], s = 0, nr = 0, s2 = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> v[i];
s += v[i];
}
sort(v, v + n);
for (int i = n - 1; i >= 0; --i) {
s2 += v[i];
nr++;
if (s2 > s / 2) {
break;
}
}
cout << nr;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
set<long long int> s;
long long int sum = 0;
long long int ans = 0;
for (int i = 0; i < n; i++) {
long long int a;
cin >> a;
sum += a;
if (sum == 0 || s.find(sum) != s.end()) {
s.clear();
ans++;
sum = a;
}
s.insert(sum);
}
cout << ans;
}
int main() { solve(); }
| 3 |
#include <bits/stdc++.h>
#define fir first
#define sec second
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<P,P> Q;
const int inf1 = 1e9+9;
const ll inf2 = 1e16+9;
const int mod = 1e9+7;
const int maxx = 1e7+9;
const int maxn = 1e5+9;
int n,ar[maxn];
int main()
{
int T;
scanf("%d",&T);
while(T--) {
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&ar[i]);
ll mip[2]={1,2},cnt[2]={n,n};
ll sum=0,ans=1ll*cnt[0]*ar[mip[0]]+1ll*cnt[1]*ar[mip[1]];
for(int i=3;i<=n;i++) {
cnt[(i-1)&1]--;
if(ar[i]<=ar[mip[(i-1)&1]]) sum+=ar[mip[(i-1)&1]],mip[(i-1)&1]=i;
else sum+=ar[i];
ans=min(ans,sum+1ll*cnt[0]*ar[mip[0]]+1ll*cnt[1]*ar[mip[1]]);
}
printf("%lld\n",ans);
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int q, n;
int a[300005];
vector<int> dis;
vector<int> pos[300005];
int main() {
scanf("%d", &q);
while (q--) {
dis.clear();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dis.push_back(a[i]);
}
sort(dis.begin(), dis.end());
dis.erase(unique(dis.begin(), dis.end()), dis.end());
for (int i = 1; i <= n; i++)
a[i] = lower_bound(dis.begin(), dis.end(), a[i]) - dis.begin() + 1;
int sz = (int)dis.size();
for (int i = 1; i <= n; i++) pos[a[i]].push_back(i);
int ans = 1, st = 1, now = 1, cnt = 1;
while (st <= sz) {
while (now < sz && pos[now + 1][0] > pos[now].back()) {
now++;
cnt++;
}
ans = max(ans, cnt);
st = now + 1;
now = st;
cnt = 1;
}
for (int i = 1; i <= n; i++) pos[a[i]].clear();
printf("%d\n", sz - ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int mod = 1e9 + 7;
vector<int> G[1000005];
int sum[1000005 << 2], add[1000005 << 2];
void PushUp(int rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; }
void PushDown(int l, int r, int rt) {
add[rt << 1] += add[rt];
add[rt << 1 | 1] += add[rt];
int m = (l + r) >> 1;
sum[rt << 1] += (m - l + 1) * add[rt];
sum[rt << 1 | 1] += (r - m) * add[rt];
add[rt] = 0;
}
void update(int L, int R, int c, int l, int r, int rt) {
if (L <= l && r <= R) {
add[rt] += c;
sum[rt] += c * (r - l + 1);
return;
}
if (add[rt]) PushDown(l, r, rt);
int m = (l + r) >> 1;
if (L <= m) update(L, R, c, l, m, rt << 1);
if (R > m) update(L, R, c, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return sum[rt];
if (add[rt]) PushDown(l, r, rt);
int ans = 0;
int m = (l + r) >> 1;
if (L <= m) ans += query(L, R, l, m, rt << 1);
if (R > m) ans += query(L, R, m + 1, r, rt << 1 | 1);
return ans;
}
int main() {
int n, c;
scanf("%d%d", &n, &c);
for (int i = 1; i <= n; i++) {
int m;
scanf("%d", &m);
G[i].resize(m);
for (int j = 0; j < m; j++) scanf("%d", &G[i][j]);
}
bool never = 0;
for (int i = 2; i <= n; i++) {
bool ok = 0;
int m = min(G[i].size(), G[i - 1].size());
int a = 1, b = 1;
for (int j = 0; j < m; j++) {
if (G[i][j] != G[i - 1][j]) {
ok = 1;
a = G[i - 1][j];
b = G[i][j];
break;
}
}
if (!ok) {
if (G[i].size() < G[i - 1].size()) never = 1;
update(1, c, 1, 1, c, 1);
} else if (a > b) {
update(c + 2 - a, c - b + 1, 1, 1, c, 1);
} else {
update(1, c - b + 1, 1, 1, c, 1);
if (c - 1 >= c + 1 - a) update(c + 2 - a, c, 1, 1, c, 1);
}
}
int ans = -1;
for (int i = 1; i <= c; i++) {
if (query(i, i, 1, c, 1) == n - 1) {
ans = i - 1;
break;
}
}
if (never) ans = -1;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
long long MM = 1e9 + 11;
long long hp = 31;
long long hpc = 53;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
vector<tuple<int, int, int> > v;
int a[n];
for (long long i = (0); i < (n); i++) cin >> a[i];
int i1, i2, j = 0;
map<int, int> m;
for (long long i = (0); i < (n); i++) {
if (i > 0) {
m[a[i - 1]]--;
if (m[a[i - 1]] == 0) {
m.erase(a[i - 1]);
}
}
while (1) {
if (m.size() > k) {
i1 = i + 1;
i2 = j - 1;
break;
}
if (j == n) {
i1 = i + 1;
i2 = j;
break;
}
m[a[j]]++;
j++;
}
v.push_back(make_tuple(i2 - i1, i1, i2));
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
cout << get<1>(v[0]) << " " << get<2>(v[0]) << endl;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n;
int a[10000];
int x[10000];
int y[10000];
while (~scanf("%d", &n)) {
int t = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != 0) t++;
}
if (!t) {
printf("NO\n");
continue;
}
int len = 0;
for (int i = 1; i <= n; i++) {
x[len] = i;
while (a[i] == 0) i++;
t--;
if (!t) break;
y[len++] = i;
}
y[len++] = n;
printf("YES\n%d\n", len);
for (int i = 0; i < len; i++) printf("%d %d\n", x[i], y[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int n, nowv;
set<int> hash;
while (scanf("%d", &n) != EOF) {
hash.clear();
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
hash.insert(a[i]);
nowv = a[i];
if (i > 0)
for (int j = i - 1; j >= 0; j--) {
nowv |= a[j];
if (nowv == a[j]) break;
a[j] = nowv;
hash.insert(nowv);
}
}
printf("%d\n", hash.size());
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
Point(int u = 0, int v = 0) : x(u), y(v) {}
bool operator<(const Point &p) const {
if (x == p.x) return y < p.y;
return x < p.x;
}
};
bool g_f;
int g_n, g_pn;
vector<Point> vp_in;
map<int, vector<int>> mivi_x;
map<int, vector<int>> mivi_y;
map<Point, bool> mpb_mark;
queue<Point> qp;
bool input() {
cin >> g_n >> g_pn;
if (cin.eof()) return false;
vp_in.clear();
mivi_x.clear();
mivi_y.clear();
mpb_mark.clear();
while (!qp.empty()) qp.pop();
g_f = false;
Point p;
for (int i = 0; i < g_pn; ++i) {
scanf("%d%d", &p.x, &p.y);
vp_in.push_back(p);
mivi_x[p.x].push_back(p.y);
mivi_y[p.y].push_back(p.x);
if (p.x == 1 && p.y != 1) {
qp.push(p);
mpb_mark[p] = true;
}
if (p.y == g_n && p.x != g_n) {
qp.push(p);
mpb_mark[p] = true;
}
if (p.x == g_n && p.y == g_n) g_f = true;
}
return true;
}
void solve() {
if (g_f) {
puts("-1");
return;
}
for (auto &m : mivi_x) sort(m.second.begin(), m.second.end());
for (auto &m : mivi_y) sort(m.second.begin(), m.second.end());
while (!qp.empty()) {
Point p = qp.front();
qp.pop();
mpb_mark[p] = true;
if (p.x == g_n || p.y == 1) {
g_f = true;
break;
}
auto mivit_x = mivi_x.find(p.x + 1);
if (mivit_x != mivi_x.end()) {
auto &vy = mivit_x->second;
for (int i = vy.size() - 1; i >= 0; --i) {
if (vy[i] < p.y - 1) break;
auto tp = Point(p.x + 1, vy[i]);
if (!mpb_mark[tp]) {
mpb_mark[tp] = true;
qp.push(tp);
}
}
}
auto mivit_y = mivi_y.find(p.y - 1);
if (mivit_y != mivi_y.end()) {
auto &vx = mivit_y->second;
for (int i = 0; i < vx.size(); ++i) {
if (vx[i] > p.x + 1) break;
auto tp = Point(vx[i], p.y - 1);
if (!mpb_mark[tp]) {
mpb_mark[tp] = true;
qp.push(tp);
}
}
}
}
if (!g_f)
printf("%d\n", 2 * g_n - 2);
else
puts("-1");
}
int main() {
while (input()) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
struct Query {
int k, pos, id;
} q[N];
vector<pair<int, int> > v;
int n, m, a[N], res[N], bit[N];
bool cmp(pair<int, int> first, pair<int, int> second) {
if (first.first == second.first) return first.second < second.second;
return first.first > second.first;
}
bool cmp2(Query first, Query second) { return first.k < second.k; }
struct OrderSet {
struct Trie {
int cnt;
int next[2];
Trie() {
memset(next, -1, sizeof(next));
cnt = 0;
}
};
vector<Trie> trie;
OrderSet() {
auto u = Trie();
trie.push_back(u);
}
bool find(int first) {
int cur = 0;
for (int i = 20; i >= 0; i--) {
auto u = (first >> i) & 1;
if (trie[cur].next[u] == -1)
return 0;
else
cur = trie[cur].next[u];
}
return 1;
}
void insert(int first) {
int cur = 0;
trie[cur].cnt++;
for (int i = 20; i >= 0; i--) {
auto u = (first >> i) & 1;
if (trie[cur].next[u] == -1) {
auto newTrie = Trie();
trie.push_back(newTrie);
trie[cur].next[u] = trie.size() - 1;
cur = trie[cur].next[u];
} else {
cur = trie[cur].next[u];
}
trie[cur].cnt++;
}
}
void deletee(int first) {
int cur = 0;
trie[cur].cnt--;
for (int i = 20; i >= 0; i--) {
auto u = (first >> i) & 1;
int temp = trie[cur].next[u];
if (trie[temp].cnt == 1) trie[cur].next[u] = -1;
cur = temp;
trie[cur].cnt--;
}
}
int order_of_key(int first) {
int cur = 0;
int res = 0;
for (int i = 20; i >= 0; i--) {
auto u = (first >> i) & 1;
if (u == 1 && trie[cur].next[0] != -1) {
int temp = trie[cur].next[0];
res += trie[temp].cnt;
}
if (trie[cur].next[u] == -1) return res;
cur = trie[cur].next[u];
}
return res;
}
int find_by_order(int k) {
int cur = 0;
int res = 0;
if (trie[cur].cnt < k) return -1;
for (int i = 20; i >= 0; i--) {
int temp = trie[cur].next[0];
if (temp == -1) {
cur = trie[cur].next[1];
res += (1 << i);
continue;
}
if (trie[temp].cnt < k) {
k -= trie[temp].cnt;
cur = trie[cur].next[1];
res += (1 << i);
} else {
cur = trie[cur].next[0];
}
}
return res;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
OrderSet *os = new OrderSet();
cin >> n;
v.push_back({1e9 + 2, 1e9});
for (int i = 1; i <= n; i++) {
cin >> a[i];
v.push_back({a[i], i});
}
sort(v.begin(), v.end(), cmp);
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> q[i].k >> q[i].pos;
q[i].id = i;
}
sort(q + 1, q + m + 1, cmp2);
int cur = 0;
for (int i = 1; i <= m; i++) {
while (cur < q[i].k) {
cur++;
os->insert(v[cur].second);
}
res[q[i].id] = os->find_by_order(q[i].pos);
}
for (int i = 1; i <= m; i++) cout << a[res[i]] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 0;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return f ? x : -x;
}
const long long N = 2e6 + 5;
long long n, x, y, a[N], pre[N], cnt[N], maxn, ans = LLONG_MAX;
signed main() {
n = read(), x = read(), y = read();
for (long long i = 1; i <= n; i++) {
a[i] = read();
maxn = max(maxn, a[i]);
cnt[a[i]]++;
pre[a[i]] += a[i];
}
for (long long i = 2; i <= maxn * 2; i++) {
cnt[i] += cnt[i - 1];
pre[i] += pre[i - 1];
}
if (maxn == 1) return printf("%lld", n * min(x, y)) * 0;
for (long long i = 2; i <= maxn; i++) {
long long s = 0;
for (long long j = i; j <= maxn + i; j += i) {
long long l = j - i + 1, r = j;
long long t = r - ceil(x * 1.0 / y);
if (t >= l)
s += x * (cnt[t] - cnt[l - 1]);
else
t = l - 1;
s += y * ((cnt[r] - cnt[t]) * r - (pre[r] - pre[t]));
}
ans = min(ans, s);
}
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double Pi = 3.14159265, eps = 1e-6;
const int oo = 1e9, Mod = 1e9 + 7;
const long long ool = 1e18;
int const N = 2e5 + 10;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int m, n;
cin >> m >> n;
int ste[n];
for (int i = 0; i < n; i++) {
cout << 1 << endl;
int y;
cin >> y;
if (!y) return 0;
ste[i] = y;
}
int low = 1, hig = m + 1;
int j = -1;
while (hig > low + 1) {
int mid = (hig + low) / 2;
cout << mid << endl;
int y;
cin >> y;
if (!y) return 0;
j++;
j %= n;
y *= ste[j];
if (y == 1) {
low = mid;
continue;
}
hig = mid;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[200005];
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; i++) {
s[i + len] = s[i];
}
int l = 0, r = 1, ans = 0;
while (l < len * 2 && r < len * 2) {
while (r < len * 2 && r - l < len && s[r] != s[r - 1]) ++r;
ans = max(r - l, ans);
l = r;
r = l + 1;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int64_t NMAX = 300005;
const int64_t INF = ~(1LL << 63);
int64_t n, t, ans;
int64_t height[NMAX], cost[NMAX], dp[NMAX][3];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
height[0] = -3;
while (t--) {
cin >> n;
for (int64_t i = 1; i <= n; i++) {
dp[i][0] = dp[i][1] = dp[i][2] = INF;
}
for (int64_t i = 1; i <= n; i++) {
cin >> height[i] >> cost[i];
for (int64_t j = 0; j < 3; j++)
for (int64_t k = 0; k < 3; k++)
if (height[i] + j != height[i - 1] + k)
dp[i][j] = min(dp[i][j], dp[i - 1][k] + cost[i] * j);
}
cout << min(dp[n][0], min(dp[n][1], dp[n][2])) << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, maxn = 5e5 + 5;
int n, m;
char s[maxn];
vector<pair<int, int> > g[maxn], qu[maxn];
vector<int> f[maxn];
int tr[maxn][27], tot = 0, in[maxn], out[maxn], dfs_clock;
int ans[maxn], fail[maxn];
int sum[maxn];
void add(int x, int v) {
while (x <= dfs_clock) {
sum[x] += v;
x += (x & (-x));
}
}
int query(int x) {
int r = 0;
while (x) {
r += sum[x];
x -= (x & (-x));
}
return r;
}
int add() {
int now = 0, len = strlen(s);
for (int i = 0; i < len; i++) {
if (!tr[now][s[i] - 'a']) tr[now][s[i] - 'a'] = ++tot;
now = tr[now][s[i] - 'a'];
}
return now;
}
void build() {
queue<int> Q;
for (int i = 0; i <= 25; i++)
if (tr[0][i]) Q.push(tr[0][i]);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i <= 25; i++) {
if (tr[u][i]) {
fail[tr[u][i]] = tr[fail[u]][i];
Q.push(tr[u][i]);
} else
tr[u][i] = tr[fail[u]][i];
}
}
for (int i = 1; i <= tot; i++) f[fail[i]].push_back(i);
}
void dfs(int u) {
in[u] = ++dfs_clock;
for (int i = 0; i < f[u].size(); i++) dfs(f[u][i]);
out[u] = dfs_clock;
}
void dfs1(int u, int now) {
add(in[u], 1);
for (int i = 0; i < qu[now].size(); i++) {
pair<int, int> v = qu[now][i];
ans[v.second] = query(out[v.first]) - query(in[v.first] - 1);
}
for (int i = 0; i < g[now].size(); i++) {
pair<int, int> v = g[now][i];
dfs1(tr[u][v.first], v.second);
}
add(in[u], -1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int op;
scanf("%d", &op);
int p = 0;
if (op == 2) scanf("%d", &p);
scanf("%s", s);
g[p].push_back(make_pair(s[0] - 'a', i));
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int p;
scanf("%d%s", &p, s);
qu[p].push_back(make_pair(add(), i));
}
build();
dfs(0);
dfs1(0, 0);
for (int i = 1; i <= m; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long a[N], b[N];
int n, k;
vector<long long> tmp;
bool judge(long long x) {
tmp.clear();
for (int i = 0; i < n; i++) {
for (long long j = a[i] / b[i], rest = a[i] % b[i]; j < k - 1;) {
tmp.push_back(j);
if (tmp.size() >= k) return 0;
j += (rest + x) / b[i];
rest = (rest + x) % b[i];
}
}
sort(tmp.begin(), tmp.end());
for (int i = 0; i < tmp.size(); i++) {
if (tmp[i] < i) return 0;
}
return 1;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%lld", &b[i]);
}
long long l = 0, r = 1e18;
while (l < r) {
long long mid = (l + r) >> 1;
if (judge(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
printf("%lld\n", l == 1e18 ? -1 : l);
return 0;
}
| 7 |
#include <cstdio>
#include <algorithm>
using namespace std;
int s[56];
int n;
long long sum,now1,now2;
int main()
{
// freopen("in.txt","r",stdin);
int time;
scanf("%d",&time);
while(time--)
{
scanf("%d",&n);
sum=0;
for(int i=1;i<=n;i++)
scanf("%d",&s[i]),sum+=s[i];
now1=now2=0;
for(int i=1;i<=n;i++)
{
if(i&1) now1+=s[i]-1;
else now2+=s[i]-1;
}
if((now1<<1)<=sum)
{
for(int i=1;i<=n;i++)
if(i&1) printf("1 ");
else printf("%d ",s[i]);
}
else if((now2<<1)<=sum)
{
for(int i=1;i<=n;i++)
if(!(i&1)) printf("1 ");
else printf("%d ",s[i]);
}
printf("\n");
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 300001;
int arr[SIZE], n, i, x, maxValue, oldSize;
set<int> st;
int main() {
cin >> n;
for (i = 1; i <= 2 * n; i++) {
cin >> x;
oldSize = st.size();
st.insert(x);
if (oldSize == st.size()) {
st.erase(x);
} else {
if (st.size() > maxValue) maxValue = st.size();
}
}
cout << maxValue;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x, a[10050], al;
double f[105][10050];
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), al += a[i];
f[n][al] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j < n; ++j)
for (int k = 0; k <= al - a[i]; ++k)
f[j][k] += f[j + 1][k + a[i]] / (j + 1) * (n - j);
double ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= al; ++j)
ans += f[i][j] * min((1.0 * n / i + 1) * x * 0.5, 1.0 * j / i);
printf("%.10lf\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200100, TOUR = 1 << 18;
;
struct tour {
int val, sz, poc, kraj;
} t[2 * TOUR];
int polje[MAX];
int subtree[MAX], hlroot[MAX], poz[MAX], par[MAX], wpar[MAX], dub[MAX];
int vr = 0;
pair<int, int> edge[MAX];
pair<int, int> q[MAX];
int qa[MAX], qb[MAX], rje[MAX];
vector<pair<int, int> > V[MAX];
tour Merge(tour a, tour b) {
tour ret = {a.val + b.val, a.sz + b.sz, a.poc, b.kraj};
if (a.poc == a.sz) ret.poc += b.poc;
if (b.kraj == b.sz) ret.kraj += a.kraj;
if (a.poc < a.sz && b.kraj < b.sz) ret.val += polje[a.kraj + b.poc];
return ret;
}
void InitTour() {
for (int i = 2 * TOUR - 1; i; i--) {
if (i >= TOUR)
t[i] = {0, 1, 0, 0};
else
t[i] = Merge(t[2 * i], t[2 * i + 1]);
}
}
void Stavi(int pos) {
t[pos + TOUR] = {0, 1, 1, 1};
for (pos = (pos + TOUR) / 2; pos; pos /= 2)
t[pos] = Merge(t[2 * pos], t[2 * pos + 1]);
}
tour Vrati(int pos, int lo, int hi, int begin, int end) {
if (lo >= end || hi <= begin) return {0, 0, 0, 0};
if (lo >= begin && hi <= end) return t[pos];
return Merge(Vrati(2 * pos + 0, lo, (lo + hi) / 2, begin, end),
Vrati(2 * pos + 1, (lo + hi) / 2, hi, begin, end));
}
int Rek1(int node, int prosli) {
int ret = 1;
for (int i = 0; i < (int)V[node].size(); i++)
if (V[node][i].first != prosli) ret += Rek1(V[node][i].first, node);
return subtree[node] = ret;
}
void Rek2(int node, int prosli, int kor) {
if (kor == -1) kor = node;
if (prosli != -1) dub[node] = dub[prosli] + 1;
par[node] = prosli;
poz[node] = vr++;
hlroot[node] = kor;
int maxx = -1, ind = -1;
for (int i = 0; i < (int)V[node].size(); i++) {
int nn = V[node][i].first;
if (nn != prosli && subtree[nn] > maxx) {
maxx = subtree[nn];
ind = nn;
}
if (nn == prosli) wpar[node] = V[node][i].second;
}
if (ind != -1) Rek2(ind, node, kor);
for (int i = 0; i < (int)V[node].size(); i++) {
int nn = V[node][i].first;
if (nn != ind && nn != prosli) Rek2(nn, node, -1);
}
}
void HLD() {
Rek1(0, -1);
Rek2(0, -1, -1);
}
int Lca(int a, int b, int gran) {
tour ta = {0, 0, 0, 0}, tb = {0, 0, 0, 0};
for (;;) {
if (hlroot[a] == hlroot[b]) {
if (dub[a] > dub[b]) {
swap(a, b);
swap(ta, tb);
}
tb = Merge(Vrati(1, 0, TOUR, poz[a] + 1, poz[b] + 1), tb);
swap(ta.poc, ta.kraj);
ta = Merge(ta, tb);
break;
}
if (dub[hlroot[a]] > dub[hlroot[b]]) {
swap(a, b);
swap(ta, tb);
}
tb = Merge(Vrati(1, 0, TOUR, poz[hlroot[b]] + 1, poz[b] + 1), tb);
if (wpar[hlroot[b]] >= gran)
tb = Merge({0, 1, 1, 1}, tb);
else
tb = Merge({0, 1, 0, 0}, tb);
b = par[hlroot[b]];
}
int ret = ta.val;
ret += polje[ta.poc];
if (ta.poc != ta.sz) ret += polje[ta.kraj];
return ret;
}
int main() {
int n, brq;
scanf("%d%d", &n, &brq);
for (int i = 1; i < n; i++) scanf("%d", &polje[i]);
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
V[a].push_back(pair<int, int>(b, c));
V[b].push_back(pair<int, int>(a, c));
}
HLD();
for (int i = 0; i < brq; i++) {
int l;
scanf("%d%d%d", &qa[i], &qb[i], &l);
qa[i]--;
qb[i]--;
q[i] = pair<int, int>(l, i);
}
for (int i = 1; i < n; i++) edge[i - 1] = pair<int, int>(wpar[i], i);
sort(q, q + brq, greater<pair<int, int> >());
sort(edge, edge + n - 1, greater<pair<int, int> >());
InitTour();
for (int i = 0, j = 0; i < brq; i++) {
for (; j < n - 1 && edge[j].first >= q[i].first; j++)
Stavi(poz[edge[j].second]);
rje[q[i].second] = Lca(qa[q[i].second], qb[q[i].second], q[i].first);
}
for (int i = 0; i < brq; i++) printf("%d\n", rje[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool prime[100000];
int64_t gcd(int64_t a, int64_t b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void SieveOfEratosthenes() {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= 100000; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= 100000; i += p) prime[i] = false;
}
}
}
long long binpow(long long a, long long b) {
a %= 1000000007;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res % 1000000007;
}
int64_t invmd(int64_t n) { return (binpow(n, 1000000007 - 2)); }
int solve() {
int x, y;
cin >> x >> y;
if (x == 1 && y > 1) {
cout << "NO" << endl;
return 0;
}
if (x == y || (x > 1 && x > y)) {
cout << "YES" << endl;
return 0;
}
if (x == 2 && y > 3) {
cout << "NO" << endl;
return 0;
}
if (x == 2 && y == 3) {
cout << "YES" << endl;
return 0;
}
if (x % 2 == 0 && x > 2) {
cout << "YES" << endl;
return 0;
}
if (x % 2 == 1 && x != 3) {
cout << "YES" << endl;
return 0;
}
if (x % 2 == 1 && x == 3) {
cout << "NO" << endl;
return 0;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 35;
const int MAXL = 1e5 + 5;
const int BASE = 3137;
const int MOD = 1e9 + 7;
struct node {
int id, pos, type;
bool operator!=(const node &rhs) const {
return id != rhs.id || pos != rhs.pos || type != rhs.type;
}
};
int N;
int len[MAXN];
char s[MAXN][MAXL];
int pref[MAXN][MAXL];
int who[MAXN][MAXL];
int pot[MAXL];
vector<node> E[MAXN][MAXL][2];
int disc[MAXN][MAXL][2], low[MAXN][MAXL][2];
bool on[MAXN][MAXL][2];
stack<node> S;
int timer;
void load() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%s", s[i] + 1);
}
inline int add(int x, int y) {
x += y;
if (x >= MOD)
x -= MOD;
else if (x < 0)
x += MOD;
return x;
}
inline int mul(int x, int y) { return (long long)x * y % MOD; }
int get(int x, int lo, int hi) {
return add(pref[x][hi], -mul(pref[x][lo - 1], pot[hi - lo + 1]));
}
bool tarjan(node x) {
int &ref = low[x.id][x.pos][x.type];
ref = disc[x.id][x.pos][x.type] = timer++;
on[x.id][x.pos][x.type] = true;
S.push(x);
for (auto it : E[x.id][x.pos][x.type])
if (!disc[it.id][it.pos][it.type]) {
if (!tarjan(it)) return false;
ref = min(ref, low[it.id][it.pos][it.type]);
} else if (on[it.id][it.pos][it.type])
ref = min(ref, disc[it.id][it.pos][it.type]);
if (ref != disc[x.id][x.pos][x.type]) return true;
vector<node> tmp;
for (node curr = {-1, -1, -1}; !S.empty() && curr != x; S.pop()) {
curr = S.top();
tmp.push_back(curr);
on[curr.id][curr.pos][curr.type] = false;
}
if (tmp.size() == 1) return true;
for (auto it : tmp)
if (it.pos > 1 && !it.type) return false;
return true;
}
void add_edges(int x, int y, int lo, int hi) {
for (int i = 0; i < 2; i++) {
E[x][y][i].clear();
disc[x][y][i] = 0;
on[x][y][i] = false;
}
int l = len[x] - y + 1;
for (int i = lo; i <= hi; i++)
if (len[i] <= l) {
if (pref[i][len[i]] == get(x, y, y + len[i] - 1))
for (int j = 0; j < 2; j++)
if (len[i] == l)
E[x][y][j].push_back({0, 0, 0});
else
E[x][y][j].push_back({x, y + len[i], j});
} else {
if (get(x, y, len[x]) == pref[i][l])
for (int j = 0; j < 2; j++) E[x][y][j].push_back({i, l + 1, j ^ 1});
}
}
bool check(int lo, int hi) {
E[0][0][0].clear();
for (int i = lo; i <= hi; i++) E[0][0][0].push_back({i, 1, 0});
for (int i = lo; i <= hi; i++)
for (int j = 1; j <= len[i]; j++) add_edges(i, j, lo, hi);
timer = 1;
S = stack<node>();
for (int i = lo; i <= hi; i++)
for (int j = 1; j <= len[i]; j++)
for (int k = 0; k < 2; k++)
if (!disc[i][j][k] && !tarjan({i, j, k})) return false;
return true;
}
int solve() {
pot[0] = 1;
for (int i = 1; i < MAXL; i++) pot[i] = mul(pot[i - 1], BASE);
for (int i = 0; i < N; i++) {
len[i] = strlen(s[i] + 1);
for (int j = 1; j <= len[i]; j++)
pref[i][j] = add(mul(pref[i][j - 1], BASE), s[i][j]);
}
int sol = 0;
for (int i = 0; i < N; i++) {
int lo = i, hi = N;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (check(i, mid))
lo = mid + 1;
else
hi = mid;
}
sol += lo - i;
}
return sol;
}
int main() {
load();
printf("%d\n", solve());
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000, K = 21;
int suff[K][N];
void count_sort(pair<pair<int, int>, int> *p, int n) {
static pair<pair<int, int>, int> bucket[N];
static int cnt[N], lst[N];
for (int i = 0; i <= n; i++) {
cnt[i] = 0;
}
for (int i = 0; i < n; i++) {
cnt[p[i].first.second + 1]++;
}
for (int i = 1; i <= n; i++) {
cnt[i] += cnt[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
lst[p[i].first.first] = i;
bucket[--cnt[p[i].first.second + 1]] = p[i];
}
for (int i = 0; i < n; i++) {
p[lst[bucket[i].first.first]++] = bucket[i];
}
}
void suff_arr(const string &str) {
static pair<pair<int, int>, int> p[N];
int n = str.size();
for (int i = 0; i < n; i++) {
p[i] = make_pair(make_pair(int(str[i]) + 255, -1), i);
}
sort(p, p + n);
int c = 0;
for (int i = 0; i < n; i++) {
if (i && p[i].first != p[i - 1].first) c++;
suff[0][p[i].second] = c;
}
for (int j = 1; j < K; j++) {
for (int i = 0; i < n; i++) {
p[i].first.first = suff[j - 1][p[i].second];
if (p[i].second + (1 << (j - 1)) < n)
p[i].first.second = suff[j - 1][p[i].second + (1 << (j - 1))];
else
p[i].first.second = -1;
}
count_sort(p, n);
int c = 0;
for (int i = 0; i < n; i++) {
if (i && p[i].first != p[i - 1].first) c++;
suff[j][p[i].second] = c;
}
}
}
int lcp(int i, int j, int n) {
if (i > j) swap(i, j);
int ans = 0;
for (int h = K - 1; h >= 0; h--) {
if (j + (1 << h) > n) continue;
if (suff[h][i] != suff[h][j]) continue;
i += 1 << h;
j += 1 << h;
ans += 1 << h;
}
return ans;
}
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return make_pair(a.first, a.second + b.second);
return min(a, b);
}
int p[N], d[N];
pair<int, int> mn[K][N];
void build(int n) {
for (int i = 0; i < n; i++) {
mn[0][i] = make_pair(d[i], 1);
}
for (int j = 1; j < K; j++) {
for (int i = 0; i < n; i++) {
if (i + (1 << (j - 1)) >= n) {
mn[j][i] = mn[j - 1][i];
} else {
mn[j][i] = merge(mn[j - 1][i], mn[j - 1][i + (1 << (j - 1))]);
}
}
}
}
pair<int, int> get(int l, int r, int x) {
pair<int, int> ans = {int(1e9), 0};
for (int j = K - 1; j >= 0; j--) {
if (l + (1 << j) - 1 > r) continue;
if (merge(ans, mn[j][l]).first < x) continue;
ans = merge(ans, mn[j][l]);
l += 1 << j;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
string str;
cin >> str;
suff_arr(str);
for (int i = 0; i < n; i++) {
p[suff[20][i]] = i;
}
vector<pair<pair<int, int>, int>> q;
for (int i = 0; i < n; i++) {
q.push_back(make_pair(make_pair(p[i], n - 1), +1));
if (!i) continue;
int x = lcp(p[i], p[i - 1], n);
if (x > 0) {
q.push_back(make_pair(make_pair(p[i], p[i] + x - 1), -1));
}
}
for (int i = 0; i < n; i++) {
d[i] = (i ? d[i - 1] : 0) + (str[i] == '(' ? +1 : -1);
}
build(n);
long long ans = 0;
for (int i = 0; i < q.size(); i++) {
int l = q[i].first.first;
int r = q[i].first.second;
pair<int, int> query;
int x = 0;
if (q[i].first.first - 1 >= 0) x = d[q[i].first.first - 1];
query = get(l, r, x);
if (query.first != x) continue;
ans += 1LL * query.second * q[i].second;
}
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double s;
cin >> s;
double a, b, c;
cin >> a >> b >> c;
if (a == 0 && b == 0 && c == 0)
printf("0 0 %.08lf", s);
else {
printf("%.15lf %.15lf %.15lf", s / (a + b + c) * a, s / (a + b + c) * b,
s / (a + b + c) * c);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; ++i) cin >> arr[i];
stack<pair<int, int> > s;
int ans = 0;
s.push(make_pair(arr[n - 1], 0));
for (int i = n - 2; i >= 0; i--) {
if (s.top().first > arr[i])
s.push(make_pair(arr[i], 0));
else {
int res = 0;
while (!s.empty() and s.top().first < arr[i]) {
res = max(res + 1, s.top().second);
s.pop();
}
s.push(make_pair(arr[i], res));
}
}
while (!s.empty()) {
ans = max(ans, s.top().second);
s.pop();
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
priority_queue<int, vector<int>, greater<int> > q;
string s;
vector<pair<int, int> > ans;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s;
if (s == "insert") {
cin >> x;
q.push(x);
ans.push_back({1, x});
} else if (s == "getMin") {
cin >> x;
while (!q.empty() && (q.top() < x)) {
q.pop();
ans.push_back({3, -1});
}
if (q.empty() || (q.top() != x)) {
q.push(x);
ans.push_back({1, x});
}
ans.push_back({2, x});
} else {
if (q.empty()) {
ans.push_back({1, 0});
ans.push_back({3, -1});
} else {
q.pop();
ans.push_back({3, -1});
}
}
}
cout << ans.size() << '\n';
for (pair<int, int> it : ans) {
if (it.first == 1)
cout << "insert " << it.second << '\n';
else if (it.first == 2)
cout << "getMin " << it.second << '\n';
else
cout << "removeMin\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<ii> vii;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define fr(be, en) for(int i = be; i <= en; i++)
ll mod = LLONG_MAX;
ll power(ll a, ll b)
{
if(b == 0) return 1;
ll ans = power(a, b/2);
ans = (ans*ans)%mod;
if(b%2) ans*=a;
return ans%mod;
}
ll mul(ll a,ll n, ll mod)
{
ll ret;
if(n==0) return 0;
ret = mul(a,n/2, mod);
ret = (ret+ret)%mod;
if(n%2) ret=(ret+a)%mod;
return ret;
}
int main()
{
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
ll t, n;
cin >> t;
while(t--){
cin >> n;
ll ans = INT_MAX;
for(ll i = 1; i <= 1e4; i++){
ll curr = (i*(i + 1))/2;
if(curr == n){
ans = i;
break;
}
if(curr <= (n + 1)) continue;
else{
ans = i;
break;
}
}
cout << ans << "\n";
}
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
int tram[n][2];
for (int x = 0; x < n; x++) {
cin >> tram[x][0] >> tram[x][1];
}
int ans = 0;
int cap = 0;
for (int x = 0; x < n; x++) {
cap = cap + tram[x][1] - tram[x][0];
if (cap >= ans) {
ans = cap;
}
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string a = "STRIKE";
string h = "HEAL";
vector<string> ans;
int main() {
int h1, a1, c1, h2, a2;
cin >> h1 >> a1 >> c1 >> h2 >> a2;
while (h2 > 0) {
if (h1 <= a2) {
if (h2 <= a1) {
ans.push_back(a);
break;
}
h1 += c1 - a2;
ans.push_back(h);
} else {
h2 -= a1;
h1 -= a2;
ans.push_back(a);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
vector<int> go[maxn], lis;
bool vis[maxn];
int fa[maxn], siz[maxn], mx[maxn], n, cn, lef, root;
void dfs(int now, int pre) {
if (now > cn) lis.push_back(now);
siz[now] = (now <= cn);
mx[now] = 0;
for (auto p : go[now])
if (p != pre && !vis[p])
dfs(p, now), siz[now] += siz[p], mx[now] = max(mx[now], siz[p]);
}
int get_leaf(int now) {
if (now <= cn) return now;
return get_leaf(go[now][0] == fa[now] ? go[now][1] : go[now][0]);
}
int query(int x, int y, int z) {
cout << x << " " << y << " " << z << endl;
fflush(stdout);
string s;
cin >> s;
if (s == "X") return 0;
if (s == "Y") return 1;
return 2;
}
void push(int now) {
lis.clear();
dfs(now, 0);
int cen = 0;
for (auto p : lis)
if (siz[p] * 2 >= siz[now] && mx[p] * 2 <= siz[now]) cen = p;
if (!cen) cen = now;
vector<int> ch, leaf;
ch.clear(), leaf.clear();
for (auto p : go[cen])
if (p != fa[cen]) ch.push_back(p), leaf.push_back(get_leaf(p));
if (ch.size() < 2) {
fa[++n] = fa[cen];
fa[cen] = fa[lef] = n;
return;
}
int bel = query(leaf[0], lef, leaf[1]);
vis[cen] = 1;
if (bel == 2) {
if (fa[cen] != -1 && !vis[fa[cen]])
push(fa[cen]);
else {
fa[++n] = fa[cen];
fa[cen] = fa[lef] = n;
}
} else {
if (vis[ch[bel]]) {
fa[++n] = cen;
fa[ch[bel]] = fa[lef] = n;
} else
push(ch[bel]);
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
fa[1] = -1;
cn = n;
for (lef = 2; lef <= cn; lef++) {
for (int i = 1; i <= n; i++) vis[i] = 0, go[i].clear();
for (int i = 1; i < lef; i++)
if (fa[i] == -1)
root = i;
else
go[fa[i]].push_back(i), go[i].push_back(fa[i]);
for (int i = cn + 1; i <= n; i++)
if (fa[i] == -1)
root = i;
else
go[fa[i]].push_back(i), go[i].push_back(fa[i]);
push(root);
}
cout << "-1" << endl;
for (int i = 1; i <= n; i++) cout << fa[i] << " ";
cout << endl;
fflush(stdout);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
string s;
int main() {
long long n, x, y, ans = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> x >> y;
ans = max(x + y, ans);
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = 3.14159265358979323846;
const int nn = 100001;
int main() {
int n, m;
int st[nn];
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &st[i]);
scanf("%d", &m);
long long h1 = st[0];
for (int i = 0; i < m; ++i) {
int w, h;
scanf("%d %d", &w, &h);
long long lm = h1;
if (lm < st[w - 1]) lm = st[w - 1];
printf("%I64d\n", lm);
h1 = lm + h;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000000 + 7;
const double eps = 1e-9;
const int inf = 0x3f3f3f3f;
const long long infl = 10000000000000000;
const int maxn = 1000 + 10;
const int maxm = 1000 + 10;
int in(int &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return -1;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
int a[maxn];
int n;
int ask() {
printf("? ");
for (int i = 1; i <= n; ++i) printf("%d", a[i]);
puts("");
fflush(stdout);
int x;
scanf("%d", &x);
return x;
}
int main() {
scanf("%d", &n);
int ori = ask();
a[1] = 1;
int d1 = ask();
int pos1 = 0, pos0 = 0;
if (d1 < ori)
pos1 = 1;
else
pos0 = 1;
int l = 2, r = n;
while (l < r) {
int mid = (l + r) >> 1;
for (int i = 1; i <= n; ++i) a[i] = (i <= mid);
int d2 = ask();
bool ok = 0;
ok |= (pos0 == 1 && d2 < d1 + (mid - 1));
ok |= (pos1 == 1 && d2 > d1 - (mid - 1));
if (ok)
r = mid;
else
l = mid + 1;
}
if (pos1)
pos0 = l;
else
pos1 = l;
printf("! %d %d", pos0, pos1);
fflush(stdout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool valid = false;
for (int i = 0; i < s.length() && !valid; i++) {
if (s[i] == 'H' || s[i] == 'Q' || s[i] == '9') {
valid = true;
}
}
if (valid) {
cout << "YES";
} else {
cout << "NO";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const long long MAXN = 9e18 + 10;
const int MAX = 1e2 + 10;
const long long mod = 1e9 + 7;
map<string, vector<int> > m;
string numphone[N], name[N];
int compare(string a, string b) {
int n = a.length(), len = b.length();
int i = n, j = len;
bool flag = true;
while (i >= 0 && j >= 0) {
if (a[i] != b[j]) {
flag = false;
break;
}
i--;
j--;
}
if (flag) return 1;
return 0;
}
void solve() {
m.clear();
int n, cnt = 1;
scanf("%d", &n);
for (int j = 0; j < n; ++j) {
string phone;
int num;
cin >> name[j] >> num;
while (num--) {
cin >> phone;
bool flag = true;
if (m[name[j]].size() != 0) {
for (int i = 0; i < m[name[j]].size(); ++i) {
if (compare(numphone[m[name[j]][i]], phone) != 0) {
flag = false;
if (phone.length() > numphone[m[name[j]][i]].length())
numphone[m[name[j]][i]] = phone;
break;
}
}
}
if (flag) {
m[name[j]].push_back(cnt);
numphone[cnt++] = phone;
}
}
}
cout << m.size() << endl;
for (int j = 0; j < n; ++j) {
if (m[name[j]].size() != 0) {
cout << name[j] << ' ' << m[name[j]].size() << ' ';
for (int i = 0; i < m[name[j]].size() - 1; ++i) {
cout << numphone[m[name[j]][i]] << ' ';
}
cout << numphone[m[name[j]][m[name[j]].size() - 1]] << endl;
m[name[j]].clear();
}
}
return;
}
int main() {
int casen = 1;
while (casen--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[100005];
int a[100005];
bool visited[100005];
map<int, int> mp;
int cnt;
void dfs(int i) {
visited[i] = 1;
vec[cnt].push_back(i + 1);
if (!visited[mp[a[i]]]) dfs(mp[a[i]]);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp.insert({a[i], 0});
}
int x = 0;
for (auto i : mp) {
mp[i.first] = x++;
}
cnt = 0;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
dfs(i);
cnt++;
}
}
cout << cnt << endl;
for (int i = 0; i < cnt; i++) {
cout << vec[i].size() << " ";
sort(vec[i].begin(), vec[i].end());
for (auto j : vec[i]) cout << j << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int n, m, a[110000];
float x;
static char buf[1000000], *p1 = buf, *p2 = buf;
inline char gc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? -1
: *p1++;
}
inline int read() {
register int x = 0;
register char a = gc();
while (a < '0' || a > '9') a = gc();
while (a >= '0' && a <= '9') x = (x << 1) + (x << 3) + (a ^ 48), a = gc();
return x;
}
int main() {
n = read();
m = read();
for (register int i = 1; i <= n; i++) a[i] = read();
while (m--) {
register int opt, l, r, ans = 0;
opt = read();
l = read();
r = read();
x = read();
if (opt & 1)
for (register int i = l; i <= r; i++) a[i] -= (a[i] > x) ? x : 0;
else {
for (register int i = l; i <= r; i++) ans += !(a[i] - x);
printf("%d\n", ans);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int N, i, j, L, R, A[100000], B[100000];
long long K, M, H;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> K >> M;
for (i = 0; i < N; i++) {
cin >> A[L];
if (L > 0 && A[L] == A[L - 1]) {
B[L] = B[L - 1] + 1;
if (B[L] == K) {
L -= K;
}
} else {
B[L] = 1;
}
L++;
}
N = L;
L = 0;
R = N - 1;
while (A[L] == A[R]) {
for (i = L; i < R && A[i] == A[L]; i++) {
}
for (j = R; j > L && A[j] == A[R]; j--) {
}
if (i == R) {
if ((M * (R - L + 1)) % K == 0) {
cout << 0 << '\n';
} else {
cout << (N - R + L - 1) + (M * (R - L + 1)) % K << '\n';
}
return 0;
}
if (R - j + i - L == K) {
R = j;
L = i;
} else {
if (R - j + i - L > K) {
R -= K;
}
break;
}
}
cout << N + (M - 1) * (R - L + 1) << '\n';
}
| 7 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int dp[1005][1005][2],n,k,m=1000000007;
int solve(int i,int curr,int d){
if(curr == 0)return 0;
if(i == 0)return 1;
if(i == n+1)return 1;
if(dp[i][curr][d]!=-1)return dp[i][curr][d];
if(d)return dp[i][curr][d]=(solve(i+1,curr,d)+solve(i-1,curr-1,1-d))%m;
return dp[i][curr][d]=(solve(i+1,curr-1,1-d)+solve(i-1,curr,d))%m;
}
int main()
{
// freopen("measurement.in", "r", stdin);
// freopen("measurement.out","w", stdout);
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int t;
cin>>t;
while(t--){
cin>>n>>k;
memset(dp,-1,sizeof dp);
cout<<solve(1,k,1)<<endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 6;
int n, m, k;
long long rm;
struct USF {
int fa[maxn], sz[maxn];
int u[maxn], v[maxn], tot;
void init() {
tot = 0;
for (int i = 1; i <= 2 * n; i++) fa[i] = i, sz[i] = 1;
}
int fid(int x) { return x == fa[x] ? x : fid(fa[x]); }
void join(int x, int y) {
int fx = fid(x), fy = fid(y);
if (fx == fy) return;
if (sz[fx] < sz[fy]) swap(fx, fy), swap(x, y);
fa[fy] = fx;
sz[fx] += sz[fy];
++tot;
u[tot] = fx;
v[tot] = fy;
}
void undo(int k) {
for (int i = 1; i <= k; i++) {
fa[v[tot]] = v[tot];
sz[u[tot]] -= sz[v[tot]];
tot--;
}
}
} dsu;
vector<pair<int, int> > G[maxn];
map<pair<int, int>, int> M;
int a[maxn], b[maxn], c[maxn], vis[maxn];
int main() {
scanf("%d%d%d", &n, &m, &k);
dsu.init();
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
if (c[a[i]] == c[b[i]]) {
int x = dsu.fid(a[i]), y = dsu.fid(b[i]);
if (x == y)
vis[c[a[i]]] = 1;
else
dsu.join(a[i], b[i] + n), dsu.join(a[i] + n, b[i]);
}
}
for (int i = 1; i <= k; i++)
if (!vis[i]) rm++;
long long ans = rm * (rm - 1) / 2, tot = 0;
for (int i = 1; i <= m; i++) {
if (c[a[i]] != c[b[i]] && !vis[c[a[i]]] && !vis[c[b[i]]]) {
if (c[a[i]] > c[b[i]]) swap(a[i], b[i]);
if (!M.count(make_pair(c[a[i]], c[b[i]])))
M[make_pair(c[a[i]], c[b[i]])] = ++tot;
G[M[make_pair(c[a[i]], c[b[i]])]].push_back(make_pair(a[i], b[i]));
}
}
for (int i = 1; i <= tot; i++) {
int sz = dsu.tot;
for (auto k : G[i]) {
int x = dsu.fid(k.first), y = dsu.fid(k.second);
if (x != y)
dsu.join(k.first, k.second + n), dsu.join(k.first + n, k.second);
else {
ans--;
break;
}
}
dsu.undo(dsu.tot - sz);
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, ct = 0, n, t, x, y, z;
double a, b, c, d;
char p, q, r, s;
string str, s1, s2, s3;
string st[11];
map<string, int> m;
vector<int> v;
cin >> str;
t = 10;
for (i = 0; i < t; i++) {
cin >> s1;
m[s1] = i;
}
i = 0;
for (; i <= 70;) {
s2 = str.substr(i, 10);
cout << m[s2];
i += 10;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int t, n;
char a[15][5];
int b[15];
char m[15][5];
int vis[15];
int y = 0;
bool check(char a[]) {
for (int i = 1; i <= n; i++) {
if (!strcmp(m[i], a)) {
return true;
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> t;
while (t--) {
cin >> n;
int num = 0;
y = 0;
for (int i = 0; i < 10; i++) vis[i] = 0;
for (int i = 0; i <= n; i++) {
strcpy(m[i], "00000");
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = 0;
}
for (int i = 1; i <= n; i++) {
if (check(a[i])) {
b[i]++;
num++;
}
strcpy(m[++y], a[i]);
vis[a[i][3] - '0'] = 1;
}
for (int i = 1; i <= n; i++) {
if (b[i] != 0) {
for (int j = 0; j < 10; j++) {
if (vis[j] == 0) {
a[i][3] = j + '0';
vis[j] = 1;
break;
}
}
}
}
cout << num << endl;
for (int i = 1; i <= n; i++) {
cout << a[i] << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using dl = double;
using ull = unsigned long long;
const long N = 3e5 + 10;
ll aarray[N];
ll magic[510][510];
vector<ll> primes;
bool check[1000001];
ll vis[N];
map<ll, ll> mp;
void solve() {
ll i, j, k, m, n, l, r, q, ans, sum = 0;
string str;
bool yes = true;
vector<ll> v, va;
cin >> n;
for (i = 0; i <= 30; i++) {
k = (1 << i);
k--;
mp[k]++;
}
if (mp[n]) {
cout << 0 << "\n";
return;
}
while (1) {
while (n) {
if (n % 2) {
v.push_back(1);
} else
v.push_back(0);
n /= 2;
}
reverse(v.begin(), v.end());
ll pro = 1;
ans = 0;
for (i = v.size() - 1; i >= 0; i--) {
if (v[i] == 0) {
ans += pro;
}
pro *= 2;
}
ll sz = v.size();
n = ans;
va.push_back(sz);
sum++;
if (mp[n]) {
break;
}
n++;
sum++;
if (mp[n]) {
break;
}
v.clear();
}
cout << sum << "\n";
for (auto c : va) {
cout << c << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string str;
ll i, j, n, m, k, t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long res = 1;
long long n = 0;
while (res <= l) {
res *= 2LL;
n++;
}
res = 1;
long long m = 0;
while (res <= r) {
res *= 2LL;
m++;
}
long long odd = n / 2LL, even = (n - 1) / 2LL;
long long sum1 = 0, sum2 = 0;
long long st, now;
res = 1;
for (long long i = 1; i <= odd; i++) {
sum1 += res;
res *= 4LL;
}
res = 2;
for (long long i = 1; i <= even; i++) {
sum2 += res;
res *= 4LL;
}
if (n % 2) {
now = (long long)1 << (n - 1);
sum1 = l - now + sum1 + 1;
st = sum1 * 2 - 1;
sum1 = ((sum1 % mod) * (sum1 % mod)) % mod;
sum2 = ((sum2 % mod) * ((sum2 + 1LL) % mod)) % mod;
} else {
now = (long long)1 << (n - 1);
sum2 = l - now + sum2 + 1;
st = sum2 * 2;
sum1 = ((sum1 % mod) * (sum1 % mod)) % mod;
sum2 = ((sum2 % mod) * ((sum2 + 1LL) % mod)) % mod;
}
res = 1;
odd = m / 2, even = (m - 1) / 2;
long long sum3 = sum1, sum4 = sum2;
sum1 = sum2 = 0;
for (long long i = 1; i <= odd; i++) {
sum1 += res;
res *= 4LL;
}
res = 2;
for (long long i = 1; i <= even; i++) {
sum2 += res;
res *= 4LL;
}
if (m % 2) {
now = (long long)1 << (m - 1);
sum1 = r - now + sum1 + 1;
sum1 = ((sum1 % mod) * (sum1 % mod)) % mod;
sum2 = ((sum2 % mod) * ((sum2 + 1LL) % mod)) % mod;
} else {
now = (long long)1 << (m - 1);
sum2 = r - now + sum2 + 1;
sum1 = ((sum1 % mod) * (sum1 % mod)) % mod;
sum2 = ((sum2 % mod) * ((sum2 + 1LL) % mod)) % mod;
}
cout << (mod + (sum1 + sum2) % mod - (sum3 + sum4) % mod + st) % mod << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[5100];
int n, sg[5100], vis[5100], l[5100], r[5100], anssg, is[5100], sg1[5100];
int main() {
int i, j, k;
scanf("%s", s + 1);
n = strlen(s + 1);
sg[0] = 0;
sg[1] = 1;
for (i = 2; i <= n; i++) {
for (j = 0; j <= i; j++) vis[j] = 0;
vis[sg[i - 2]] = 1;
for (j = 2; j < i; j++) vis[sg[j - 2] ^ sg[i - j - 1]] = 1;
for (j = 0; vis[j] == 1; j++)
;
sg[i] = j;
}
for (i = 2; i < n; i++)
if (s[i - 1] == s[i + 1]) is[i] = 1;
anssg = 0;
for (i = 2; i < n; i = j + 1) {
j = i;
if (!is[i]) continue;
while (is[j + 1] == 1) j++;
anssg ^= sg[j - i + 1];
for (k = i; k <= j; k++) sg1[k] = sg[j - i + 1];
for (k = i; k <= j; k++) {
l[k] = sg[max(0, k - i - 1)];
r[k] = sg[max(0, j - k - 1)];
}
}
if (!anssg)
printf("Second\n");
else {
printf("First\n");
for (i = 2; i < n; i++) {
if (!is[i]) continue;
if ((anssg ^ sg1[i] ^ l[i] ^ r[i]) == 0) {
printf("%d\n", i);
return 0;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, m, res = N * N, a[N], b[N], c[N], d[N], mx[N * N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
;
scanf("%d", &b[i]);
;
}
for (int i = 0; i < m; i++) {
scanf("%d", &c[i]);
;
scanf("%d", &d[i]);
;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (a[i] <= c[j])
mx[max(c[j] - a[i], 0)] =
max(mx[max(c[j] - a[i], 0)], max(d[j] - b[i] + 1, 0));
;
}
for (int i = N * N - 3; i >= 0; i--) {
mx[i] = max(mx[i], mx[i + 1]);
;
res = min(res, i + mx[i]);
;
}
cout << res << endl;
}
| 6 |
#include <bits/stdc++.h>
int pan(int nn) {
int sum = 0, i;
for (i = 1; i <= 8; i++) {
sum = sum * 2;
sum = sum + nn % 2;
nn = nn / 2;
}
return sum;
}
int main() {
char s[110];
int n, i, sum = 0, pp;
gets(s);
n = strlen(s);
for (i = 0; i < n; i++) {
pp = pan(s[i]);
printf("%d\n", (sum - pp + 256) % 256);
sum = pp;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ii = pair<int, int>;
using ll = long long;
using llu = unsigned long long;
const int INF = numeric_limits<int>::max();
int main() {
int n, d1, d2, l;
while (cin >> n >> l >> d1 >> d2) {
vector<int> v(n);
vector<ii> p;
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) {
p.emplace_back(v[i], 0);
if (v[i] - d1 >= 0) p.emplace_back(v[i] - d1, 1);
if (v[i] + d1 <= l) p.emplace_back(v[i] + d1, 1);
if (v[i] - d2 >= 0) p.emplace_back(v[i] - d2, 2);
if (v[i] + d2 <= l) p.emplace_back(v[i] + d2, 2);
}
p.emplace_back(l + 1, 0);
sort(p.begin(), p.end());
int o = -1;
bool has[3];
int a1 = -1, a2 = -1;
for (auto pp : p) {
int x = pp.first;
int j = pp.second;
if (x != o) {
if (o != -1) {
if (has[1]) {
if (has[0]) a1 = INF;
if (a1 == -1) a1 = o;
}
if (has[2]) {
if (has[0]) a2 = INF;
if (a2 == -1) a2 = o;
}
if (has[1] && has[2] && a1 != INF && a2 != INF) a1 = a2 = o;
}
o = x;
for (int i = 0; i < 3; i++) has[i] = false;
}
has[j] = true;
}
vi add;
if (a1 != INF) add.emplace_back(a1);
if (a2 != INF && a2 != a1) add.emplace_back(a2);
cout << add.size() << endl;
if (!add.empty()) {
for (int i = 0; i < add.size(); i++) {
if (i) cout << " ";
cout << add[i];
}
cout << endl;
}
}
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.