solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, k, t;
long long int l;
int a[1000005], b[1000005];
vector<int> rev[1000005];
vector<long long int> p[1000005], sum2[1000005];
long long int sum[1000005][2];
map<int, int> rnk;
int main() {
scanf("%d%lld%d", &n, &l, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++) {
if (rnk.count(b[i]) == 0) rnk.insert(pair<int, int>(b[i], i));
}
for (int i = 1; i <= n; i++) {
rev[rnk[a[i]]].push_back(i);
}
long long int cse = l / n, rem = l % n;
if ((long long int)k < cse + 1)
t = k;
else
t = cse + 1;
for (int i = 1; i <= n; i++) {
p[i].push_back(0);
sum2[i].push_back(0);
}
bool s = 0;
for (int j = 1; j <= t; j++) {
for (int i = 1; i <= n; i++) {
if (j == 1)
p[i].push_back(1);
else
p[i].push_back(sum[rnk[a[i]]][!s]);
}
for (int i = 1; i <= n; i++) {
sum[i][s] = sum[i - 1][s];
for (int z = 0; z < rev[i].size(); z++)
sum[i][s] = (sum[i][s] + p[rev[i][z]][j]) % 1000000007;
}
s = !s;
}
long long int ans = 0;
s = 0;
for (int j = 1; j <= t; j++)
for (int i = 1; i <= n; i++) {
if (i == 1)
sum2[i].push_back(p[i][j] % 1000000007);
else
sum2[i].push_back((sum2[i - 1][j] + p[i][j]) % 1000000007);
}
for (int i = 1; i <= t; i++) {
long long int tmp;
tmp =
((sum2[n][i] % 1000000007) * ((cse - i + 1) % 1000000007)) % 1000000007;
ans = (ans + tmp) % 1000000007;
if (rem == 0) continue;
tmp = sum2[rem][i] % 1000000007;
ans = (ans + tmp) % 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int largediv(int n) {
int i, j;
int ret = 1;
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret = i;
break;
}
}
if (ret != 1) ret = n / ret;
return ret;
}
int main() {
int n, sum;
int i, j, k;
scanf("%d", &n);
sum = n;
while (n != 1) {
n = largediv(n);
sum += n;
}
printf("%d\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, n, l, h;
cin >> n >> h;
long long int ar[n + 1];
for (i = 1; i <= n; i++) {
cin >> ar[i];
}
long long int mx = 0;
for (i = 1; i <= n; i++) {
vector<long long int> vc;
for (j = 1; j <= i; j++) {
vc.push_back(ar[j]);
}
sort(vc.begin(), vc.end());
long long int x = 0, y = 0, s = 0;
for (j = 0; j < i; j++) {
if (s % 2 == 0) {
if (x + vc[j] <= h) {
x += vc[j];
} else if (y + vc[j] <= h) {
y += vc[j];
} else
break;
} else {
if (y + vc[j] <= h) {
y += vc[j];
} else if (x + vc[j] <= h) {
x += vc[j];
} else
break;
}
s = (s + 1) % 2;
}
if (j == i) {
if (i > mx) mx = i;
}
}
cout << mx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<string, vector<int> > mp;
string s[200000 + 10];
int main() {
int sum = 99999999;
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
while (x) {
s[i] += x % 2;
x /= 2;
}
reverse(s[i].begin(), s[i].end());
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < s[i].size(); j++)
mp[s[i].substr(0, j + 1)].push_back(s[i].size() - j - 1);
}
for (map<string, vector<int> >::iterator it = mp.begin(); it != mp.end();
it++) {
vector<int> a = it->second;
if (a.size() < k) continue;
sort(a.begin(), a.end());
int t = 0;
for (int i = 0; i < k; i++) t += a[i];
sum = min(sum, t);
}
cout << sum;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100;
long long Fib[MAX];
int num;
void initial() {
Fib[0] = Fib[1] = 1;
for (int i = 2; i < MAX; i++) {
Fib[i] = Fib[i - 1] + Fib[i - 2];
if (Fib[i] > 1e18) {
num = i;
break;
}
}
}
int main() {
initial();
int n;
long long k;
while (scanf("%d%I64d", &n, &k) != EOF) {
bool start = true;
for (int i = 1; i <= n; i++) {
if (start)
start = false;
else
printf(" ");
if (k > Fib[n - i]) {
printf("%d %d", i + 1, i);
k -= Fib[n - i];
i++;
} else
printf("%d", i);
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int get() {
int f = 0, v = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') break;
if (ch == '-')
f = 1;
else
v = ch - '0';
while (isdigit(ch = getchar())) v = v * 10 + ch - '0';
if (f)
return -v;
else
return v;
}
const int maxn = 100003;
struct Tpoint {
long long x, y;
inline bool operator<(const Tpoint &b) const {
return b.x == x ? y > b.y : x < b.x;
}
} p[maxn];
long long s[maxn], a, b, c, d;
int n, tot = 0;
int main() {
n = get(), a = get(), b = get(), c = get(), d = get();
for (int i = 1; i <= n; i++) {
long long x = get(), y = get();
p[i].x = c * x - d * y;
p[i].y = b * y - a * x;
}
sort(p + 1, p + 1 + n);
for (int k, i = 1; i <= n; i++)
if (p[i].x > 0 && p[i].y > 0) {
s[k = lower_bound(s, s + 1 + tot, p[i].y) - s] = p[i].y;
if (k == tot + 1) tot = k;
}
printf("%d\n", tot);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7, N = 1e5 + 10;
int p[N], dp[N][2], n, Xtdp[N][2], pa[N];
vector<int> child[N];
int sum(int a, int b) {
int c = a + b;
if (c >= MOD) c -= MOD;
return c;
}
int mul(int a, int b) { return 1LL * a * b % MOD; }
void dfs(int v) {
for (int u : child[v]) dfs(u);
if (child[v].size() == 0) {
dp[v][0] = 0;
dp[v][1] = 1;
return;
}
int even = 0, even1 = 0, odd = 1, odd1 = 0;
for (int i = 0; i < (int)child[v].size(); i++) {
int u = child[v][i];
even1 = sum(mul(even, (dp[u][0] + 1)), mul(odd, dp[u][1]));
odd1 = sum(mul(even, dp[u][1]), mul(odd, (dp[u][0] + 1)));
odd = odd1;
even = even1;
}
even = mul(even, 2);
odd = mul(odd, 2);
int alleven = (dp[child[v][0]][0] + 1), allodd_e = 1,
allodd_o = dp[child[v][0]][1];
for (int i = 1; i < (int)child[v].size(); i++) {
int aoe = allodd_e, aoo = allodd_o, u = child[v][i];
alleven = mul(alleven, (dp[u][0] + 1));
allodd_e = sum(mul(aoo, dp[u][1]), aoe);
allodd_o = sum(mul(aoe, dp[u][1]), aoo);
}
dp[v][0] = sum(even, MOD - allodd_o);
dp[v][1] = sum(odd, MOD - alleven);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> p[i];
p[i]--;
child[p[i]].push_back(i);
}
dfs(0);
cout << sum(dp[0][0], dp[0][1]);
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
using namespace std;
const double pi = 3.1415926535897932384626433832795;
template <class T>
inline T Sqr(const T &x) {
return x * x;
}
template <class T>
inline T Abs(const T &x) {
return x >= 0 ? x : -x;
}
int n, m;
char s[5005], t[5005];
int dp[5005][5005];
void solve() {
scanf("%s", s);
scanf("%s", t);
n = strlen(s);
m = strlen(t);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i] == t[j]) {
dp[i][j]++;
if (i > 0 && j > 0) dp[i][j] += dp[i - 1][j - 1];
}
if (j > 0) dp[i][j] += dp[i][j - 1];
dp[i][j] %= 1000000007;
}
}
int res = 0;
for (int i = 0; i < n; i++) res = (res + dp[i][m - 1]) % 1000000007;
cout << res;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, d, z = 0;
cin >> d >> n;
int a[n];
for (i = 0; i < n - 1; i++) {
cin >> a[i];
z += d - a[i];
}
cin >> a[i];
cout << z;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1, 0};
const int N = 2000;
int n, m;
int mx[N][N];
bool niceKor(int x, int y) {
return x >= 1 && x <= n && y >= 1 && y <= n && mx[x][y] == 1;
}
bool sqTest(int x, int y) {
for (int i = 0; i < 9; i++) {
int newX = x + dx[i];
int newY = y + dy[i];
if (!niceKor(newX, newY)) return false;
}
return true;
}
bool test(int x, int y) {
for (int i = 0; i < 9; i++) {
int newX = x + dx[i];
int newY = y + dy[i];
if (sqTest(newX, newY)) return true;
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
mx[x][y] = 1;
if (test(x, y)) {
printf("%d", i);
return 0;
}
}
puts("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e6 + 100;
const int mod = 1e9 + 7;
int n, m, k;
long long dp1[MAXN], dp2[MAXN];
struct fc {
int d, u, v;
long long cost;
};
vector<fc> v1;
vector<fc> v2;
bool vis[MAXN];
long long pre[MAXN];
bool cmp(fc a, fc b) { return a.d < b.d; }
bool cmp2(fc a, fc b) { return a.d > b.d; }
int main() {
scanf("%d%d%d", &n, &m, &k);
int maxd = -1;
for (int i = 1; i <= m; i++) {
int d, u, v;
long long cost;
scanf("%d%d%d%lld", &d, &u, &v, &cost);
maxd = max(d, maxd);
if (v == 0)
v1.push_back({d, u, v, cost});
else
v2.push_back({d, u, v, cost});
}
sort(v1.begin(), v1.end(), cmp);
int cnt = 0;
memset(vis, 0, sizeof(vis));
memset(pre, -1, sizeof(pre));
memset(dp1, -1, sizeof(dp1));
long long sum = 0;
for (auto elem : v1) {
int d = elem.d, u = elem.u, v = elem.v;
long long cost = elem.cost;
if (!vis[u]) {
vis[u] = 1;
cnt++;
pre[u] = cost;
sum += cost;
} else {
if (cost < pre[u]) {
sum = sum - pre[u] + cost;
pre[u] = cost;
}
}
if (cnt == n) {
dp1[d] = dp1[d - 1];
if (dp1[d] == -1)
dp1[d] = sum;
else
dp1[d] = min(dp1[d], sum);
}
}
sort(v2.begin(), v2.end(), cmp2);
memset(vis, 0, sizeof(vis));
memset(pre, -1, sizeof(pre));
memset(dp2, -1, sizeof(dp2));
sum = 0;
cnt = 0;
for (auto elem : v2) {
int d = elem.d, v = elem.u, u = elem.v;
long long cost = elem.cost;
if (!vis[u]) {
vis[u] = 1;
cnt++;
pre[u] = cost;
sum += cost;
} else {
if (cost < pre[u]) {
sum = sum - pre[u] + cost;
pre[u] = cost;
}
}
if (cnt == n) {
dp2[d] = dp2[d + 1];
if (dp2[d] == -1)
dp2[d] = sum;
else
dp2[d] = min(dp2[d], sum);
}
}
for (int i = 1; i <= maxd; i++)
if (dp1[i] == -1) dp1[i] = dp1[i - 1];
for (int i = maxd; i >= 1; i--)
if (dp2[i] == -1) dp2[i] = dp2[i + 1];
long long ans = ((long long)0x3f3f3f3f3f3f3f3f);
for (int i = 1; i <= maxd; i++) {
if (dp1[i] != -1 && dp2[i + k + 1] != -1) {
ans = min(dp1[i] + dp2[i + 1 + k], ans);
}
}
if (ans == ((long long)0x3f3f3f3f3f3f3f3f))
cout << "-1" << endl;
else
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n = 0, ans = 1e18;
cin >> n;
vector<pair<long long, long long> > a(n);
for (long long i = 0; i < n; i++) cin >> a[i].second >> a[i].first;
for (long long curh = 1; curh <= 1000; curh++) {
long long curw = 0, cnt = 0;
vector<long long> wh;
for (long long i = 0; i < n; i++) {
if (a[i].first > curh && a[i].second > curh) {
curw = 1e9;
break;
}
if (a[i].first > curh) {
curw += a[i].first;
cnt++;
continue;
}
if (a[i].second > curh) {
curw += a[i].second;
continue;
}
curw += min(a[i].first, a[i].second);
wh.push_back(a[i].first - a[i].second);
}
if (cnt * 2 > n) continue;
sort((wh).begin(), (wh).end());
long long left = cnt + wh.size();
while (left * 2 > n) {
if (wh.back() < 0) curw -= wh.back();
wh.pop_back();
left--;
}
ans = min(ans, curh * curw);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int start;
int ara[n];
vector<int> x;
x.push_back(1);
vector<int> sta;
for (int i = 2; 2 * i < n; i++) {
if (n % i == 0) x.push_back(i);
}
bool t = true;
for (int i = 0; i < n; i++) {
cin >> ara[i];
if (ara[i] == 1) sta.push_back(i);
}
bool ans = false;
int sum;
int pos = 0;
if (sta.size() < 3) goto there;
for (int i = 0; i < x.size(); i++) {
int temp = x[i];
sum = temp;
for (pos = 0; sta[pos] < temp; pos++) {
if (pos >= sta.size()) break;
for (int j = sta[pos]; j < n; j = j + sum) {
if (sta[pos] >= temp) {
break;
}
if (ara[j] == 0) {
break;
} else if (j == n - temp + sta[pos]) {
cout << "YES" << endl;
ans = true;
goto there;
}
}
}
}
there:;
if (!ans) cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int compare(string s, string s1) {
int ans = 0;
for (int i = 0; i < 7; i++) {
if (s[i] == '1' && s1[i] == '0') {
ans++;
} else if (s[i] == '0' && s1[i] == '1') {
return -1;
}
}
return ans;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
int a, b, t, c, d, n, k;
cin >> n >> k;
string s[10] = {"1110111", "0010010", "1011101", "1011011", "0111010",
"1101011", "1101111", "1010010", "1111111", "1111011"};
string str;
int dist[n + 1][10];
for (int i = 1; i <= n; i++) {
cin >> str;
for (int j = 0; j < 10; j++) {
dist[i][j] = compare(s[j], str);
}
}
int dp[n + 2][k + 1];
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= k; j++) {
dp[i][j] = 0;
}
}
dp[n + 1][0] = 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= k; j++) {
if (dp[i + 1][j] == 1) {
for (int d = 0; d < 10; d++) {
if (dist[i][d] + j <= k && dist[i][d] != -1) {
dp[i][j + dist[i][d]] = 1;
}
}
}
}
}
if (dp[1][k] == 0) {
cout << -1;
return 0;
} else {
for (int i = 1; i <= n; i++) {
for (int d = 9; d >= 0; d--) {
if (dist[i][d] != -1 && dp[i + 1][k - dist[i][d]] == 1 &&
k >= dist[i][d]) {
cout << d;
k -= dist[i][d];
break;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
int dp[105][105];
int n, m, k, P;
int cnt[10];
void addMod(int &a, int b, int m = mod) {
a += b;
if (m <= a) {
a -= m;
}
}
vector<vector<int> > I(int n) {
vector<vector<int> > ret(n, vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
ret[i][i] = 1;
}
return ret;
}
vector<vector<int> > mult(vector<vector<int> > a, vector<vector<int> > b) {
int n = a.size(), m = a[0].size(), k = b[0].size();
vector<vector<int> > ret(n, vector<int>(k, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k; ++j) {
for (int p = 0; p < m; ++p) {
addMod(ret[i][j], a[i][p] * 1ll * b[p][j] % mod);
}
}
}
return ret;
}
vector<vector<int> > binPow(vector<vector<int> > a, int b) {
vector<vector<int> > ret = I(a.size());
while (b > 0) {
if (b & 1) {
ret = mult(ret, a);
}
a = mult(a, a);
b >>= 1;
}
return ret;
}
void solve() {
scanf("%d %d %d %d", &n, &m, &k, &P);
for (int i = 1, x; i <= n; ++i) {
scanf("%d", &x);
++cnt[x];
}
vector<vector<int> > base(1, vector<int>(P, 0));
base[0][0] = 1;
vector<vector<int> > M(P, vector<int>(P, 0));
for (int cur = 0; cur < P; ++cur) {
for (int c = 1; c <= 9; ++c) {
int nxt = (cur * 10 + c) % P;
addMod(M[cur][nxt], cnt[c]);
}
}
vector<vector<int> > ans = mult(base, binPow(M, m));
printf("%d\n", ans[0][k]);
}
int main() {
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string inp;
cin >> inp;
int stacount = 0;
int strcount = 0;
while (strcount < inp.length()) {
if (inp[strcount + 1] != '/') {
for (int i = 0; i < stacount; i++) cout << ' ';
string ths(inp, strcount, 3);
cout << ths << endl;
stacount += 2;
strcount += 3;
} else {
for (int i = 0; i < stacount - 2; i++) cout << ' ';
string ths(inp, strcount, 4);
cout << ths << endl;
stacount -= 2;
strcount += 4;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mn = 1000000001;
long long mx = -1000000001;
long long GCD(long long a, long long b) {
if (!b) return a;
return GCD(b, a % b);
}
long long NOD(long long x) {
if (!x) return 0;
return NOD(x / 10) + 1;
}
bool IsPrime(long long x) {
long long s = sqrt(x);
for (long long i = 2; i <= s; i++)
if (x % i == 0) return false;
return true;
}
int a[100];
int dp[100][3];
int f(int i, int g, int n) {
if (i == n) return 0;
if (dp[i][g] != -1) return dp[i][g];
if (a[i] == 0) {
dp[i][g] = f(i + 1, 0, n) + 1;
return dp[i][g];
}
if (a[i] == 1 && g != 1) {
dp[i][g] = f(i + 1, 1, n);
return dp[i][g];
}
if (a[i] == 2 && g != 2) {
dp[i][g] = f(i + 1, 2, n);
return dp[i][g];
}
if (a[i] == 3 && g == 1) {
dp[i][g] = f(i + 1, 2, n);
return dp[i][g];
}
if (a[i] == 3 && g == 2) {
dp[i][g] = f(i + 1, 1, n);
return dp[i][g];
}
if (a[i] == 3 && g == 0) {
dp[i][g] = min(f(i + 1, 1, n), f(i + 1, 2, n));
return dp[i][g];
}
dp[i][g] = f(i + 1, 0, n) + 1;
return dp[i][g];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int n;
for (long long i = 0; i < 100; i++)
for (long long j = 0; j < 3; j++) dp[i][j] = -1;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
cout << f(0, 0, n);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const int MOD = 1e9 + 7;
const long long oo = 1e9 + 7;
long long GCD(long long a, long long b) { return !b ? a : GCD(b, a % b); }
const int mx = 1e5 + 5;
int n, m, ptr;
long long h[mx], p[mx], t[mx];
long long calc(long long x, long long stps, long long idx) {
long long l = idx, r = m - 1, md, ret = -1;
while (l <= r) {
md = (l + r) / 2;
if (p[md] <= x + stps)
l = md + 1, ret = md;
else
r = md - 1;
}
return ret;
}
bool can(long long stps) {
ptr = 0;
fill(t, t + n, stps);
for (int i = 0; i < n; i++)
if (ptr != m) {
if (h[i] <= p[ptr]) {
long long bst = calc(h[i], stps, ptr);
if (bst != -1) ptr = bst + 1;
} else {
if (abs(h[i] - p[ptr]) > stps) return 0;
long long bst;
if ((stps - (h[i] - p[ptr])) / 2 > stps - (h[i] - p[ptr]) * 2)
bst = calc(h[i], (stps - (h[i] - p[ptr])) / 2, ptr);
else
bst = calc(h[i], stps - (h[i] - p[ptr]) * 2, ptr);
if (bst != -1) ptr = bst + 1;
}
}
return ptr == m;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%lld", &h[i]);
for (int i = 0; i < m; i++) scanf("%lld", &p[i]);
long long l = 0, r = 1e10 + 5e9, mid;
while (l <= r) {
mid = (l + r) / 2;
if (can(mid))
r = mid - 1;
else
l = mid + 1;
}
cout << ++r << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200011;
int n, m, t, V[N];
pair<int, int> a[N];
vector<int> g[N], now;
int main() {
scanf("%d%d", &n, &m);
t = m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= t; j++) {
scanf("%d", &a[j].first);
a[j].second = j;
}
sort(a + 1, a + t + 1);
for (int j = 1; j < t; j++) {
if (a[j].first == -1) continue;
int k = j + 1;
while (k <= t and a[k].first == a[j].first) k++;
int o = k;
while (o <= t and a[o].first == a[k].first) o++;
m++;
for (int u = j; u < k; u++) g[a[u].second].push_back(m);
for (int u = k; u < o and u <= t; u++) g[m].push_back(a[u].second);
j = k - 1;
}
}
for (int i = 1; i <= m; i++)
for (int j = 0; j < g[i].size(); j++) V[g[i][j]]++;
for (int i = 1; i <= m; i++)
if (V[i] == 0) now.push_back(i);
for (int i = 0; i < now.size(); i++) {
int v = now[i];
for (int j = 0; j < g[v].size(); j++) {
int u = g[v][j];
V[u]--;
if (V[u] == 0) now.push_back(u);
}
}
if (now.size() != m) return cout << -1, 0;
for (int i = 0; i < now.size(); i++)
if (now[i] <= t) printf("%d ", now[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, r;
scanf("%d%d", &l, &r);
if (l == r && l % 2)
printf("%d", l);
else
printf("%d", 2);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, pre[N], mcnt;
struct edge {
int x, next;
} e[N << 1];
int deg[N], f[N], tmp[N];
bool g[N];
void work() {
int i, x, y;
scanf("%d%d", &n, &m);
memset(pre, -1, sizeof(pre));
for (i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
e[mcnt] = (edge){y, pre[x]}, pre[x] = mcnt++;
e[mcnt] = (edge){x, pre[y]}, pre[y] = mcnt++;
++deg[x], ++deg[y];
}
queue<int> Q;
for (i = 1; i <= n; ++i)
if (deg[i] > 1) Q.push(i), g[i] = 1;
while (!Q.empty()) {
x = Q.front(), Q.pop(), g[x] = 0;
if (deg[x] <= 1) continue;
f[x] ^= 1, deg[x] = -deg[x];
for (i = pre[x]; ~i; i = e[i].next) {
int y = e[i].x;
++deg[x];
if (f[x] != f[y]) {
--deg[y];
} else {
++deg[y];
if (deg[y] > 1) Q.push(y), g[y] = 1;
}
}
}
for (i = 1; i <= n; ++i) printf("%d", f[i]);
}
int main() {
work();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[2001];
int b[2001];
int curr_id[2001];
int target_id[2001];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
curr_id[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
target_id[b[i]] = i;
}
int min_cost = 0;
vector<pair<int, int>> operations;
for (int id = n; id >= 0; id--)
while (curr_id[b[id]] != id) {
int value = b[id];
int j = curr_id[value] + 1;
while (j <= id && target_id[a[j]] > curr_id[value]) j++;
min_cost += j - curr_id[value];
operations.push_back({curr_id[value], j});
curr_id[a[j]] = curr_id[value];
swap(a[curr_id[value]], a[j]);
curr_id[value] = j;
}
cout << min_cost << '\n';
cout << operations.size() << '\n';
for (auto operation : operations)
cout << operation.first << ' ' << operation.second << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int v[4000], d[4000], p[4000], n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d%d", v + i, d + i, p + i);
vector<int> ans;
queue<int> ci;
for (int i = 0; i < n; i++) {
while (!ci.empty()) {
int ii = ci.front();
ci.pop();
for (int j = ii + 1; j < n; j++)
if (p[j] >= 0) {
p[j] -= d[ii];
if (p[j] < 0) ci.push(j);
}
}
if (p[i] < 0) continue;
ans.push_back(i + 1);
int val = v[i];
for (int j = i + 1; j < n && val; j++)
if (p[j] >= 0) {
p[j] -= val;
val--;
if (p[j] < 0) ci.push(j);
}
}
printf("%d\n", ((int)ans.size()));
for (auto &val : ans) printf("%d ", val);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
struct Mod {
const long long M;
Mod(long long M) : M(M) {}
long long qadd(long long a, long long b) const {
return a += b, a < M ? a : a - M;
}
long long add(long long a, long long b) const { return qadd((a + b) % M, M); }
long long mul(long long a, long long b) const { return add(a * b, 0); }
};
struct Factorial : Mod {
vector<long long> fac, ifac;
Factorial(int N, long long M) : fac(N, 1), ifac(N, 1), Mod(M) {
for (int i = 2; i < N; ++i)
fac[i] = mul(fac[i - 1], i), ifac[i] = mul(M - M / i, ifac[M % i]);
for (int i = 2; i < N; ++i) ifac[i] = mul(ifac[i], ifac[i - 1]);
}
} f(N, 998244353);
int n, ans, cnt[N], dp[N];
int main() {
scanf("%d", &n);
for (int i = 0, t; i < n; ++i) scanf("%d", &t), ++cnt[t];
for (int i = dp[0] = 1, tot = 0; i <= n; ++i)
if (cnt[i])
for (int j = tot++, t = f.mul(f.mul(cnt[i], cnt[i] - 1), f.ifac[n]); ~j;
--j)
ans = f.qadd(ans, f.mul(f.mul(t, f.fac[n - j - 2]), dp[j])),
dp[j + 1] = f.qadd(dp[j + 1], f.mul(cnt[i], dp[j]));
printf("%d", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 200001;
const int kM = 998244353;
int f[kMaxN], c[kMaxN];
int n, m;
long long ans;
void R(int n, int v) {
while (n > 1) {
c[f[n]] += v;
n /= f[n];
}
}
int main() {
cin >> n >> m;
if (n > 2) {
for (int i = 2; i <= m; i++) {
if (!f[i]) {
for (int j = i; j <= m; j += i) {
f[j] = i;
}
}
}
for (int i = n; i <= m; i++) {
R(i, 1);
}
for (int i = 2; i <= m - n + 1; i++) {
R(i, -1);
}
R(n - 2, 1);
c[2] += n - 3;
ans = 1;
for (int i = 2; i <= m; i++) {
for (int j = 1; j <= c[i]; j++) {
ans = (ans * i) % kM;
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str = "", s;
bool last = false;
while (getline(cin, s)) {
bool flag = false;
for (int i = 0; i < s.length(); i++) {
if (s[i] != ' ') {
flag = (s[i] == '#');
break;
}
}
if (flag) {
if (last) cout << str << "\n";
str = "";
cout << s << "\n";
last = false;
} else {
last = true;
string h = "";
for (int i = 0; i < s.length(); i++) {
if (s[i] != ' ') {
h += s[i];
}
}
str += h;
}
}
if (last) {
cout << str << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
const double PI = 2 * acos(0.0);
const long long MOD = 1000000007;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
long long int n, i, j, index = 0, l, b_size = 0, c_size = 0, flag = 1,
cnt = 0;
string a, b, c;
cin >> a;
l = a.size();
for (i = l - 1; i >= 0; i--) {
if (a[i] == 'a') {
index = i;
flag = 0;
break;
}
b.push_back(a[i]);
}
if (flag) {
b.clear();
if (l % 2) {
cout << ":(" << endl;
} else {
for (i = 0; i < l / 2; i++) {
b.push_back(a[i]);
}
for (i = l / 2; i <= l - 1; i++) {
c.push_back(a[i]);
}
if (b == c) {
cout << b << endl;
} else {
cout << ":(" << endl;
}
}
return 0;
}
if (b.size()) {
b_size = b.size();
reverse(b.begin(), b.end());
}
for (i = 0; i < index + 1; i++) {
if (a[i] != 'a') {
c.push_back(a[i]);
}
}
c_size = c.size();
long long int k = b_size - c_size;
if (b_size == 0 && c_size == 0) {
cout << a << endl;
return 0;
}
if (k < 0) {
cout << ":(" << endl;
return 0;
}
for (i = index + 1, j = 1; j < k; i++, j++) {
if (b.size() <= c.size()) break;
c.push_back(a[i]);
b.erase(b.begin());
}
if (b != c) {
cout << ":(" << endl;
return 0;
} else {
for (i = 0; i < c_size; i++) {
b.erase(b.begin());
}
for (i = 0; i < index + 1; i++) {
cout << a[i];
}
cout << b;
}
cout << endl;
;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 20;
const long double PI = 3.1415926535897932;
int n;
pair<long double, long double> vec[MAXN], sec[MAXN];
bool mark[MAXN];
bool cmp(pair<long double, long double> a, pair<long double, long double> b) {
pair<long double, long double> center(0, 0);
if (a.first - center.first >= 0 && b.first - center.first < 0) return true;
if (a.first - center.first < 0 && b.first - center.first >= 0) return false;
if (a.first - center.first == 0 && b.first - center.first == 0) {
if (a.second - center.second >= 0 || b.second - center.second >= 0)
return a.second > b.second;
return b.second > a.second;
}
long double det = (a.first - center.first) * (b.second - center.second) -
(b.first - center.first) * (a.second - center.second);
if (det < 0) return true;
if (det > 0) return false;
long double d1 = (a.first - center.first) * (a.first - center.first) +
(a.second - center.second) * (a.second - center.second);
long double d2 = (b.first - center.first) * (b.first - center.first) +
(b.second - center.second) * (b.second - center.second);
return d1 > d2;
}
bool ec(pair<long double, long double> a, pair<long double, long double> b) {
pair<long double, long double> center(0, 0);
if (a.first - center.first >= 0 && b.first - center.first < 0) return false;
if (a.first - center.first < 0 && b.first - center.first >= 0) return false;
if (a.first - center.first == 0 && b.first - center.first == 0) {
if (a.second - center.second >= 0 || b.second - center.second >= 0)
return false;
return false;
}
long double det = (a.first - center.first) * (b.second - center.second) -
(b.first - center.first) * (a.second - center.second);
if (det < 0) return false;
if (det > 0) return false;
return true;
}
long double cal(int a, int b) {
long double ret =
(vec[a].first - vec[b].first) * (vec[a].first - vec[b].first);
ret += (vec[a].second - vec[b].second) * (vec[a].second - vec[b].second);
return sqrt(ret);
}
long double get(int b, int c, int a = n) {
long double ret = acos(
(cal(a, b) * cal(a, b) + cal(a, c) * cal(a, c) - cal(b, c) * cal(b, c)) /
(cal(a, b) * cal(a, c) * (long double)2.0));
long long t = vec[b].first * vec[c].second - vec[b].second * vec[c].first;
if (t == 0) {
if (b < c) return ret * (long double)180.0 / PI;
return (long double)360.0 - ret * (long double)180 / PI;
}
if (t <= 0) return ret * (long double)180.0 / PI;
return (long double)360.0 - ret * (long double)180 / PI;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
cin >> n;
for (int i = 0; i < n; i++) cin >> vec[i].first >> vec[i].second;
int zz = vec[0].first;
sort(vec, vec + n, cmp);
for (int i = 1; i < n; i++)
if (ec(vec[i - 1], vec[i])) mark[i - 1] = 1;
int g = 0;
for (int i = 0; i < n; i++)
if (mark[i] == 0) sec[g++] = vec[i];
copy(sec, sec + g, vec);
n = g;
if (n == 1) {
cout << 0 << endl;
return 0;
}
vec[n] = {0, 0};
long double ans = 0;
for (int i = 0; i < n; i++) {
long double a = i, b = (i + 1) % n;
ans = max(ans, get(a, b));
}
long double ret = 360.0;
cout << ret - ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, d, h;
int main() {
scanf("%d%d%d", &n, &d, &h);
if (h * 2 < d || (n > 2 && d < 2)) {
printf("-1");
return 0;
}
for (int i = 2; i <= h + 1; ++i) printf("%d %d\n", i - 1, i);
if (h == d)
for (int i = h + 2; i <= n; ++i) printf("2 %d\n", i);
else {
if (h + 1 < n) printf("1 %d\n", h + 2);
for (int i = h + 3; i <= d + 1; ++i) printf("%d %d\n", i - 1, i);
for (int i = d + 2; i <= n; ++i) printf("1 %d\n", i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int a[100000 + 350 + 5], b[100000 + 350 + 5], u[100000 + 350 + 5],
pa[100000 + 350 + 5], pb[100000 + 350 + 5];
int ra[100000 + 5], rb[100000 + 5], ca[100000 + 5], cb[100000 + 5],
usa[100000 + 350 + 5], usb[100000 + 350 + 5];
long long sa[100000 + 350 + 5], sb[100000 + 350 + 5], ans[100000 + 5];
bool cmpa(int x, int y) { return a[x] < a[y]; }
bool cmpb(int x, int y) { return b[x] < b[y]; }
void build(int x) {
ans[x] = 0;
for (int i = x; i < x + 350; ++i)
pa[i] = pb[i] = i,
ans[x] += (u[i] = a[i] < 1000000001 && b[i] < 1000000001) ? a[i] + b[i] : 0;
sort(pa + x, pa + x + 350, cmpa);
sort(pb + x, pb + x + 350, cmpb);
ra[x] = rb[x] = x + 350 - 1;
ca[x] = a[pa[x + 350 - 1]];
cb[x] = b[pb[x + 350 - 1]];
for (int i = x + 350; i-- > x;)
usa[i] = (i + 1 < x + 350 ? usa[i + 1] : 0) + u[pa[i]],
sa[i] = (i + 1 < x + 350 ? sa[i + 1] : 0) + u[pa[i]] * a[pa[i]],
usb[i] = (i + 1 < x + 350 ? usb[i + 1] : 0) + u[pb[i]],
sb[i] = (i + 1 < x + 350 ? sb[i + 1] : 0) + u[pb[i]] * b[pb[i]];
}
void rebuild(int x) {
for (int i = ra[x]; i < x + 350; ++i) a[pa[i]] = ca[x];
for (int i = rb[x]; i < x + 350; ++i) b[pb[i]] = cb[x];
}
void mark(int x, int z) {
int l, r, mid, res = 0;
if (z > 0) {
if (z >= ca[x]) return;
for (l = x, r = ra[x] - 1; l <= r;)
if (z < a[pa[mid = l + r >> 1]])
res = mid, r = mid - 1;
else
l = mid + 1;
if (res) ans[x] += 1LL * z * (usa[res] - usa[ra[x]]) - sa[res] + sa[ra[x]];
ans[x] += 1LL * usa[ra[x]] * (z - ca[x]);
ra[x] = res ? res : ra[x];
ca[x] = z;
} else {
if ((z = -z) >= cb[x]) return;
for (l = x, r = rb[x] - 1; l <= r;)
if (z < b[pb[mid = l + r >> 1]])
res = mid, r = mid - 1;
else
l = mid + 1;
if (res) ans[x] += 1LL * z * (usb[res] - usb[rb[x]]) - sb[res] + sb[rb[x]];
ans[x] += 1LL * usb[rb[x]] * (z - cb[x]);
rb[x] = res ? res : rb[x];
cb[x] = z;
}
}
int main() {
int q = read(), t, l, r, x, i, j, lk, rk;
for (i = 1; i < 100000; ++i) a[i] = b[i] = 1000000001;
for (i = 1; i < 100000; i += 350) build(i);
while (q--) {
t = read();
l = read();
r = read() - 1;
lk = (l - 1) / 350 * 350 + 1;
rk = (r - 1) / 350 * 350 + 1;
if (t == 1) {
x = read();
rebuild(lk);
if (lk != rk) rebuild(rk);
for (i = l; i < lk + 350 && i <= r; ++i)
if (x > 0)
a[i] = min(a[i], x);
else
b[i] = min(b[i], -x);
if (lk != rk)
for (i = r; i >= rk; --i)
if (x > 0)
a[i] = min(a[i], x);
else
b[i] = min(b[i], -x);
build(lk);
if (lk != rk) build(rk);
for (i = lk + 350; i < rk; i += 350)
if (x > 0 && ca[i] == 1000000001) {
rebuild(i);
for (j = i; j < i + 350; ++j) a[j] = min(a[j], x);
build(i);
} else if (x < 0 && cb[i] == 1000000001) {
rebuild(i);
for (j = i; j < i + 350; ++j) b[j] = min(b[j], -x);
build(i);
} else
mark(i, x);
} else {
long long res = 0;
rebuild(lk);
if (lk != rk) rebuild(rk);
for (i = l; i < lk + 350 && i <= r; ++i)
res += a[i] < 1000000001 && b[i] < 1000000001 ? a[i] + b[i] : 0;
if (lk != rk)
for (i = r; i >= rk; --i)
res += a[i] < 1000000001 && b[i] < 1000000001 ? a[i] + b[i] : 0;
build(lk);
if (lk != rk) build(rk);
for (i = lk + 350; i < rk; i += 350) res += ans[i];
printf("%I64d\n", res);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
int b[n];
vector<int> v1;
vector<int> v2;
for (int i = 0; i < n; i++) {
cin >> a[i];
v1.push_back(a[i]);
}
for (int i = 0; i < n; i++) {
cin >> b[i];
v2.push_back(b[i]);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
if (v1 == v2) {
map<pair<int, int>, int> has1;
map<pair<int, int>, int> has2;
for (int i = 0; i < n / 2; i++) {
has1[{a[i], a[n - i - 1]}]++;
has1[{a[n - i - 1], a[i]}]++;
has2[{b[i], b[n - i - 1]}]++;
has2[{b[n - i - 1], b[i]}]++;
}
if (has1 == has2) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
} else {
cout << "No" << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char sir[10005];
int frecv[30][5005][30], n, nrpozd[5005];
long double prob;
vector<int> poz[30];
int main() {
int i, j, maxi;
cin >> sir;
n = strlen(sir);
for (i = n; i <= 2 * n - 1; i++) sir[i] = sir[i - n];
sir[2 * n] = 0;
for (i = 0; i < n; i++) {
for (j = i; j <= i + n - 1; j++) frecv[sir[i] - 'a'][j - i][sir[j] - 'a']++;
poz[sir[i] - 'a'].push_back(i);
}
for (i = 0; i <= 25; i++) {
for (j = 1; j < n; j++) nrpozd[j] = 0;
maxi = 0;
for (j = 1; j < n; j++) {
for (auto it = poz[i].begin(); it != poz[i].end(); ++it)
if (frecv[i][j][sir[j + (*it)] - 'a'] == 1) nrpozd[j]++;
maxi = max(maxi, nrpozd[j]);
}
prob += maxi;
}
prob /= n;
cout << fixed << setprecision(10) << prob;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve(int n, int k1, int k2) {
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < k1; i++) {
if (v[i] == n) {
cout << "YES\n";
return;
}
}
cout << "NO\n";
}
int main() {
long t;
cin >> t;
while (t--) {
int n, k1, k2;
cin >> n >> k1 >> k2;
solve(n, k1, k2);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int num[150000];
void Sum(int i, int op, int n, int &sum) {
if (i != op && i > 0 && i <= n && op > 0 && op <= n) {
swap(num[i], num[op]);
if ((i & 1) && (op & 1)) {
if ((i > 1 && num[i] < num[i - 1] || i == 1) &&
(i < n && num[i] < num[i + 1] || i == n) &&
(op == 1 || op > 1 && num[op] < num[op - 1]) &&
(op == n || op < n && num[op] < num[op + 1]))
sum++;
} else if (!(i & 1) && (op & 1)) {
if ((i > 1 && num[i] > num[i - 1] || i == 1) &&
(i < n && num[i] > num[i + 1] || i == n) &&
(op == 1 || op > 1 && num[op] < num[op - 1]) &&
(op == n || op < n && num[op] < num[op + 1]))
sum++;
} else if ((i & 1) && !(op & 1)) {
if ((i > 1 && num[i] < num[i - 1] || i == 1) &&
(i < n && num[i] < num[i + 1] || i == n) &&
(op == 1 || op > 1 && num[op] > num[op - 1]) &&
(op == n || op < n && num[op] > num[op + 1]))
sum++;
} else {
if ((i > 1 && num[i] > num[i - 1] || i == 1) &&
(i < n && num[i] > num[i + 1] || i == n) &&
(op == 1 || op > 1 && num[op] > num[op - 1]) &&
(op == n || op < n && num[op] > num[op + 1]))
sum++;
}
swap(num[i], num[op]);
}
}
void Solve(int n, int minx[], int mins, int &sum) {
if (mins == 0) {
int op = minx[0];
for (int i = 1; i <= n; i++) Sum(i, op, n, sum);
op++;
if (op <= n) {
for (int i = 1; i <= n; i++) Sum(i, op, n, sum);
}
int sum1 = sum;
Sum(minx[0], minx[0] + 1, n, sum);
if (sum1 < sum) sum -= 2;
} else if (mins == 1) {
if (minx[0] + 1 == minx[1]) {
Sum(minx[0], minx[1] + 1, n, sum);
for (int i = 1; i <= n; i++) Sum(i, minx[1], n, sum);
} else {
Sum(minx[0], minx[1], n, sum);
Sum(minx[0], minx[1] + 1, n, sum);
Sum(minx[0] + 1, minx[1], n, sum);
Sum(minx[0] + 1, minx[1] + 1, n, sum);
}
} else if (mins == 2) {
if (minx[0] + 1 == minx[1] && minx[1] + 1 == minx[2]) {
Sum(minx[0], minx[2], n, sum);
Sum(minx[1], minx[2], n, sum);
Sum(minx[1], minx[2] + 1, n, sum);
} else if (minx[0] + 1 == minx[1]) {
Sum(minx[1], minx[2], n, sum);
Sum(minx[1], minx[2] + 1, n, sum);
} else if (minx[1] + 1 == minx[2]) {
Sum(minx[0], minx[2], n, sum);
Sum(minx[0] + 1, minx[2], n, sum);
}
} else if (minx[0] + 1 == minx[1] && minx[2] + 1 == minx[3]) {
Sum(minx[1], minx[3], n, sum);
}
}
int main() {
int n;
while (~scanf("%d", &n) && n) {
int sum = 0;
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
int minx[110], mins = -1;
for (int i = 1; i <= n - 1; i++) {
if (i & 1) {
if (num[i] >= num[i + 1] && mins < 100) minx[++mins] = i;
} else {
if (num[i] <= num[i + 1] && mins < 100) minx[++mins] = i;
}
}
if (mins >= 4 || mins < 0)
printf("0\n");
else {
Solve(n, minx, mins, sum);
printf("%d\n", sum);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, long long> > graph[200000 + 10];
vector<int> indexx[200000 + 10];
long long baseArray[200000 + 10];
int chainNo, chainInd[200000 + 10], chainHead[200000 + 10],
posInBase[200000 + 10], ptr;
int depth[200000 + 10], parent[30][200000 + 10], otherEnd[200000 + 10],
subsize[200000 + 10];
long long tree[4 * 200000 + 10], lazy[4 * 200000 + 10], dist[200000 + 10];
long long val[200000 + 10];
int N;
void buildst(int node, int start, int end) {
if (start == end) {
tree[node] = baseArray[start];
} else {
int mid = (start + end) / 2;
buildst(2 * node, start, mid);
buildst(2 * node + 1, mid + 1, end);
tree[node] = tree[2 * node] + tree[2 * node + 1];
}
}
void updatest(int node, int start, int end, int l, int r, long long val) {
if (lazy[node] != 0) {
tree[node] += (end - start + 1) * lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start > end or start > r or end < l) return;
if (start >= l and end <= r) {
tree[node] += (end - start + 1) * val;
if (start != end) {
lazy[node * 2] += val;
lazy[node * 2 + 1] += val;
}
return;
}
int mid = (start + end) / 2;
updatest(node * 2, start, mid, l, r, val);
updatest(node * 2 + 1, mid + 1, end, l, r, val);
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
long long queryst(int node, int start, int end, int l, int r) {
if (start > end or start > r or end < l) return 0;
if (lazy[node] != 0) {
tree[node] += (end - start + 1) * lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start >= l and end <= r) return tree[node];
int mid = (start + end) / 2;
long long p1 = queryst(node * 2, start, mid, l, r);
long long p2 = queryst(node * 2 + 1, mid + 1, end, l, r);
return (p1 + p2);
}
void dfs(int u, int p, long long d) {
subsize[u] = 1;
dist[u] = d;
for (int i = 0; i < graph[u].size(); i++) {
pair<int, long long> v = graph[u][i];
if (p != v.first) {
otherEnd[indexx[u][i]] = v.first;
parent[0][v.first] = u;
depth[v.first] = depth[u] + 1;
dfs(v.first, u, d + v.second);
subsize[u] += subsize[v.first];
}
}
}
void pre() {
dfs(0, -1, 0);
for (int i = 1; i < 30; i++) {
for (int j = 0; j < N; j++) {
parent[i][j] = parent[i - 1][parent[i - 1][j]];
}
}
}
int getParent(int u, int k) {
for (int i = 0; i < 30; i++) {
if (k & 1) {
u = parent[i][u];
}
k >>= 1;
}
return u;
}
int lca(int u, int v) {
if (depth[v] > depth[u]) swap(u, v);
u = getParent(u, depth[u] - depth[v]);
if (u == v) return u;
for (int i = 30 - 1; i >= 0; i--) {
if (parent[i][u] != parent[i][v]) {
u = parent[i][u];
v = parent[i][v];
}
}
return parent[0][u];
}
long long queryup(int u, int v) {
if (u == v) return queryst(1, 1, ptr, posInBase[u], posInBase[u]);
int act, uchain, vchain = chainInd[v], ans = -1;
while (1) {
uchain = chainInd[u];
if (uchain == vchain) {
if (u == v) break;
act = queryst(1, 1, ptr, posInBase[v], posInBase[u]);
ans = max(ans, act);
break;
}
act = queryst(1, 1, ptr, posInBase[chainHead[uchain]], posInBase[u]);
ans = max(ans, act);
u = chainHead[uchain];
u = parent[0][u];
}
return ans;
}
void updateup(int u, int v) {
if (u == v) {
updatest(1, 1, ptr, posInBase[u], posInBase[u], 1);
return;
}
int uchain, vchain = chainInd[v];
while (1) {
uchain = chainInd[u];
if (uchain == vchain) {
if (u == v) break;
updatest(1, 1, ptr, posInBase[v], posInBase[u], 1);
break;
}
updatest(1, 1, ptr, posInBase[chainHead[uchain]], posInBase[u], 1);
u = chainHead[uchain];
u = parent[0][u];
}
}
void change(int u, int v) {
int w = lca(u, v);
long long val = queryup(w, w);
updateup(u, w);
updateup(v, w);
long long nuevo = queryup(w, w);
if (val + 2 == nuevo) updatest(1, 1, ptr, posInBase[w], posInBase[w], -1);
}
void hld(int u, int cost, int p) {
if (chainHead[chainNo] == -1) {
chainHead[chainNo] = u;
}
chainInd[u] = chainNo;
posInBase[u] = ptr;
baseArray[ptr++] = cost;
int sc = -1;
for (auto &v : graph[u]) {
if (v.first != p) {
if (sc == -1 || subsize[sc] < subsize[v.first]) {
sc = v.first;
}
}
}
if (sc != -1) {
hld(sc, cost, u);
}
for (auto &v : graph[u]) {
if (v.first != p && v.first != sc) {
chainNo++;
hld(v.first, cost, u);
}
}
}
bool can(int u, int v, long long c) { return dist[u] - dist[v] <= c; }
int u, v, c, Q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N + 10; i++) {
graph[i].clear();
indexx[i].clear();
chainHead[i] = -1;
}
for (int i = 0; i < N; i++) cin >> val[i];
for (int i = 0; i < N - 1; i++) {
cin >> u >> c;
u--;
graph[u].push_back({i + 1, c});
indexx[u].push_back(i);
graph[i + 1].push_back({u, c});
indexx[i + 1].push_back(i);
}
ptr = 1;
chainNo = 0;
pre();
hld(0, 0, -1);
ptr--;
buildst(1, 1, ptr);
for (int i = 1; i < N; i++) {
int ini = 0, fin = depth[i] + 1;
while (ini < fin) {
int mit = (ini + fin) >> 1;
if (can(i, getParent(i, mit), val[i]))
ini = mit + 1;
else
fin = mit;
}
if (can(i, getParent(i, ini - 1), val[i]) && getParent(i, ini - 1) != i) {
change(getParent(i, ini - 1), parent[0][i]);
}
}
for (int i = 0; i < N; i++) {
if (i) cout << " ";
cout << queryup(i, i);
}
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 2e5 + 10, MD = 1e9 + 7, SQ = 2200;
long long n, m, a[MX], ans[MX], q, b[MX], cnt[MX], le, ri, tim, num[MX];
vector<pair<pair<long long, long long>, pair<long long, long long> > > query;
vector<long long> v;
pair<long long, long long> change[MX], reverse_change[MX];
void Add(long long x) {
cnt[num[a[x]]]--;
num[a[x]]++;
cnt[num[a[x]]]++;
}
void Remove(long long x) {
cnt[num[a[x]]]--;
num[a[x]]--;
cnt[num[a[x]]]++;
}
void Change(long long x, long long y) {
if (x < le || x > ri) {
a[x] = y;
return;
}
Remove(x);
a[x] = y;
Add(x);
}
bool CMP(pair<pair<long long, long long>, pair<long long, long long> > A,
pair<pair<long long, long long>, pair<long long, long long> > B) {
if (A.first.first / SQ != B.first.first / SQ)
return A.first.first < B.first.first;
if (A.first.second / SQ != B.first.second / SQ)
return A.first.second < B.first.second;
if ((A.first.second / SQ) % 2)
return A.second.first < B.second.first;
else
return B.second.first < A.second.first;
}
int32_t main() {
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
v.push_back(a[i]);
}
long long tmp = 0, tmp2 = 0;
for (long long i = 1; i <= q; i++) {
long long t, l, r;
scanf("%lld%lld%lld", &t, &l, &r);
if (t == 2) {
tmp++;
change[tmp] = {l, r};
v.push_back(r);
} else {
tmp2++;
query.push_back({{l, r}, {tmp, tmp2}});
}
}
sort(query.begin(), query.end(), CMP);
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
for (long long i = 1; i <= n; i++)
a[i] = (upper_bound(v.begin(), v.end(), a[i]) - v.begin()), b[i] = a[i];
for (long long i = 1; i <= tmp; i++) {
change[i].second =
(upper_bound(v.begin(), v.end(), change[i].second) - v.begin());
reverse_change[i].first = change[i].first;
reverse_change[i].second = b[change[i].first];
b[change[i].first] = change[i].second;
}
for (auto pa : query) {
long long l = pa.first.first, r = pa.first.second, t = pa.second.first,
id = pa.second.second;
while (ri < r) ri++, Add(ri);
while (le > l) le--, Add(le);
while (ri > r) Remove(ri), ri--;
while (le < l) Remove(le), le++;
while (tim < t) tim++, Change(change[tim].first, change[tim].second);
while (tim > t)
Change(reverse_change[tim].first, reverse_change[tim].second), tim--;
for (long long i = 1; i < 600; i++) {
if (cnt[i] == 0) {
ans[id] = i;
break;
}
}
}
for (long long i = 1; i <= tmp2; i++) printf("%lld\n", ans[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
int q;
long long sum[35];
char opt[5];
multiset<long long> s[35];
int main() {
read(q);
while (q--) {
long long v, x = 0, val = 0, ans = 0;
scanf("%s", opt), read(v);
while ((1 << (x + 1)) <= v) x++;
if (opt[0] == '+')
s[x].insert(v), sum[x] += v;
else
s[x].erase(s[x].find(v)), sum[x] -= v;
for (int i = 0; i <= 30; ++i)
ans += s[i].size() - (*s[i].begin() > 2 * val), val += sum[i];
printf("%lld\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 2e5 + 1;
long long N, T, A[MXN];
bool cnt[MXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> T;
priority_queue<pair<long long, long long> > pq;
for (int x = 0, ThxDem = N; x < ThxDem; ++x) {
cin >> A[x];
A[x] = max(0LL, A[x] - (x + 1LL));
pq.push({-A[x], x});
}
int ans = 0, tmp = 0, i = N - 1;
while (!pq.empty()) {
pair<long long, long long> tmpP = pq.top();
pq.pop();
while (i >= 0 && i + 1 - tmpP.first >= T) tmp -= cnt[i], i--;
if (tmpP.second <= i) cnt[tmpP.second] = 1, tmp++;
ans = max(ans, tmp);
}
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int Search(string pat, string txt) {
int n = txt.size();
int m = pat.size();
for (int i = 0; i <= n - m; i++) {
int j;
for (j = 0; j < m; j++) {
if (txt[i + j] != pat[j]) {
break;
}
}
if (j == m) {
return i;
}
}
return -1;
}
int findFirst(const std::vector<long long int> &array, int key, int low,
int high) {
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (key == array[mid]) {
ans = mid;
high = mid - 1;
} else if (key > array[mid])
low = mid + 1;
else
high = mid - 1;
}
return ans;
}
int findLast(const std::vector<long long int> &array, int key, int low,
int high) {
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (key == array[mid]) {
ans = mid;
low = mid + 1;
} else if (key > array[mid])
low = mid + 1;
else
high = mid - 1;
}
return ans;
}
int d, x, y;
void extendedEuclid(int a, int b) {
if (b == 0) {
d = 1;
x = 1;
y = 0;
} else {
extendedEuclid(b, a % b);
int temp = x;
x = y;
y = temp - (a / b) * y;
}
}
bool isPowerOfTwo(long long int x) { return (x && !(x & (x - 1))); }
int count_one_in_Bin(long long int n) {
int ans = 0;
while (n) {
n = n & (n - 1);
ans++;
}
return ans;
}
int Len_dec(long long int n) {
int ans = 0;
while (n > 0) {
n /= 10;
ans++;
}
return ans;
}
int Len_Bin(long long int n) {
int ans = 0;
while (n > 0) {
n /= 2;
ans++;
}
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
for (int tc = 0; tc < t; tc++) {
int n, m;
cin >> n >> m;
vector<int> arr(n), brr(m);
for (int i1 = 0; i1 < n; i1++) cin >> arr[i1];
for (int i1 = 0; i1 < m; i1++) cin >> brr[i1];
int pos = 0, cnt = 0;
for (int i = 0; i < n && pos < m; i++) {
if (brr[pos] >= arr[i]) {
cnt++;
pos++;
}
}
cout << cnt << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long double DP[202][202][202];
long double P[202];
int A[202];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, l, k;
cin >> n >> l >> k;
k = min(k, n);
for (int i = 1; i <= n; i++) cin >> P[i], P[i] /= 100.0;
for (int i = 1; i <= n; i++) cin >> A[i];
DP[1][0][k] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j < i; j++)
for (int z = k; z <= n; z++) {
DP[i + 1][j][z] += DP[i][j][z] * (1.0 - P[i]);
if (A[i] == -1)
DP[i + 1][j + 1][z] += DP[i][j][z] * P[i];
else
DP[i + 1][j + 1][min(n, z + A[i] + 1)] += DP[i][j][z] * P[i];
}
long double ats = 0;
for (int j = l; j <= n; j++)
for (int z = max(k, j); z <= n; z++) ats += DP[n + 1][j][z];
cout << setprecision(13) << fixed << ats;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 2 * 100000 + 5;
int N;
vector<int> graph[NMAX];
int deg[NMAX];
int whatLen[NMAX];
bool out[NMAX];
queue<int> q;
int main() {
ios_base ::sync_with_stdio(false);
cin >> N;
for (int i = 1; i < N; ++i) {
int a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
deg[a]++;
deg[b]++;
}
for (int i = 1; i <= N; ++i)
if (deg[i] == 1) q.push(i);
int rem = N;
int node;
while (!q.empty()) {
node = q.front();
rem--;
q.pop();
if (!rem) break;
bool same = true;
int val = 0;
for (auto it : graph[node])
if (out[it]) {
if (val == 0)
val = whatLen[it];
else if (val != whatLen[it]) {
same = false;
break;
}
}
if (!same) {
cout << "-1\n";
return 0;
}
whatLen[node] = 1 + val;
out[node] = true;
deg[node]--;
for (auto it : graph[node])
if (!out[it]) {
deg[it]--;
if (deg[it] == 1) q.push(it);
}
}
vector<int> vals;
for (auto it : graph[node])
if (out[it]) vals.push_back(whatLen[it]);
sort(vals.begin(), vals.end());
vals.resize(unique(vals.begin(), vals.end()) - vals.begin());
if (vals.size() > 2) {
cout << "-1\n";
return 0;
}
int sum = 0;
for (auto it : vals) sum += it;
while (sum % 2 == 0) sum /= 2;
cout << sum << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
int l[1200100], r[1200100];
int c[1200100], d[1200100];
struct xxx {
long long ls, rs, sum, s;
} t[1200100];
int st[1200100], top = 0;
xxx pushup(xxx a, xxx b) {
xxx c;
c.ls = std::max(a.ls, a.s + b.ls);
c.rs = std::max(b.rs, b.s + a.rs);
c.sum = std::max(std::max(a.sum, b.sum), a.rs + b.ls);
c.s = a.s + b.s;
return c;
}
void build(int x, int L, int R) {
if (L == R) {
t[x].ls = t[x].rs = t[x].sum = t[x].s = c[L];
return;
}
int mid = L + R >> 1;
build(x << 1, L, mid);
build(x << 1 | 1, mid + 1, R);
t[x] = pushup(t[x << 1], t[x << 1 | 1]);
}
xxx query(int x, int L, int R, int l, int r) {
if (L == l && R == r) return t[x];
int mid = L + R >> 1;
if (r <= mid)
return query(x << 1, L, mid, l, r);
else if (l > mid)
return query(x << 1 | 1, mid + 1, R, l, r);
else
return pushup(query(x << 1, L, mid, l, mid),
query(x << 1 | 1, mid + 1, R, mid + 1, r));
}
int main() {
long long ans = 0;
int n, a;
scanf("%d%d", &n, &a);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &d[i], &c[i]);
c[i] = a - c[i];
ans = std::max(ans, (long long)c[i]);
}
for (int i = 1; i < n; i++) d[i] = d[i + 1] - d[i];
for (int i = 1; i < n; i++) {
while (top && d[st[top]] <= d[i]) top--;
l[i] = st[top] + 1;
st[++top] = i;
}
top = 0;
for (int i = 1; i < n; i++) {
while (top && d[st[top]] < d[i]) r[st[top--]] = i - 1;
st[++top] = i;
}
while (top) r[st[top--]] = n - 1;
build(1, 1, n);
for (int i = 1; i < n; i++)
ans = std::max(ans, query(1, 1, n, l[i], r[i] + 1).sum - 1ll * d[i] * d[i]);
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int cal(int x, int c) {
int l = -1e9, r = 1e9;
int ans = -1e9;
while (l <= r) {
int mid = l + r >> 1;
if (mid * 2 + c <= x) {
ans = max(ans, mid);
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
int main() {
int x1, x2, y1, y2;
while (~scanf("%d%d%d%d", &x1, &y1, &x2, &y2)) {
if ((y1 - x1) % 2) {
y1--;
y2--;
}
long long ans;
int t = (x2 - x1) / 2;
if (x1 % 2)
ans = (long long)(cal(y2, 1) - cal(y1 - 1, 1)) * (t + 1) +
(long long)(cal(y2, 0) - cal(y1 - 1, 0)) * t;
else
ans = (long long)(cal(y2, 1) - cal(y1 - 1, 1)) * t +
(long long)(cal(y2, 0) - cal(y1 - 1, 0)) * (t + 1);
printf("%I64d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve();
void file_i_o() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long n, m, k, p[200000], j, c, u, t, l;
int main(int argc, char const *argv[]) {
clock_t begin = clock();
file_i_o();
solve();
return 0;
}
void solve() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) cin >> p[i];
while (j < m) {
l = t;
u = ((p[j] - l - 1) / k + 1) * k;
while (p[j] - l <= u && j < m) {
t++;
j++;
}
c++;
}
cout << c;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c;
cin >> a >> b >> c;
int inf = 0x3f3f3f3f;
int ans = inf;
for (int i = a; i <= 100; i++) {
for (int j = b; j <= 100; j++) {
for (int k = c; k <= 100; k++) {
if (i + j > k && i + k > j && j + k > i)
ans = min(ans, i - a + j - b + k - c);
}
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, s, a[200020], p[200020];
void solve() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
int ans = 0;
if (a[s] != 0) ans++;
for (int i = 1; i <= n; i++)
if (i != s) {
p[a[i]]++;
}
for (int i = 1, c = n - 1; i < n; i++) {
if (p[i] > 0) {
c -= p[i];
if (c <= 0) break;
} else {
c--;
ans++;
if (c == 0) break;
}
}
printf("%d", ans);
}
int main() {
int Tc = 1;
for (int tc = 1; tc <= Tc; tc++) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
char s[1000005];
scanf("%s", s);
int len = strlen(s), i, nb = 0, start = -1, end = -1;
long long ans = 0, b = 0;
for (i = 0; i < len; i++) {
if (s[i] == 'a' && start == -1) {
start = i;
}
if (s[i] == 'b') {
end = i;
}
}
if (start == -1 || end == -1 || start > end) {
ans = 0;
} else {
for (i = end; i >= start; i--) {
if (s[i] == 'b') {
nb++;
b++;
}
if (s[i] == 'a') {
b = (b * 2) % 1000000007;
}
}
}
ans = b - nb;
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
double dis[N], ang[N];
int tree[2 * N], n;
long long k;
pair<double, int> a[2 * N];
pair<int, int> b[N];
void add(int x, int k) {
while (x <= 2 * n) {
tree[x] += k;
x += x & -x;
}
}
int find(int x) {
int ans = 0;
while (x > 0) {
ans += tree[x];
x -= x & -x;
}
return ans;
}
bool check(double r) {
int m = 0;
long long sum = 0;
for (int i = 1; i <= n; i++)
if (r < dis[i]) {
double s = acos(r / dis[i]);
double s1 = ang[i] - s, s2 = ang[i] + s;
if (s1 < 0) s1 += 2 * 3.14159265358979323846;
if (s2 > 2 * 3.14159265358979323846) s2 -= 2 * 3.14159265358979323846;
if (s1 > s2) swap(s1, s2);
a[m++] = {s1, -i};
a[m++] = {s2, i};
}
if (m) {
sort(a, a + m);
for (int i = 1; i <= n; i++) b[i] = {1, 0};
for (int i = 0; i < m; i++) {
if (a[i].second > 0)
b[a[i].second].second = i + 1;
else
b[-a[i].second].first = i + 1;
}
m = 0;
for (int i = 1; i <= n; i++)
if (b[i].first < b[i].second) {
b[m++] = b[i];
}
sort(b, b + m);
memset(tree, 0, sizeof tree);
for (int i = m - 1; i >= 0; i--) {
sum += find(b[i].second);
add(b[i].first, 1);
add(b[i].second, -1);
}
}
return ((long long)n * (n - 1) / 2 - sum >= k);
}
int main() {
scanf("%d %lld", &n, &k);
int x, y;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x, &y);
dis[i] = sqrt(x * x + y * y);
ang[i] = atan2(y, x);
if (ang[i] < 0) ang[i] += 2 * 3.14159265358979323846;
}
double l = 0, r = 20000;
while (r - l > 1e-8) {
double mid = (r + l) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.8lf\n", l);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 155000;
int n, m, p;
int pei[N];
struct node {
node *fa, *lson, *rson;
int minz, tot;
int val, rank;
} tree[N];
node *root;
bool cmp(int x, int y) { return (x > y); }
int getint() {
int res = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while ('0' <= ch && ch <= '9') {
res = res * 10 + ch - '0';
ch = getchar();
}
return res;
}
int erfen(int l, int r, int key) {
if (l == r) return l;
int mid = (l + r + 1) >> 1;
if (key + pei[mid] >= p) return erfen(mid, r, key);
return erfen(l, mid - 1, key);
}
void replace(node *x) {
int lt;
if (x->lson)
lt = x->lson->tot;
else
lt = 0;
x->tot = 1;
x->minz = x->rank - lt;
if (x->lson) {
x->tot += x->lson->tot;
x->minz = min(x->minz, x->lson->minz);
}
if (x->rson) {
x->tot += x->rson->tot;
x->minz = min(x->minz, x->rson->minz - lt - 1);
}
}
void zig(node *x) {
node *y = x->fa;
if (y->fa) {
if (y->fa->lson == y)
y->fa->lson = x;
else
y->fa->rson = x;
}
if (x->rson) x->rson->fa = y;
x->fa = y->fa;
y->fa = x;
y->lson = x->rson;
x->rson = y;
replace(y);
replace(x);
}
void zag(node *x) {
node *y = x->fa;
if (y->fa) {
if (y->fa->lson == y)
y->fa->lson = x;
else
y->fa->rson = x;
}
if (x->lson) x->lson->fa = y;
x->fa = y->fa;
y->fa = x;
y->rson = x->lson;
x->lson = y;
replace(y);
replace(x);
}
void splay(node *x, node *key) {
if (x == key) return;
while (1) {
node *y = x->fa;
if (y == key) {
if (y->lson == x)
zig(x);
else
zag(x);
return;
}
node *z = y->fa;
if (z->lson == y) {
if (y->lson == x) {
zig(y);
zig(x);
} else {
zag(x);
zig(x);
}
} else {
if (y->lson == x) {
zig(x);
zag(x);
} else {
zag(y);
zag(x);
}
}
if (z == key) return;
}
}
void add(node *x, node *key) {
if (x->val < key->val) {
if (x->rson)
add(x->rson, key);
else {
x->rson = key;
key->fa = x;
}
} else {
if (x->lson)
add(x->lson, key);
else {
x->lson = key;
key->fa = x;
}
}
replace(x);
}
void insert(node *x) {
add(root, x);
splay(x, root);
root = x;
}
void del(node *x) {
splay(x, root);
root = x;
if (!(x->lson)) {
root = x->rson;
root->fa = 0;
return;
}
if (!(x->rson)) {
root = x->lson;
root->fa = 0;
return;
}
node *s = x->lson;
while (s->rson) s = s->rson;
splay(s, x->lson);
node *t = x->rson;
s->rson = t;
s->fa = 0;
t->fa = s;
root = s;
replace(s);
}
void GetData() {
int i;
n = getint();
m = getint();
p = getint();
for (i = 1; i <= m; i++) pei[i] = getint();
sort(pei + 1, pei + m + 1, cmp);
for (i = 1; i <= n; i++) {
tree[i].val = getint();
tree[i].rank = erfen(0, m, tree[i].val);
tree[i].minz = tree[i].rank;
tree[i].tot = 1;
}
root = tree + 1;
for (i = 2; i <= m; i++) insert(tree + i);
}
void Do() {
int ans;
if (root->minz > 0)
ans = 1;
else
ans = 0;
int i;
for (i = m + 1; i <= n; i++) {
insert(tree + i);
del(tree + i - m);
if (root->minz > 0) ans++;
}
printf("%d\n", ans);
}
int main() {
GetData();
Do();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string a1, a2, a3, a4, a5, a6, a7, a8;
int ans;
int main() {
cin >> a1 >> a2 >> a3 >> a4 >> a5 >> a6 >> a7 >> a8;
if (a1[0] == 'B' && a1[1] == 'B' && a1[2] == 'B' && a1[3] == 'B' &&
a1[4] == 'B' && a1[5] == 'B' && a1[6] == 'B' && a1[7] == 'B' &&
a2[0] == 'B' && a2[1] == 'B' && a2[2] == 'B' && a2[3] == 'B' &&
a2[4] == 'B' && a2[5] == 'B' && a2[6] == 'B' && a2[7] == 'B' &&
a4[0] == 'B' && a4[1] == 'B' && a4[2] == 'B' && a4[3] == 'B' &&
a4[4] == 'B' && a4[5] == 'B' && a4[6] == 'B' && a4[7] == 'B' &&
a3[0] == 'B' && a3[1] == 'B' && a3[2] == 'B' && a3[3] == 'B' &&
a3[4] == 'B' && a3[5] == 'B' && a3[6] == 'B' && a3[7] == 'B') {
if (a5[0] == 'B' && a5[1] == 'B' && a5[2] == 'B' && a5[3] == 'B' &&
a5[4] == 'B' && a5[5] == 'B' && a5[6] == 'B' && a5[7] == 'B' &&
a6[0] == 'B' && a6[1] == 'B' && a6[2] == 'B' && a6[3] == 'B' &&
a6[4] == 'B' && a6[5] == 'B' && a6[6] == 'B' && a6[7] == 'B' &&
a7[0] == 'B' && a7[1] == 'B' && a7[2] == 'B' && a7[3] == 'B' &&
a7[4] == 'B' && a7[5] == 'B' && a7[6] == 'B' && a7[7] == 'B' &&
a8[0] == 'B' && a8[1] == 'B' && a8[2] == 'B' && a8[3] == 'B' &&
a8[4] == 'B' && a8[5] == 'B' && a8[6] == 'B' && a8[7] == 'B') {
cout << "8";
return 0;
}
}
if (a1[0] == 'B' && a1[1] == 'B' && a1[2] == 'B' && a1[3] == 'B' &&
a1[4] == 'B' && a1[5] == 'B' && a1[6] == 'B' && a1[7] == 'B') {
ans++;
}
if (a2[0] == 'B' && a2[1] == 'B' && a2[2] == 'B' && a2[3] == 'B' &&
a2[4] == 'B' && a2[5] == 'B' && a2[6] == 'B' && a2[7] == 'B') {
ans++;
}
if (a3[0] == 'B' && a3[1] == 'B' && a3[2] == 'B' && a3[3] == 'B' &&
a3[4] == 'B' && a3[5] == 'B' && a3[6] == 'B' && a3[7] == 'B') {
ans++;
}
if (a4[0] == 'B' && a4[1] == 'B' && a4[2] == 'B' && a4[3] == 'B' &&
a4[4] == 'B' && a4[5] == 'B' && a4[6] == 'B' && a4[7] == 'B') {
ans++;
}
if (a5[0] == 'B' && a5[1] == 'B' && a5[2] == 'B' && a5[3] == 'B' &&
a5[4] == 'B' && a5[5] == 'B' && a5[6] == 'B' && a5[7] == 'B') {
ans++;
}
if (a6[0] == 'B' && a6[1] == 'B' && a6[2] == 'B' && a6[3] == 'B' &&
a6[4] == 'B' && a6[5] == 'B' && a6[6] == 'B' && a6[7] == 'B') {
ans++;
}
if (a7[0] == 'B' && a7[1] == 'B' && a7[2] == 'B' && a7[3] == 'B' &&
a7[4] == 'B' && a7[5] == 'B' && a7[6] == 'B' && a7[7] == 'B') {
ans++;
}
if (a8[0] == 'B' && a8[1] == 'B' && a8[2] == 'B' && a8[3] == 'B' &&
a8[4] == 'B' && a8[5] == 'B' && a8[6] == 'B' && a8[7] == 'B') {
ans++;
}
if (a1[0] == 'B' && a2[0] == 'B' && a3[0] == 'B' && a4[0] == 'B' &&
a5[0] == 'B' && a6[0] == 'B' && a7[0] == 'B' && a8[0] == 'B') {
ans++;
}
if (a1[1] == 'B' && a2[1] == 'B' && a3[1] == 'B' && a4[1] == 'B' &&
a5[1] == 'B' && a6[1] == 'B' && a7[1] == 'B' && a8[1] == 'B') {
ans++;
}
if (a1[2] == 'B' && a2[2] == 'B' && a3[2] == 'B' && a4[2] == 'B' &&
a5[2] == 'B' && a6[2] == 'B' && a7[2] == 'B' && a8[2] == 'B') {
ans++;
}
if (a1[3] == 'B' && a2[3] == 'B' && a3[3] == 'B' && a4[3] == 'B' &&
a5[3] == 'B' && a6[3] == 'B' && a7[3] == 'B' && a8[3] == 'B') {
ans++;
}
if (a1[4] == 'B' && a2[4] == 'B' && a3[4] == 'B' && a4[4] == 'B' &&
a5[4] == 'B' && a6[4] == 'B' && a7[4] == 'B' && a8[4] == 'B') {
ans++;
}
if (a1[5] == 'B' && a2[5] == 'B' && a3[5] == 'B' && a4[5] == 'B' &&
a5[5] == 'B' && a6[5] == 'B' && a7[5] == 'B' && a8[5] == 'B') {
ans++;
}
if (a1[6] == 'B' && a2[6] == 'B' && a3[6] == 'B' && a4[6] == 'B' &&
a5[6] == 'B' && a6[6] == 'B' && a7[6] == 'B' && a8[6] == 'B') {
ans++;
}
if (a1[7] == 'B' && a2[7] == 'B' && a3[7] == 'B' && a4[7] == 'B' &&
a5[7] == 'B' && a6[7] == 'B' && a7[7] == 'B' && a8[7] == 'B') {
ans++;
}
if (a1[8] == 'B' && a2[8] == 'B' && a3[8] == 'B' && a4[8] == 'B' &&
a5[8] == 'B' && a6[8] == 'B' && a7[8] == 'B' && a8[8] == 'B') {
ans++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node *l, *r;
int s, e, v;
Node(int a, int b) : v(a), e(b), s(0), l(0), r(0) {}
Node* L() {
if (l == NULL) {
l = new Node(v * 2, 0);
}
return l;
}
Node* R() {
if (r == NULL) {
r = new Node(v * 2 + 1, 0);
}
return r;
}
void up() { s = e + L()->s + R()->s; }
void add(int m, int h, int q) {
if (v == m) {
e += q;
s += q;
return;
}
if (m >> (h - 2) & 1) {
R()->add(m, h - 1, q);
} else {
L()->add(m, h - 1, q);
}
up();
}
double query(int m) {
double ret;
if (s <= m) {
ret = m;
} else if (L()->s > R()->s) {
ret = (L()->query(max(m, R()->s + e)) + max(L()->s + e, m)) / 2;
} else if (L()->s < R()->s) {
ret = (R()->query(max(m, L()->s + e)) + max(R()->s + e, m)) / 2;
} else {
ret = max(m, L()->s + e);
}
return ret;
}
};
int len(int s, int ret = 0) {
while (s > 0) {
ret++;
s >>= 1;
}
return ret;
}
int main() {
char ch[10];
int n, m;
cin >> n >> m;
Node* rt = new Node(1, 0);
for (int i = 0; i < m; i++) {
scanf("%s", ch);
if (ch[0] == 'a') {
int x, y;
scanf("%d %d", &x, &y);
rt->add(x, len(x), y);
} else {
printf("%.8f\n", rt->query(0));
}
}
}
| 8 |
#include <bits/stdc++.h>
int main() {
int i, j, m[5][5];
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
scanf("%d", &m[i][j]);
if (m[i][j] == 1) printf("%d", abs(i - 2) + abs(j - 2));
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct T {
double x;
long double v, m;
int id;
} q[1000];
bool m1(T A, T B) { return A.x < B.x; }
bool m2(T A, T B) { return A.id < B.id; }
long double t, tt, o, v1, v2;
int n;
long double wh() {
double r = 1000000000;
for (int i = 1; i < n; i++) {
if (q[i - 1].v - q[i].v <= 0) continue;
double e = (q[i].x - q[i - 1].x) / (q[i - 1].v - q[i].v);
if (e >= 0) r = min(r, e);
}
return r;
}
int main() {
cin >> n >> t;
for (int i = 0; i < n; i++) cin >> q[i].x >> q[i].v >> q[i].m;
for (int i = 0; i < n; i++) q[i].id = i;
sort(q, q + n, &m1);
tt = 0;
while (tt + 1e-9 < t) {
o = wh();
if (o + tt <= t) {
for (int i = 0; i < n; i++) q[i].x += q[i].v * o;
for (int i = 1; i < n; i++)
if (fabs(q[i].x - q[i - 1].x) < 1e-8) {
v1 = ((q[i - 1].m - q[i].m) * q[i - 1].v + 2 * q[i].m * q[i].v) /
(q[i - 1].m + q[i].m);
v2 = ((q[i].m - q[i - 1].m) * q[i].v + 2 * q[i - 1].m * q[i - 1].v) /
(q[i - 1].m + q[i].m);
q[i - 1].v = v1;
q[i].v = v2;
}
} else
for (int i = 0; i < n; i++) q[i].x += q[i].v * (t - tt);
tt += o;
}
sort(q, q + n, &m2);
cout.precision(7);
for (int i = 0; i < n; i++) cout << fixed << q[i].x << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N;
int Pow[40];
int A[120000 + 5];
map<int, int> vis;
multiset<int> Num;
int main() {
Pow[0] = 1;
for (int i = 1; i <= 31; i++) Pow[i] = Pow[i - 1] * 2;
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
Num.insert(A[i]);
}
int Ans = 0;
for (int i = 1; i <= N; i++) {
if (vis.count(A[i])) {
Ans += vis[A[i]] - 1;
continue;
}
bool flag = 0;
for (int j = 0; j <= 31; j++) {
int tmp = Pow[j] - A[i];
int k = Num.count(tmp);
if (tmp == A[i] && k == 1) continue;
if (k) {
vis[A[i]] = vis[tmp] = 1;
flag = 1;
break;
}
}
if (!flag) {
Ans++;
vis[A[i]] = 2;
}
}
printf("%d", Ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
char ans[20] = "01001010111001010";
int main() {
int a, b = 1, c = 0;
scanf("%d", &a);
printf("%c\n", ans[a]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string a, b;
cin >> a >> b;
vector<vector<int> > vec(26);
for (int i = 0; i < a.size(); i++) {
vec[a[i] - 'a'].push_back(i);
}
int cnt = 1;
int prev = -1;
int flag = 0;
for (int i = 0; i < b.size(); i++) {
int row = b[i] - 'a';
if (vec[row].size() == 0) {
flag = -1;
break;
}
int ind = upper_bound(vec[row].begin(), vec[row].end(), prev) -
vec[row].begin();
if (ind == vec[row].size()) {
i--;
prev = -1;
cnt++;
} else {
prev = vec[row][ind];
}
}
if (flag == -1)
cout << -1 << endl;
else
cout << cnt << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n + 10];
set<int> vect;
for (long long i = 0; i < n; i++) {
cin >> a[i];
long long x = a[i];
while (x > 0) {
vect.insert(x);
x /= 2;
}
}
long long ans = 1e10;
set<int>::iterator it;
for (it = vect.begin(); it != vect.end(); it++) {
vector<int> cnt;
for (long long j = 0; j < n; j++) {
long long op = 0;
long long x = a[j];
while (x > (*it)) {
x = x / 2;
op += 1;
}
if (x == (*it)) cnt.push_back(op);
}
if (cnt.size() < k) {
continue;
}
sort(cnt.begin(), cnt.end());
ans = min(ans, (long long)accumulate(cnt.begin(), cnt.begin() + k, 0));
}
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 100010;
long long a[MAXN];
long long s[MAXN];
long long euclid(long long a, long long b) {
if (a == 0)
return b;
else
return euclid(b % a, a);
}
int main() {
(ios::sync_with_stdio(false));
int n;
cin >> n;
for (int i = 0; i < (n); ++i) cin >> a[i];
long long left = 0, right = 0;
sort(a, a + n);
for (int i = 0; i < (n); ++i) {
right += (i)*a[i] - left;
left += a[i];
}
long long fac = euclid((long long)n, (left + 2 * right));
cout << (left + 2 * right) / fac << " " << n / fac;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, h, x, ans, i;
int main() {
cin >> n >> h;
for (i = 0; i < n; i++) {
cin >> x;
if (x > h) {
ans++;
}
ans++;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int n, m;
long long t[MAX << 2], tag[MAX << 2];
int sz = 1;
inline void Period(int k, int l, int r, int a, int b, long long x) {
if (a > r || b < l) return;
if (a >= l && b <= r) {
tag[k] = t[k] = x;
return;
}
Period(k << 1, l, r, a, (a + b) >> 1, x);
Period((k << 1) + 1, l, r, ((a + b) >> 1) + 1, b, x);
t[k] = max(t[k << 1], t[(k << 1) + 1]);
}
inline long long Query(int k, int l, int r, int a, int b) {
if (tag[k]) {
t[k] = tag[k];
tag[k << 1] = max(tag[k << 1], tag[k]);
tag[(k << 1) + 1] = max(tag[(k << 1) + 1], tag[k]);
tag[k] = 0;
}
if (a > r || b < l) return 0;
if (a >= l && b <= r) return t[k];
return max(Query(k << 1, l, r, a, (a + b) >> 1),
Query((k << 1) + 1, l, r, ((a + b) >> 1) + 1, b));
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
while (sz < n) sz <<= 1;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
Period(1, i, i, 1, sz, x);
}
cin >> m;
while (m--) {
int x;
long long h;
cin >> x >> h;
long long res = Query(1, 1, x, 1, sz);
cout << res << endl;
Period(1, 1, x, 1, sz, res + h);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
unsigned long long v[100001], t[100001];
unsigned long long prefT[100001];
unsigned long long pref2[200000];
unsigned long long ans[100001];
unsigned long long sum[100001];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &v[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &t[i]);
prefT[0] = 0;
for (int i = 1; i <= n; i++) prefT[i] = prefT[i - 1] + t[i];
for (int i = 1; i <= n; i++) {
int pos =
upper_bound(prefT + i, prefT + n + 1, v[i] + prefT[i - 1]) - prefT;
pref2[i]++;
pref2[pos]--;
unsigned long long ost = v[i] - (prefT[pos - 1] - prefT[i - 1]);
sum[pos] += ost;
}
for (int i = 1; i <= n; i++) {
pref2[i] += pref2[i - 1];
printf("%lld ", sum[i] + pref2[i] * t[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[105];
int a, b, x, y, p1, p2;
bool check(int k1, int k2) {
if (k1 == 0 && k2 == 0) return true;
if (x == 0 && y == 0) {
if (k1 == 0 && k2 == 0) return true;
return false;
}
if (x == 0) {
if (k1 == 0 && (long long)y * k2 > 0 && k2 % y == 0) return true;
return false;
}
if (y == 0) {
if (k2 == 0 && (long long)x * k1 > 0 && k1 % x == 0) return true;
return false;
}
if ((long long)x * k2 == (long long)y * k1 && (long long)x * k1 > 0 &&
(long long)y * k2 > 0 && k1 % x == 0 && k2 % y == 0)
return true;
return false;
}
int main() {
scanf("%d%d%s", &a, &b, s);
x = 0;
y = 0;
for (int i = 0; s[i]; i++) {
if (s[i] == 'L')
x--;
else if (s[i] == 'R')
x++;
else if (s[i] == 'D')
y--;
else
y++;
}
if (check(a, b)) {
puts("Yes");
return 0;
}
int len = strlen(s);
for (int i = len - 1; i >= 0; i--) {
p1 = a, p2 = b;
for (int j = i; j >= 0; j--) {
if (s[j] == 'L')
p1++;
else if (s[j] == 'R')
p1--;
else if (s[j] == 'D')
p2++;
else
p2--;
}
if (check(p1, p2)) {
puts("Yes");
return 0;
}
}
puts("No");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const MAX = 41;
pair<int, int> a[MAX], b[MAX];
int q[MAX];
int n, m;
int get(pair<int, int> a, pair<int, int> b) {
if (a == b) return -1;
if (a.first == b.first) return a.first;
if (a.first == b.second) return a.first;
if (a.second == b.first) return a.second;
if (a.second == b.second) return a.second;
return -1;
}
void solve() {
for (int i = 1; i <= n; i++) {
if (a[i].first > a[i].second) swap(a[i].first, a[i].second);
}
for (int i = 1; i <= m; i++) {
if (b[i].first > b[i].second) swap(b[i].first, b[i].second);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (get(a[i], b[j]) != -1) {
q[get(a[i], b[j])]++;
}
}
}
int cnt = 0;
for (int i = 0; i <= 9; i++) {
if (q[i]) {
cnt++;
while (false) {
};
}
}
assert(cnt > 0);
if (cnt == 1) {
for (int i = 0; i <= 9; i++) {
if (q[i]) {
printf("%d\n", i);
return;
}
}
assert(false);
}
bool f = 1;
for (int i = 1; i <= n; i++) {
set<int> t;
for (int j = 1; j <= m; j++) {
if (get(a[i], b[j]) != -1) {
t.insert(get(a[i], b[j]));
}
}
if ((int)t.size() > 1) f = 0;
}
for (int i = 1; i <= m; i++) {
set<int> t;
for (int j = 1; j <= n; j++) {
if (get(b[i], a[j]) != -1) {
t.insert(get(b[i], a[j]));
}
}
if ((int)t.size() > 1) f = 0;
}
if (f) {
printf("0\n");
return;
}
printf("-1\n");
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &b[i].first, &b[i].second);
}
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long n, m;
int k;
unsigned long long dp[64][2][65];
bool dp2[64][2][65];
unsigned long long f(int b, int x, int c) {
if (b == 64)
return x == 1 ? 0 : (c == k ? 1 : 0);
else if (dp2[b][x][c])
return dp[b][x][c];
unsigned long long ret = 0;
int bit = ((n >> b) & 1);
ret += f(b + 1, bit ? 0 : x, c);
ret += f(b + 1, bit ? x : 1, c + 1);
dp2[b][x][c] = true;
return dp[b][x][c] = ret;
}
unsigned long long solve(unsigned long long val) {
n = val;
memset(dp2, false, sizeof(dp2));
unsigned long long ret1 = f(0, 0, 0);
n = val << 1;
memset(dp2, false, sizeof(dp2));
unsigned long long ret2 = f(0, 0, 0);
return ret2 - ret1;
}
int main() {
cin.sync_with_stdio(false);
cin >> m >> k;
unsigned long long low = 1;
unsigned long long high = 1000000000000000000LL;
solve(1);
while (high - low > 1) {
unsigned long long mid = (low + high) / 2;
if (solve(mid) < m)
low = mid;
else
high = mid;
}
unsigned long long res;
if (solve(low) == m)
res = low;
else
res = high;
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, cnt[250] = {0}, ans = 0;
cin >> n;
string a;
cin >> a;
for (int i = 0; i < a.size(); i++) {
if (i % 2 == 0)
cnt[a[i]]++;
else {
if (cnt[a[i] + 32])
cnt[a[i] + 32]--;
else
ans++;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const double EPS = 0.00000000001, PI = 3.14159265358979323846;
const int MAXN = int(1e5 + 100), max_dist = 1000000;
pair<int, int> p[MAXN];
int n;
map<int, int> dp;
int main() {
int res = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int a, b;
scanf("%d %d", &a, &b);
p[i] = make_pair(a, b);
}
sort(p + 1, p + n + 1);
int c = 1;
for (int i = 0; i <= max_dist; ++i) {
if (p[c].first == i)
dp[i] = dp[i - p[c].second - 1] + 1, c++;
else
dp[i] = dp[i - 1];
}
for (int i = 1; i <= n; ++i) res = max(res, dp[p[i].first]);
printf("%d", n - res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double eps = 1e-10;
using namespace std;
int n, A, B, a, b, i, j, k, m, pas;
int d[101][101];
int over;
vector<long long> diff;
int in[1000005];
map<int, int> mp;
int used[1000005];
double maxWays;
const int mx = 2e3 + 555;
int dp[1111][111][2];
int powers[1000005], c[1000005];
int C[5555][5555];
struct node {
int a, b;
int l, r;
bool operator<(const node &x) const { return r > x.r; }
} gr[3010];
int pr[3010];
void go() {
for (int i = 0; i <= n; i++) pr[i] = i;
}
int find(int x) {
if (pr[x] == x) {
return x;
} else
return find(pr[x]);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
pr[y] = x;
}
void doit(int x) {
go();
for (int i = 0; i < m; i++) {
if (gr[i].l > x) continue;
merge(gr[i].a, gr[i].b);
if (find(1) == find(n)) {
pas = max(pas, gr[i].r - x + 1);
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &gr[i].a, &gr[i].b, &gr[i].l, &gr[i].r);
}
sort(gr, gr + m);
pas = 0;
for (int i = 0; i < m; i++) {
doit(gr[i].l);
}
if (pas == 0) {
printf("Nice work, Dima!\n");
} else {
printf("%d ", pas);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Maxx = 1e9;
int n, q;
map<int, map<int, int> > mp;
void Insert(int time, int val) {
while (time <= Maxx) {
mp[val][time]++;
time += (time) & (-time);
}
}
void Erase(int time, int val) {
while (time <= Maxx) {
mp[val][time]--;
time += (time) & (-time);
}
}
int Query(int time, int val) {
int re = 0;
while (time) {
re += mp[val][time];
time -= (time) & (-time);
}
return re;
}
int main() {
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int type, time, val;
scanf("%d%d%d", &type, &time, &val);
if (type == 1) {
Insert(time, val);
} else if (type == 2) {
Erase(time, val);
} else {
printf("%d\n", Query(time, val));
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n & 1 ^ 1) {
if (n - 4 >= 4) {
cout << n - 4 << " " << 4;
}
} else {
if (n - 9 >= 4) {
cout << n - 9 << " " << 9;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool done;
bool dp[100005][3][3];
int A[100050], n;
string num;
bool rec(int idx, int rem, int mustOverFlow) {
if (idx == (n - 1) >> 1) {
if (idx == n - idx - 1) {
int value = num[idx] - '0' - rem;
for (int i = 0; i < 10; ++i)
if ((2 * i) % 10 == (value + 10) % 10)
if ((2 * i < 10 and !mustOverFlow) or (2 * i > 9 and mustOverFlow)) {
A[idx] = i;
return true;
}
} else {
int value = num[idx] - '0' - rem;
for (int i = 0; i < 10; ++i) {
int other = (value - i + 10) % 10;
int first = (i + other + rem) / 10;
int f = (first + i + other);
if (f % 10 == num[idx + 1] - '0' and f / 10 == mustOverFlow) {
A[idx] = i;
A[idx + 1] = other;
return true;
}
}
}
return false;
}
if (dp[idx][rem][mustOverFlow]) return false;
dp[idx][rem][mustOverFlow] = true;
int value = num[idx] - '0' - rem;
for (int i = 0; i < 10; ++i) {
int other = (value - i + 10) % 10;
if ((i + other + rem < 10 and !mustOverFlow) or
(i + other + rem > 9 and mustOverFlow)) {
if (num[n - idx - 1] - '0' == (value + 10) % 10) {
if (rec(idx + 1, i + other + rem > 9, 0)) {
A[idx] = i;
A[n - idx - 1] = other;
return true;
}
} else if (num[n - idx - 1] - '0' == (value + 1) % 10) {
if (rec(idx + 1, i + other + rem > 9, 1)) {
A[idx] = i;
A[n - idx - 1] = other;
return true;
}
}
} else if (i + other + rem < 10 and mustOverFlow) {
if (i + other == 9 and num[n - idx - 1] - '0' == 0) {
if (rec(idx + 1, i + other + rem > 9, 1)) {
A[idx] = i;
A[n - idx - 1] = other;
return true;
}
}
} else {
if (i + other == 9 and num[n - idx - 1] - '0' == 9) {
if (rec(idx + 1, i + other + rem > 9, 0)) {
A[idx] = i;
A[n - idx - 1] = other;
return true;
}
}
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> num;
reverse(num.begin(), num.end());
n = num.size();
if (!rec(0, 0, 0)) {
if (num[n - 1] == '1') {
num.erase(num.end() - 1, num.end());
--n;
memset(dp, 0, sizeof(dp));
if (rec(0, 0, 1)) done = true;
}
} else
done = true;
if (done) {
if (A[n - 1] == 0) {
cout << "0\n";
return 0;
}
for (int i = 0; i < n; ++i) cout << A[n - i - 1];
cout << "\n";
} else
cout << "0\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int m;
cin >> n >> m;
long long a[n];
long long b[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
long long kolvo1 = 1000000000000000;
long long kolvo2 = 0;
long long kolvo3 = 0;
for (int i = 0; i < n; i++) {
if (a[i] < m || (a[i] == m && b[i] == 0)) {
if (kolvo1 > b[i] && b[i] != 0) {
kolvo1 = b[i];
}
if (b[i] == 0) {
kolvo3++;
}
} else {
kolvo2++;
}
}
if (kolvo2 == n) {
cout << -1;
return 0;
}
if (kolvo3 == n) {
cout << 0;
return 0;
} else {
if (100 - kolvo1 < 0) {
cout << 0;
return 0;
}
cout << 100 - kolvo1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, m, k, tmp;
while (cin >> t) {
for (int i = 0; i < t; ++i) {
cin >> n >> m >> k;
tmp = max(n, m);
if (k < tmp) {
cout << -1 << endl;
continue;
}
if (abs(n - m) % 2) {
--k;
} else {
if ((k - tmp) % 2) {
k -= 2;
}
}
cout << k << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
const long long linf = 1000000000000000000LL;
const double eps = 0.000001;
const double pi = 3.14159265358979323846;
template <class T>
T abs(T k) {
return k >= 0 ? k : -k;
}
template <class T>
T sqr(T n) {
return n * n;
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T mod(T a, T b) {
return (a % b + b) % b;
}
template <class T>
T addmod(T a, T b, T c) {
return (T)mod((long long)a + b, (long long)c);
}
template <class T>
T mulmod(T a, T b, T c) {
return (T)mod((long long)a * b, (long long)c);
}
template <class T>
T powmod(T a, T b, T c) {
return (T)(b ? mulmod(mod((T)sqr((long long)powmod(a, b >> 1, c)), c),
b & 1 ? a : 1, c)
: 1);
}
template <class T>
void maxe(T &a, T b) {
a = max(a, b);
}
template <class T>
void mine(T &a, T b) {
a = min(a, b);
}
template <class T>
void mode(T &a, T b) {
a = mod(a, b);
}
template <class T>
void addmode(T &a, T b, T c) {
a = addmod(a, b, c);
}
template <class T>
void mulmode(T &a, T b, T c) {
a = mulmod(a, b, c);
}
template <class T>
void powmode(T &a, T b, T c) {
a = powmod(a, b, c);
}
void fileio_in_out() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
void fileio_txt() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int N = 333;
int test;
int n, m, k, ans;
int a[N], b[N];
pair<int, int> p[N];
int x, y;
vector<int> e[N];
int flag[N], ok[N];
pair<pair<int, int>, int> step[2 * N * N];
int check() {
for (int i = 1; i <= n; i++)
if (a[i] != b[i]) return 0;
return 1;
}
void trans(int x, int y, int d) {
step[ans++] = make_pair(make_pair(x, y), d);
a[x] -= d;
a[y] += d;
}
void dfs(int x, int w) {
flag[x] = 1;
w -= a[x];
for (int i = 0; i < e[x].size(); i++) {
int y = e[x][i];
if (w > 0 && !flag[y]) {
if (!ok[y]) {
dfs(y, w);
int d = min(w, a[y]);
w -= d;
trans(y, x, d);
} else {
trans(y, x, w);
dfs(y, b[y]);
w = 0;
if (a[y] < b[y]) {
w = b[y] - a[y];
trans(x, y, w);
}
}
}
}
}
bool cmp(pair<int, int> a, pair<int, int> b) { return a > b; }
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
p[i] = make_pair(b[i], i);
}
while (m--) {
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
sort(p + 1, p + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
memset(flag, 0, sizeof(flag));
dfs(p[i].second, p[i].first);
ok[p[i].second] = 1;
}
if (check()) {
printf("%d\n", ans);
for (int i = 0; i < ans; i++)
printf("%d %d %d\n", step[i].first.first, step[i].first.second,
step[i].second);
} else
puts("NO");
return 0;
}
| 8 |
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define fo(i,n) for(ll i=0;i<n;i++)
#define fo1(i,n) for(ll i=1;i<=n;i++)
#define loop(i,a,b)for(ll i=a;i<=b;i++)
#define loopr(i,a,b)for(ll i=b;i>=a;i--)
#define all(x) x.begin(), x.end()
#define sz(x) (ll)(x).size()
#define vll vector<ll>
#define vvl vector<vll>
#define vpll vector<pll>
#define pll pair<ll,ll>
#define F first
#define S second
#define MOD 1000000007
ll max(ll a,ll b){if (a>b) return a; else return b;}
ll gcd(ll a, ll b){if(b==0)return a;return gcd(b, a%b);}
ll lcm(ll a, ll b){return a*b/gcd(a, b);}
ll fexp(ll a, ll b){ll ans = 1;while(b){if(b&1) ans = ans*a%MOD; b/=2;a=a*a%MOD;}return ans;}
ll inverse(ll a, ll p){return fexp(a, p-2);}
using namespace std;
//take care of long long
//fast I/O
auto optimizer = []() { // makes I/O fast
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
return 0;
}();
//seive
ll N = 1e5;
vll lpf(N+1,0);
void leastPrimeFactor()
{
lpf[1] = 1;
for (ll i = 2; i <= N; i++)
{
if(lpf[i] == 0)
{
lpf[i] = i;
for (ll j = 2*i; j <= N; j += i)
if (lpf[j] == 0)
lpf[j] = i;
}
}
}
int main()
{
ll t=1;
cin>>t;
while(t--)
{
ll n;
cin>>n;
vector<ll> vc(n);
for(ll i=0;i<n;i++)
cin>>vc[i];
ll ans=n+n-1;
//ll add=0;
//bool var=false;
for(ll ln=3;ln<=5;ln++)
{
ll st=0, en=ln-1;
while(en<n)
{
bool flg=true;
for(ll p1=st;p1<=en&&flg;p1++)
{
for(ll p2=p1+1;p2<=en&&flg;p2++)
{
for(ll p3=p2+1;p3<=en&&flg;p3++)
{
if( (vc[p1]<=vc[p2]&&vc[p2]<=vc[p3]) || (vc[p1]>=vc[p2]&&vc[p2]>=vc[p3]) )
{
flg=false;
break;
}
}
}
}
if(flg)
{
ans++;
}
st++;
en++;
}
}
//ans+=add;
//cout<<add<<" ";
//cout<<endl;
cout<<ans<<endl;
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int n, z;
int a[maxn];
int ans;
int main() {
cin >> n >> z;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int l = 1, r = (n + 3) / 2;
while (r <= n) {
if (a[r] - a[l] >= z) {
ans++;
l++;
}
r++;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'H' || s.at(i) == 'Q' || s.at(i) == '9') {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6, pi = acos(-1.00);
int n, m;
double cx, cy, ans;
struct line {
double a, b;
};
line lines[55555];
struct segment {
double ltheta, rtheta;
int id;
bool operator<(const segment &temp) const { return ltheta < temp.ltheta; }
};
segment sg[55555];
struct pp {
int flag, id, nx;
double theta;
bool operator<(const pp &temp) const {
if (theta == temp.theta) return flag < temp.flag;
return theta < temp.theta;
}
};
pp xx[110000];
struct qq {
int id, ip;
bool operator<(const qq &temp) const { return ip < temp.ip; }
};
set<qq> hs;
set<qq>::iterator it;
qq now;
int nxt[55555], pre[55555];
int cnt_sg, cnt_x, ix[155555], rt[110000];
int cnt_th;
int arr[110000];
void norm(double &theta) {
while (theta <= -pi) theta += 2 * pi;
while (theta > pi) theta -= 2 * pi;
}
int lowbit(int x) { return x & (-x); }
void insert(int id) {
int flag = xx[id].flag;
for (id = rt[xx[id].id] + 1; id <= cnt_x; id += lowbit(id)) arr[id] -= flag;
}
int query(int id) {
int res = 0;
for (id = rt[xx[id].id] + 1; id > 0; id -= lowbit(id)) res += arr[id];
return res;
}
int check(double r, bool path_fou) {
int res = 0, id, i, j, s, p, q;
double alpha, theta, vv;
cnt_sg = 0;
for (i = 0; i < n; i++) {
alpha = atan2(1., lines[i].a);
vv = (cy - lines[i].b - lines[i].a * cx) /
(r * sqrt(1 + lines[i].a * lines[i].a));
if (vv < -1 || vv > 1) continue;
theta = -acos(vv) - alpha;
norm(theta);
sg[cnt_sg].id = i;
sg[cnt_sg].ltheta = theta;
theta = acos(vv) - alpha;
norm(theta);
sg[cnt_sg++].rtheta = theta;
if (sg[cnt_sg - 1].ltheta > sg[cnt_sg - 1].rtheta)
swap(sg[cnt_sg - 1].ltheta, sg[cnt_sg - 1].rtheta);
}
cnt_x = 0;
for (i = 0; i < cnt_sg; i++) {
xx[cnt_x].theta = sg[i].ltheta;
xx[cnt_x].id = i;
xx[cnt_x++].flag = -1;
xx[cnt_x].theta = sg[i].rtheta;
xx[cnt_x].id = i;
xx[cnt_x++].flag = 1;
}
sort(xx, xx + cnt_x);
for (i = 0; i < cnt_x; i++) rt[xx[i].id] = i;
for (i = 0; i <= cnt_x; i++) arr[i] = 0;
for (i = 0; i < cnt_x; i++) {
if (xx[i].flag < 0) {
res += query(i);
if (!path_fou) {
if (res > m) return 1;
}
}
insert(i);
}
if (!path_fou) {
if (res < m) return -1;
}
if (path_fou) {
memset(nxt, -1, sizeof(nxt));
memset(pre, -1, sizeof(pre));
hs.clear();
ans = 0;
for (i = 0; i < cnt_x; i++) {
now.id = sg[xx[i].id].id;
now.ip = rt[xx[i].id];
it = hs.upper_bound(now);
if (xx[i].flag < 0) {
if (it != hs.end()) {
nxt[now.id] = it->id;
pre[it->id] = now.id;
}
if (it != hs.begin()) {
it--;
id = it->id;
while (id >= 0) {
int ii = now.id, jj = id;
double xp, yp;
xp = (lines[jj].b - lines[ii].b) / (lines[ii].a - lines[jj].a);
yp = lines[ii].a * xp + lines[ii].b;
ans += sqrt((cx - xp) * (cx - xp) + (cy - yp) * (cy - yp));
m--;
id = pre[id];
}
nxt[it->id] = now.id;
pre[now.id] = it->id;
}
hs.insert(now);
} else {
if (nxt[now.id] >= 0) pre[nxt[now.id]] = pre[now.id];
if (pre[now.id] >= 0) nxt[pre[now.id]] = nxt[now.id];
pre[now.id] = -1;
nxt[now.id] = -1;
hs.erase(now);
}
}
}
return 0;
}
int main() {
int i, j, s, p, q;
double low, high, mid;
scanf("%d%lf%lf%d", &n, &cx, &cy, &m);
cx /= 1000.;
cy /= 1000.;
for (i = 0; i < n; i++) {
scanf("%lf%lf", &lines[i].a, &lines[i].b);
lines[i].a /= 1000.;
lines[i].b /= 1000.;
}
low = 0;
high = 2e9 + 2e3;
for (int it = 0; it <= 50; it++) {
mid = (low + high) / 2.0;
int ms = check(mid, 0);
if (ms <= 0)
low = mid;
else if (ms > 0)
high = mid;
}
if (low == 0) {
puts("0");
return 0;
}
check(low, 1);
printf("%.20f\n", ans + high * m);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long i, j, k, l = 0, m, n, divisor = 0;
cin >> n;
vector<long long> v(n), x;
for (i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
k = v[n - 1] * v[0];
for (i = 2; i * i <= k; i++) {
if (i * i == k)
x.push_back(i);
else if (k % i == 0)
x.push_back(i), x.push_back(k / i);
}
sort(x.begin(), x.end());
if (v == x)
cout << k << endl;
else
cout << -1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, w, r;
pair<long long, long long> a[2000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
r += a[i].first;
}
sort(a, a + n);
int l = a[0].first;
if ((w < 2 && w < l) || w > r || (w < l && n == 1)) {
cout << "No";
return 0;
}
cout << "Yes" << endl;
if (w < l) {
cout << a[0].second << " " << a[1].second << " " << a[0].second << " ";
a[0].first--;
while (a[0].first >= w) {
cout << a[0].second << " " << a[0].second << " ";
a[0].first--;
}
cout << a[1].second << " ";
a[1].first--;
w--;
}
cout << a[0].second << " ";
int t = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < a[i].first; j++)
if (t < w)
t++;
else
cout << a[i].second << " " << a[i].second << " ";
cout << a[0].second << " ";
a[0].first--;
t--;
for (int i = 0; i < n; i++)
for (int j = 0; j < a[i].first; j++)
if (t) {
cout << a[i].second << " " << a[i].second << " ";
t--;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1001 * 1001;
int n, m, s, t, ql, qr, d[MX], q[MX * 2], de[MX];
set<int> nd;
vector<int> g[MX];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
g[v].push_back(u);
++de[u];
}
scanf("%d %d", &s, &t);
if (s == t) {
puts("0");
return 0;
}
nd.insert(t);
int cd = 1;
while (!nd.empty()) {
set<int> cu;
swap(cu, nd);
while (!cu.empty()) {
int v = *cu.begin();
cu.erase(cu.begin());
d[v] = cd;
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (d[to]) continue;
nd.insert(to);
--de[to];
if (de[to] == 0) {
nd.erase(to);
cu.insert(to);
}
}
}
cd++;
}
printf("%d\n", d[s] - 1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a1, a2, b1, b2, c1, c2;
cin >> a1 >> a2 >> b1 >> b2 >> c1 >> c2;
if (a1 * (b2 - c2) + b1 * (c2 - a2) + c1 * (a2 - b2) == 0) {
cout << "No";
return 0;
} else if (((a1 - b1) * (a1 - b1) + (a2 - b2) * (a2 - b2)) ==
((c1 - b1) * (c1 - b1) + (c2 - b2) * (c2 - b2))) {
cout << "Yes";
return 0;
}
cout << "No";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
int dp[3][maxn], cnt = 0;
int n, q;
void solve(int r, int c) {
r--;
if (dp[r][c]) {
dp[r][c] = 0;
r ^= 1;
for (int i = -1; i <= 1; i++) {
int now = c + i;
if (now <= 0 || now > n) continue;
if (dp[r][now]) cnt--;
}
} else {
dp[r][c] = 1;
r ^= 1;
for (int i = -1; i <= 1; i++) {
int now = c + i;
if (now <= 0 || now > n) continue;
if (dp[r][now]) cnt++;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> q;
while (q--) {
int r, c;
cin >> r >> c;
solve(r, c);
if (cnt)
cout << "No" << '\n';
else
cout << "Yes" << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010];
int n, k, a, b, x, y, z[300010];
long long inf = 1e18;
int main() {
while (scanf("%d %d", &n, &k) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &z[i]);
sort(z + 1, z + n + 1);
x = n / k;
y = n / k + 1;
b = n - k * x;
a = k - b;
dp[1][0] = z[y] - z[1];
dp[1][1] = z[x] - z[1];
for (int i = 2; i <= a + b; i++) {
for (int j = 0; j <= min(a, i); j++) {
if (i == j) {
dp[i][j] = dp[i - 1][j - 1] + (long long)z[(i - 1) * x + x] -
z[(i - 1) * x + 1];
} else {
int tmp = j * x + (i - 1 - j) * y;
if (tmp + y <= n)
dp[i][j] = dp[i - 1][j] + (long long)z[tmp + y] - z[tmp + 1];
else
dp[i][j] = inf;
if (j > 0) {
tmp = (j - 1) * x + (i - j) * y;
if (tmp + x <= n)
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] +
(long long)z[tmp + x] - z[tmp + 1]);
}
}
}
}
printf("%I64d\n", dp[a + b][a]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<vector<int> > relatives;
vector<int> father, value;
int gcd(int A, int B) {
if (B == 0) {
return A;
}
return gcd(B, A % B);
}
void assignfathers(int V, int F) {
father[V] = F;
int i;
for (i = 0; i < relatives[V].size(); i++) {
if (relatives[V][i] != F) {
assignfathers(relatives[V][i], V);
}
}
}
int askfor(int v, int val) {
if (v < 0) {
return -1;
}
if (gcd(value[v], val) > 1) {
return v + 1;
}
return askfor(father[v], val);
}
int main() {
cin >> n >> q;
father.resize(n);
value.resize(n);
relatives.resize(n);
int x, y, num, jay, newval;
for (int i = 0; i < n; i++) {
cin >> value[i];
}
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
relatives[x - 1].push_back(y - 1);
relatives[y - 1].push_back(x - 1);
}
assignfathers(0, -1);
while (q > 0) {
q--;
cin >> num;
if (num == 2) {
cin >> jay >> newval;
value[jay - 1] = newval;
}
if (num == 1) {
cin >> jay;
cout << askfor(father[jay - 1], value[jay - 1]) << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e5 + 5;
struct p {
int l, r, id;
bool operator<(const p &a) const { return r < a.r; }
} qu[MAX];
int n, q, UP, maxn;
int ans[MAX], a[MAX], p[21], pos[21];
int read() {
int x(0);
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); x = x * 10 + ch - 48, ch = getchar())
;
return x;
}
void ins(int x, int id) {
for (int i = UP; i >= 0; --i)
if (x & (1 << i)) {
if (!p[i]) {
p[i] = x;
return void(pos[i] = id);
}
if (pos[i] < id) swap(p[i], x), swap(pos[i], id);
x ^= p[i];
}
}
int GET_MAX(int id) {
int Ans = 0;
for (int i = UP; i >= 0; --i)
if (pos[i] >= id && (Ans ^ p[i]) > Ans) Ans ^= p[i];
return Ans;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read(), maxn = max(maxn, a[i]);
while (maxn) maxn >>= 1, ++UP;
q = read();
for (int i = 1; i <= q; ++i) qu[i].l = read(), qu[i].r = read(), qu[i].id = i;
sort(qu + 1, qu + 1 + q);
for (int i = 1, L = 1; i <= q; ++i) {
while (L <= qu[i].r && L <= n) ins(a[L], L), ++L;
ans[qu[i].id] = GET_MAX(qu[i].l);
}
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int l, r, x, y;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int totalPrimeFactors(long long int n) {
long long int count = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
long long int b = n / i;
if (i * x < l || i * x > r || b * x < l || b * x > r) continue;
long long int w = gcd(i * x, b * x);
long long int r = b * i * x * x / (w);
if (w != x || r != y) continue;
count = count + 2;
if (i == b) count--;
}
}
return count;
}
long long int countPairs(long long int G, int L) {
if (L % G != 0) return 0;
long long int div = L / G;
return totalPrimeFactors(div);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> l >> r >> x >> y;
long long int p = countPairs(x, y);
cout << p << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int yh() {
int ret = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == EOF) return -1;
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) ret = (ret << 3) + (ret << 1) + (c ^ 48), c = getchar();
return f ? -ret : ret;
}
const int maxn = 3e5 + 5;
const long long MOD = 2147483647;
vector<int> a[10];
long long c[10];
long long w[10];
int n;
set<long long> il;
set<long long> vst;
int hd[10];
struct ar {
vector<int> a;
long long val;
long long hsh;
bool operator<(const ar& A) const {
return make_pair(val, hsh) < make_pair(A.val, A.hsh);
}
};
void print(vector<int>& A) {
for (int i = 0, iss = (n); i < iss; i++) cout << A[i] + 1 << " ";
cout << endl;
}
int main() {
n = yh();
for (int i = 0, iss = (n); i < iss; i++) {
c[i] = yh();
a[i].resize(c[i]);
for (int& x : a[i]) x = yh();
}
w[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) w[i] = w[i + 1] * c[i + 1] % MOD;
int m = yh();
long long sum = 0, val = 0;
for (int i = 0, iss = (m); i < iss; i++) {
sum = 0;
for (int j = 0, jss = (n); j < jss; j++) (sum += w[j] * (yh() - 1)) %= MOD;
il.insert(sum);
}
sum = 0;
priority_queue<ar> q;
vector<int> tmp;
tmp.resize(n);
for (int i = 0, iss = (n); i < iss; i++)
hd[i] = c[i] - 1, (sum += hd[i] * w[i]) %= MOD, tmp[i] = hd[i],
val += a[i][hd[i]];
q.push((ar){tmp, val, sum});
vst.insert(sum);
while (!q.empty()) {
ar T = q.top();
tmp = T.a, val = T.val, sum = T.hsh;
q.pop();
if (!il.count(sum)) {
print(tmp);
return 0;
}
for (int i = 0, iss = (n); i < iss; i++)
if (tmp[i]) {
long long ns = (sum - w[i] + MOD) % MOD;
if (!vst.count(ns)) {
tmp[i]--;
q.push((ar){tmp, val + a[i][tmp[i]] - a[i][tmp[i] + 1], ns});
vst.insert(ns);
tmp[i]++;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 10;
const int MAX_N = 200 * 1000 + 10;
int a[MAX_N], nex[MAX_N];
int main() {
ios_base ::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int ans = 0;
for (int i = n; i; i--) nex[i - 1] = (a[i] != 1 ? i : nex[i]);
for (int i = 0; i < n; i++) {
int cur = i;
long long s = 0, p = 1;
while (cur < n && INF / a[cur] > p) {
s += a[cur], p *= a[cur];
int L = 0, R = nex[cur] - cur;
while (L + 1 < R) {
int mid = (L + R) / 2;
p >= k*(s + mid) ? L = mid : R = mid;
}
ans += (p == k * (s + L)), s += nex[cur] - cur - 1, cur = nex[cur];
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class Person {
vector<int> fr, notfr;
public:
void add(int s, int n) {
if (s)
fr.push_back(n);
else
notfr.push_back(n);
}
vector<int> getvt(int s) {
if (s) return fr;
return notfr;
}
};
Person p[2003];
unordered_set<int> vis;
int dfs(unordered_set<int> &dsl, vector<int> fr, int n, int &ok) {
int count = 0;
if (vis.find(n) == vis.end()) {
vis.insert(n);
vector<int> temp = p[n].getvt(0);
for (int i : temp) dsl.insert(i);
}
for (int i : fr) {
if (vis.find(i) == vis.end()) count += dfs(dsl, p[i].getvt(1), i, ok);
if (dsl.find(i) != dsl.end()) ok = 0;
}
return (ok ? count + 1 : 0);
}
void solve() {
int n, k, x, y;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cin >> x >> y;
p[x].add(1, y);
p[y].add(1, x);
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
p[x].add(0, y);
p[y].add(0, x);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vis.find(i) == vis.end()) {
unordered_set<int> dsl;
int ok = 1;
ans = max(ans, dfs(dsl, p[i].getvt(1), i, ok));
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = (int)4e5 + 10;
using namespace std;
struct Node {
int l, r, id;
bool operator<(const Node &rhs) const {
return r < rhs.r || r == rhs.r && id < rhs.id;
};
} p[N];
bool cmp(Node a, Node b) { return a.l < b.l; }
int n, m;
set<Node> v;
vector<int> ans;
int main() {
cin >> n >> m;
for (int i = 1, x, y; i <= m; i++)
scanf("%d%d", &x, &y), p[i] = (Node){n - y + 1, x, i};
sort(p + 1, p + m + 1, cmp);
for (int i = 1, j = 1; i <= n; i++) {
while (j <= m && p[j].l == i) v.insert((Node){0, p[j].r, p[j].id}), j++;
set<Node>::iterator it = v.lower_bound((Node){0, i, -1});
if (it != v.end()) ans.push_back((*it).id), v.erase(it);
}
cout << ans.size() << "\n";
for (auto k : ans) printf("%d ", k);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ll n;
cin >> n;
vector<ll> A(n);
for (auto& _a : A) cin >> _a;
int cnt[4] = {};
for (int x : A) ++cnt[x];
ll ans = max({cnt[1], cnt[2], cnt[3]});
n -= ans;
cout << n << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 505, inf = 1111111111;
int n, m, b, mod, a[max_n], dp[2][max_n][max_n];
vector<pair<int, int> > v;
int main() {
cin >> n >> m >> b >> mod;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
dp[0][0][0] = 1;
int q1 = 0, q2 = 0;
for (int i = 0; i < n; ++i) {
for (int x = 0; x < m; ++x) {
for (int y = 0; y + a[i] <= b; ++y) {
if (dp[q1][x][y] == 0) {
continue;
}
dp[q1][x + 1][y + a[i]] =
(dp[q1][x + 1][y + a[i]] + dp[q1][x][y]) % mod;
}
}
swap(q1, q2);
}
int ans = 0;
for (int y = 0; y <= b; ++y) {
ans = (ans + dp[q1][m][y]) % mod;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1LL << 61;
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
cout << s[0];
for (long long i = 1; i < s.size(); i += 2) {
cout << s[i];
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, T, m, t0 = 0;
double c, mean = 0.0;
scanf("%d %d %lf", &n, &T, &c);
long long a[n];
long long s[n];
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
s[i] = ((i > 0) ? (s[i - 1]) : 0L) + a[i];
}
scanf("%d", &m);
for (int j = 0; j < m; j++) {
int p;
scanf("%d", &p);
p--;
while (t0 <= p) mean = (mean + (double)a[t0++] / T) / c;
double a_mean = ((double)(s[p] - ((p >= T) ? s[p - T] : 0L))) / T;
double error = std::abs(mean - a_mean) / a_mean;
printf("%.6f %.6f %.6f\n", a_mean, mean, error);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int m = 1000000007;
long long int n1, n2 = 0, sum = 0;
long long int gcd(long long int a, long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
bool compare(pair<string, long long int> p1, pair<string, long long int> p2) {
if (p1.second != p2.second) {
return p1.second > p2.second;
} else
return p1.first < p2.first;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
long long int n;
cin >> n;
bool prime[n + 2];
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n + 1; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n + 1; i += p) prime[i] = false;
}
}
if (n > 2)
cout << 2 << "\n";
else
cout << 1 << "\n";
for (long long int i = 2; i < n + 2; i++) {
if (prime[i])
cout << 1 << ' ';
else
cout << 2 << ' ';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
int n = 0;
long long int cur_k, cur_a = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
int k, a;
scanf("%d %d", &k, &a);
v.push_back(make_pair(k, a));
}
sort(v.begin(), v.end());
int i = 0;
for (cur_k = 0; i < n; ++cur_k) {
long long int new_a = cur_a / 4;
if (cur_a % 4 != 0) new_a++;
if (cur_k == v[i].first) {
long long int second = v[i].second;
new_a = max(new_a, second);
++i;
}
cur_a = new_a;
if (cur_a <= 1 && i < n) cur_k = max(v[i].first - 1, 0);
}
cur_k--;
while (cur_a > 1) {
++cur_k;
long long int new_a = cur_a / 4;
if (cur_a % 4 != 0) new_a++;
cur_a = new_a;
}
if (cur_k == v[n - 1].first) cur_k++;
cout << cur_k;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, v[100], a[1000005], fr[1000005];
int main() {
int j, p;
long long i, val, sol = 0;
cin.sync_with_stdio(0);
cin >> n;
for (i = 0; i <= n; ++i) a[i] = -1;
for (i = n; i >= 0; --i) {
if (a[i] != -1) continue;
val = (i ^ 4294967295LL);
for (j = 31, v[0] = 0; j >= 0; --j)
if ((1LL << j) & val) v[++v[0]] = j;
p = 1;
while (val > n || fr[val]) {
val -= (1LL << v[p]);
++p;
}
fr[val] = true;
a[i] = val;
a[val] = i;
}
for (i = 0; i <= n; ++i) sol += (i ^ a[i]);
cout << sol << "\n";
for (i = 0; i <= n; ++i) cout << a[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10, MAX = 1e5 + 1e4, MOD = 1e9 + 7, MAXL = 25;
void OUT(long double o, int x) {
cout << fixed << setprecision(x) << o;
return;
}
int fen[4][12][12][MAX], n, m, ch[100];
void upd(int a, int b, int c, int x, int y) {
for (; x <= n; x += x & -x) fen[a][b][c][x] += y;
}
int g(int a, int b, int c, int x) {
int z = 0;
for (; x; x -= x & -x) z += fen[a][b][c][x];
return z;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, p;
cin >> s;
n = s.size();
ch[0] = 0;
ch['T' - 'A'] = 1;
ch['C' - 'A'] = 2;
ch['G' - 'A'] = 3;
s = "!" + s;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 10; j++) upd(ch[s[i] - 'A'], j, i % j, i, 1);
cin >> m;
while (m--) {
int t;
cin >> t;
if (t == 1) {
int x;
char c;
cin >> x >> c;
for (int j = 1; j <= 10; j++)
upd(ch[s[x] - 'A'], j, x % j, x, -1), upd(ch[c - 'A'], j, x % j, x, 1);
s[x] = c;
} else {
int l, r, ans = 0;
cin >> l >> r >> p;
for (int i = 0; i < p.size(); i++)
ans += g(ch[p[i] - 'A'], p.size(), (l + i) % p.size(), r) -
g(ch[p[i] - 'A'], p.size(), (l + i) % p.size(), l - 1);
cout << ans << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v;
int main() {
int n, p, i, l, r;
long long x, y, tot = 1, temp = 0;
double res = 0.0, res1, res2;
scanf("%d %d", &n, &p);
for (i = 0; i < n; i++) {
scanf("%d %d", &l, &r);
x = (r - l) + 1;
y = (r / p) - ((l - 1) / p);
v.push_back(pair<long long, long long>(x, y));
tot *= x;
}
v.push_back(v[0]);
for (i = 1; i < v.size(); i++) {
res1 = (double)v[i - 1].second / (double)v[i - 1].first;
y = v[i - 1].first - v[i - 1].second;
res2 = (double)y / (double)v[i - 1].first;
res2 *= (double)v[i].second / (double)v[i].first;
res += (res1 + res2);
}
res *= 2000.0;
printf("%0.10lf\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t, b;
unsigned long int a;
unsigned int k;
cin >> n >> m >> k;
unsigned int idxr[5005] = {0};
unsigned int idxc[5005] = {0};
unsigned long int r[5005] = {0};
unsigned long int c[5005] = {0};
for (unsigned int i = 1; i <= k; i++) {
cin >> t;
cin >> b;
cin >> a;
if (t == 1) {
idxr[b] = i;
r[b] = a;
} else {
idxc[b] = i;
c[b] = a;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a = idxr[i] > idxc[j] ? r[i] : c[j];
cout << a << " ";
}
cout << "\n";
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.