solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long n, M;
const long long MX = 101111;
struct edge {
long long to, w;
};
vector<edge> g[MX];
long long ni10[MX], z10[MX];
namespace Niyuan {
long long extend_gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0 && b == 0) return -1;
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extend_gcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
long long mod_r(long long a, long long n) {
long long x, y;
long long d = extend_gcd(a, n, x, y);
if (d == 1)
return (x % n + n) % n;
else
return -1;
}
} // namespace Niyuan
long long wt[MX];
long long del[MX];
long long newroot;
long long maxn = 0x3f3f3f3f;
long long dfs(long long now, long long fa, long long all, long long &newroot,
long long dep) {
wt[now] = 1;
long long mx = 0;
for (long long i = 0; i < g[now].size(); i++) {
long long to = g[now][i].to;
if (to == fa || del[to]) continue;
long long siz = dfs(to, now, all, newroot, dep + 1);
mx = max(mx, siz);
wt[now] += siz;
}
mx = max(mx, all - wt[now]);
if (mx < maxn) maxn = mx, newroot = now;
return wt[now];
}
long long searchit(long long root, long long all) {
maxn = 0x3f3f3f3f;
dfs(root, -1, all, newroot, 1);
return newroot;
}
map<long long, long long> mp;
long long ans = 0;
long long tque[101111];
long long tl = 0;
void gao(long long u, long long fa, long long zv, long long fv, long long dep,
long long sef) {
long long cha = (((-zv * ni10[dep]) % M + M) % M);
if (mp.count(cha)) ans += mp[cha];
if (zv == 0 && sef) {
ans++;
}
if (fv == 0 && sef) {
ans++;
}
if (fa != -1) {
tque[tl++] = fv;
}
for (long long i = 0; i < g[u].size(); i++) {
long long to = g[u][i].to;
if (to == fa || del[to]) continue;
long long w = g[u][i].w;
long long nzv = (((zv * 10 + w) % M + M) % M);
long long nfv = (((w * z10[dep] + fv) % M + M) % M);
gao(to, u, nzv, nfv, dep + 1, sef);
}
}
void fz(long long rt, long long sz) {
queue<pair<int, int> > sq;
sq.push(make_pair((rt), (sz)));
while (!sq.empty()) {
pair<int, int> now = sq.front();
sq.pop();
long long nr = searchit(now.first, now.second);
del[nr] = true;
mp.clear();
for (long long i = 0; i < g[nr].size(); i++) {
long long to = g[nr][i].to;
if (del[to]) continue;
long long w = g[nr][i].w % M;
tl = 0;
gao(to, nr, w, w, 1, 1);
for (long long j = 0; j < tl; j++) {
mp[tque[j]]++;
}
sq.push(make_pair((to), (wt[to])));
}
long long gsz = g[nr].size();
mp.clear();
for (long long i = gsz - 1; i >= 0; i--) {
long long to = g[nr][i].to;
if (del[to]) continue;
long long w = g[nr][i].w % M;
tl = 0;
gao(to, nr, w, w, 1, 0);
for (long long j = 0; j < tl; j++) {
mp[tque[j]]++;
}
}
}
}
int main() {
scanf("%I64d%I64d", &n, &M);
ni10[0] = 1;
z10[0] = 1;
long long nn10 = Niyuan::mod_r(10, M);
for (long long i = 1; i < MX; i++) {
ni10[i] = ni10[i - 1] * nn10 % M;
z10[i] = z10[i - 1] * 10 % M;
}
for (long long i = 0; i < n - 1; i++) {
long long u, v, w;
scanf("%I64d%I64d%I64d", &u, &v, &w);
g[u].push_back((edge){v, w});
g[v].push_back((edge){u, w});
}
fz(0, n);
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string a, b;
vector<pair<int64_t, int64_t> > v;
vector<int64_t> ans;
cin >> a >> b;
int64_t len = a.length(), d = 0;
for (int64_t i = 0; i < len; ++i) {
if (a[i] != b[i]) {
d++;
v.push_back({i, 1});
} else {
v.push_back({i, 0});
}
}
if (d & 1)
cout << "impossible";
else {
for (auto& it : v) {
int64_t i = it.first;
int64_t j = a.at(i) - 48;
bool suc = it.second;
if (suc) {
if (d & 1) {
ans.push_back(j);
} else {
ans.push_back(!j);
}
d--;
} else
ans.push_back(j);
}
}
for (auto& it : ans) cout << it;
cerr << "Time taken : " << 1.0 * clock() / CLOCKS_PER_SEC << " seconds."
<< '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &_x_) {
_x_ = 0;
bool f = false;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = !f;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
_x_ = _x_ * 10 + ch - '0';
ch = getchar();
}
if (f) _x_ = -_x_;
}
const double eps = 1e-8;
const int maxn = 1e5 + 7;
const int mod = 1e9 + 7;
const long long inf = 1e15;
long long n, x, ans = 0;
stack<long long> s;
int main() {
read(n);
read(x);
s.push(x);
for (long long i = 2; i <= n; i++) {
read(x);
while (s.size() >= 2) {
long long a = s.top();
s.pop();
long long b = s.top();
if (a <= b && a <= x) {
ans += min(x, b);
} else {
s.push(a);
break;
}
}
s.push(x);
}
long long mi = 0, mx = 0, sum = 0;
while (!s.empty()) {
long long u = s.top();
s.pop();
sum += u;
if (u >= mx) {
mi = mx;
mx = u;
} else if (u > mi)
mi = u;
}
printf("%I64d\n", ans + sum - mi - mx);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, a, b;
cin >> n >> a >> b;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
long long lo = v[b - 1];
long long hi = v[b];
cout << hi - lo;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
cout << setprecision(12);
int t = 1;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
int dp[1010][1010][11][2];
char s1[1010], s2[1010];
int n, m, k;
int main() {
int t;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
scanf("%s%s", s1 + 1, s2 + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (s1[i] == s2[j])
for (int t = 1; t <= k; t++)
dp[i][j][t][0] =
max(dp[i - 1][j - 1][t][0], dp[i - 1][j - 1][t - 1][1]) + 1;
for (int t = 1; t <= k; t++) {
int cnt = max(dp[i - 1][j - 1][t][1], dp[i][j - 1][t][1]);
cnt = max(cnt, dp[i - 1][j][t][1]);
dp[i][j][t][1] = max(cnt, dp[i][j][t][0]);
}
}
printf("%d\n", dp[n][m][k][1]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T = int>
struct Fenwick {
int n;
vector<T> v;
Fenwick(int size = 100005) : n(size), v(n + 1, 0) {}
inline void add(int p, T val) {
for (; p <= n; p += (p & -p)) {
v[p] += val;
}
}
inline T query(int p) {
T tmp = 0;
for (; p > 0; p -= (p & -p)) {
tmp += v[p];
}
return tmp;
}
inline T query(int l, int r) { return query(r) - query(l - 1); }
};
template <typename T>
T bs_first(T l, T r, function<bool(T)> f) {
assert(l < r);
T mid;
while (l != r) {
mid = l + (r - l) / 2;
if (f(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
return r;
}
void solve() {
int n, m;
cin >> n >> m;
swap(n, m);
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i >= 1; i--) {
a[i] -= a[i - 1];
}
Fenwick<int> occur(m);
vector<int> res(m + 1);
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
res[i] = x;
if (x == -1) {
int l = 1;
for (int z : a) {
if (l > i || occur.query(l, i) < z) break;
int k = bs_first<int>(l, i + 1,
[&](int k) { return occur.query(l, k) >= z; });
occur.add(k, -1);
l = k + 1;
}
} else {
occur.add(i, 1);
}
}
if (occur.query(m) == 0) {
cout << "Poor stack!";
return;
}
for (int i = 1; i <= m; i++) {
if (occur.query(i, i)) cout << res[i];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
string rooms;
int n, k;
while (cin >> n) {
cin >> k;
cin >> rooms;
vector<int> counts(n, 0);
counts[0] = rooms[0] == '0';
for (int i = 1; i < n; i++) {
counts[i] = counts[i - 1] + (rooms[i] == '0');
}
int left = 0;
while (left < n && counts[left] == 0) {
left++;
}
int right = 0;
while (right < n && counts[right] < k + 1) {
right++;
}
int bestAns = n;
while (right < n) {
int m = left + (right - left + 1) / 2;
if (rooms[m] == '0') {
bestAns = min(bestAns, max(m - left, right - m));
} else {
int a = left;
int b = m;
while (a < b - 1) {
int test = (a + b) / 2;
if (counts[m] == counts[test] && rooms[test] == '1') {
b = test;
} else {
a = test;
}
}
int ans1 = max(a - left, right - a);
a = m;
b = right;
while (a < b - 1) {
int test = (a + b) / 2;
if (counts[m] == counts[test] && rooms[test] == '1') {
a = test;
} else {
b = test;
}
}
int ans2 = max(b - left, right - b);
bestAns = min(bestAns, min(ans1, ans2));
}
right++;
if (right >= n || counts[right] == counts[right - 1]) {
continue;
}
left++;
while (counts[left] == counts[left - 1]) {
left++;
}
}
cout << bestAns << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const double tau = 2 * pi;
const double epsilon = 1e-9;
const int MAX_N = 110;
const int MAX_M = 110;
const int MAX_K = 110;
int N, M, K;
int instructions[MAX_N][MAX_M];
vector<int> cells[MAX_K];
int locktime[MAX_M];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> N >> M >> K;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
cin >> instructions[i][j];
--instructions[i][j];
}
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++)
if (locktime[j] == 0 && instructions[j][i] != -1) {
if (((int)cells[instructions[j][i]].size()) == 0)
cells[instructions[j][i]].push_back(j);
else if (((int)cells[instructions[j][i]].size()) == 1) {
locktime[cells[instructions[j][i]][0]] = i + 1;
locktime[j] = i + 1;
cells[instructions[j][i]].push_back(j);
} else {
locktime[j] = i + 1;
cells[instructions[j][i]].push_back(j);
}
}
for (int j = 0; j < K; j++)
if (((int)cells[j].size()) == 1) cells[j].clear();
}
for (int i = 0; i < N; i++) cout << locktime[i] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
void solve() {
int n;
long long k;
cin >> n >> k;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (k == 0) break;
if ((i % 2 == 0) && (i + 2) < n &&
(s[i] == '4' && s[i + 1] == '7' && s[i + 2] == '7')) {
k %= 2;
}
if (k && (s[i] == '4' && s[i + 1] == '7')) {
if ((i + 1) & 1)
s[i + 1] = '4';
else
s[i] = '7';
i -= 2, k--;
}
}
cout << s << '\n';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005];
int num[200005];
int s[200005];
int t[200005];
int co = 1;
int dfs(int pos) {
s[co] = pos;
t[pos] = co++;
int number = 0;
for (int i = 0; i < v[pos].size(); i++) {
number += dfs(v[pos][i]);
}
num[pos] = number;
number++;
return number;
}
int main() {
std::ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
int pre;
for (int i = 2; i <= n; i++) {
cin >> pre;
v[pre].push_back(i);
}
dfs(1);
int u, k;
while (q--) {
cin >> u >> k;
if (num[u] + 1 < k) {
cout << -1 << endl;
} else {
cout << s[t[u] + k - 1] << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool flag = false;
int n, m, k, x, y;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> x >> y;
if (x == n or y == m)
flag = true;
else {
if (n - x < 5) flag = true;
if (x - 1 < 5) flag = true;
if (m - y < 5) flag = true;
if (y - 1 < 5) flag = true;
}
}
if (flag == true)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
while (q--) {
long long int n, k = 0;
cin >> n;
if (n % 2 != 0) {
n = n - 9;
k++;
}
if (n == 2 || n < 0) {
cout << -1 << "\n";
continue;
} else if (n == 0) {
cout << k << "\n";
continue;
}
if (n % 4 == 0) {
cout << n / 4 + k << "\n";
} else {
k++;
n = n - 6;
cout << n / 4 + k << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int Num;
char CH[20];
const int inf = 0x3f3f3f3f;
inline long long 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;
}
inline void P(int x) {
Num = 0;
if (!x) {
putchar('0');
puts("");
return;
}
while (x > 0) CH[++Num] = x % 10, x /= 10;
while (Num) putchar(CH[Num--] + 48);
puts("");
}
int a[1000010];
vector<pair<int, int> > q;
multiset<int> s;
int main() {
int n = read(), k = read();
for (int i = 0; i < n; i++) a[i] = read();
int j = 0;
int aa = -1;
for (int i = 0; i < n; i++) {
s.insert(a[i]);
while (*s.rbegin() - *s.begin() > k) s.erase(s.find(a[j++]));
if (i - j + 1 > aa) {
aa = i - j + 1;
q.clear();
}
if (i - j + 1 == aa) q.push_back(make_pair(j + 1, i + 1));
}
printf("%d %d\n", aa, q.size());
for (int i = 0; i < q.size(); i++) printf("%d %d\n", q[i].first, q[i].second);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, n;
int cek(int x) {
d = x % 10;
c = ((x % 100) - d) / 10;
b = ((x % 1000) - (x % 100)) / 100;
a = ((x % 10000) - (x % 1000)) / 1000;
if (a != b && a != c && a != d && b != c && b != d && c != d)
return x;
else
return 0;
}
int main() {
cin >> n;
for (int i = n + 1; i <= 9999; i++) {
if (cek(i) != 0) {
cout << i;
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, pair<int, int> > > vec[1002];
int maxVal = -1;
int n;
int nodeMin[1002], nodeMax[1002];
bool visited[1002];
bool Subset(int childMin, int childMax, int oldMin, int oldMax) {
return (childMin < oldMin || childMax > oldMax);
}
void dfs(int node, int left, int right) {
if (node == n - 1) {
if (right - left + 1 > maxVal) maxVal = right - left + 1;
return;
}
int vSize = vec[node].size();
for (int counter = 0; counter < vSize; counter++) {
int child = vec[node][counter].first;
int childMin = vec[node][counter].second.first;
int childMax = vec[node][counter].second.second;
childMin = max(left, childMin);
childMax = min(right, childMax);
if (visited[child]) continue;
if (childMax - childMin + 1 > maxVal &&
Subset(childMin, childMax, nodeMin[child], nodeMax[child])) {
visited[child] = true;
nodeMin[child] = childMin;
nodeMax[child] = childMax;
dfs(child, childMin, childMax);
visited[child] = false;
}
}
}
int main() {
int m;
cin >> n >> m;
for (int counter = 0; counter < m; counter++) {
int x, y, a, b;
cin >> x >> y >> a >> b;
x--, y--;
pair<int, int> wgh = make_pair(a, b);
vec[x].push_back(make_pair(y, wgh));
vec[y].push_back(make_pair(x, wgh));
}
nodeMin[0] = 1;
nodeMax[0] = 1e6;
visited[0] = true;
dfs(0, 1, 1e6);
if (maxVal > 0)
cout << maxVal << endl;
else
cout << "Nice work, Dima!" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int x[n], i, j;
for (i = 0; i < n; i++) {
cin >> x[i];
}
int temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (x[i] > x[j]) {
temp = x[i];
x[i] = x[j];
x[j] = temp;
}
}
}
int m = x[k - 1], t = 0;
for (i = 0; i < n; i++) {
if (x[i] > 0)
if (x[i] >= m) t++;
}
cout << t;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 3;
const int maxc = 26;
const int maxs = 1e6 + 6;
int cur;
int len;
int n, m;
string str;
string inp;
int arr[maxn];
int start[maxn];
int finish[maxn];
int nxt1[maxs][maxc];
pair<int, int> dp[maxn][maxn];
pair<int, int> nxt2[maxn][maxc];
void in();
void solve();
void out();
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
in();
solve();
out();
}
void in() {
cin >> n;
cur = 0;
memset(nxt1, -1, sizeof(nxt1));
for (int i = 1; i <= n; ++i) {
cin >> inp;
len = inp.size();
start[i] = cur + 1;
finish[i] = cur + len;
for (int i = len; i >= 1; --i) {
for (int j = 0; j < maxc; ++j) nxt1[cur + i][j] = nxt1[cur + i + 1][j];
nxt1[cur + i][inp[i - 1] - 'a'] = cur + i;
}
cur += len;
}
cin >> m;
for (int i = 1; i <= m; ++i) cin >> arr[i];
for (int i = 0; i < maxc; ++i) nxt2[m + 1][i] = {m, cur + 1};
for (int i = m; i >= 1; --i) {
for (int j = 0; j < maxc; ++j) {
nxt2[i][j] = nxt2[i + 1][j];
if (nxt1[start[arr[i]]][j] != -1)
nxt2[i][j] = {i, nxt1[start[arr[i]]][j]};
}
}
for (int i = 0; i < maxc; ++i) nxt2[0][i] = nxt2[1][i];
cin >> str;
str = '.' + str;
len = str.size() - 1;
}
void solve() {
dp[0][0] = {0, 0};
for (int i = 1; i <= len; ++i) dp[0][i] = {m, cur + 1};
for (int i = 1; i <= len; ++i) {
int c = str[i] - 'a';
dp[i][0] = {0, 0};
for (int j = 1; j <= i; ++j) {
dp[i][j] = dp[i - 1][j];
auto idx = dp[i - 1][j - 1];
auto idx2 = nxt2[idx.first + 1][c];
if (nxt1[idx.second + 1][c] != -1 &&
idx.second + 1 <= finish[arr[idx.first]])
idx2 = {idx.first, nxt1[idx.second + 1][c]};
dp[i][j] = min(dp[i][j], idx2);
}
for (int j = i + 1; j <= len; ++j) dp[i][j] = {m, cur + 1};
}
}
void out() {
for (int i = len; i >= 0; --i) {
if (dp[len][i].second <= cur) {
cout << i << '\n';
break;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (1 << 20) + 10;
long long dp[N];
void solve() {
long long n, m, b;
cin >> n >> m >> b;
vector<array<long long, 3>> info;
for (long long i = 0; i < n; ++i) {
long long x, k, p;
cin >> x >> k >> p;
long long val = 0;
while (p--) {
long long task;
cin >> task;
--task;
val |= (1 << task);
}
info.push_back({k, x, val});
}
memset(dp, 0x3f, sizeof dp);
sort(info.begin(), info.end());
long long ans = 2e18;
dp[0] = 0;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < (1 << m); ++j) {
long long mask = info[i][2] | j;
dp[mask] = min(dp[mask], dp[j] + info[i][1]);
}
ans = min(ans, dp[(1 << m) - 1] + info[i][0] * b);
}
if (ans == 2e18) ans = -1;
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
int n, m;
long long f[2005][2005], sum[2005][2005];
char ch[2005];
int main() {
cin >> n >> m;
scanf(" %s", ch + 1);
f[0][0] = 1;
for (int i = 0; i <= n; i++) sum[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= m; j++) {
if (i != n)
f[i][j] += sum[i - 1][j] * (ch[i] - 'a'), f[i][j] %= 1000000007;
if (i == n)
f[i][j] += sum[i - 1][j] * (ch[i] - 'a' + 1), f[i][j] %= 1000000007;
for (int k = 0; j - (n - i + 1) * (k + 1) >= 0 && i - 1 - k >= 0; k++) {
f[i][j] += f[i - 1 - k][j - (n - i + 1) * (k + 1)] * ('z' - ch[i]);
f[i][j] %= 1000000007;
}
sum[i][j] = sum[i - 1][j] + f[i][j];
sum[i][j] %= 1000000007;
}
cout << f[n][m] << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[1111111];
int cnt[30];
int ans[31111111];
int main() {
scanf("%s", s);
int i, j, now, p, t = 0, n;
for (i = 1; i <= 26; i++) {
for (j = 0; j < 26; j++) cnt[j] = 0;
j = i, now = 0;
for (p = 0; j && s[p]; p++)
if (!cnt[s[p] - 'a']++) {
j--;
now += (1 << (s[p] - 'a'));
}
if (j) break;
for (; s[p] && cnt[s[p] - 'a']; p++) cnt[s[p] - 'a']++;
ans[t++] = now;
for (j = 0; s[j]; j++)
if (!--cnt[s[j] - 'a']) {
now -= (1 << (s[j] - 'a'));
for (; s[p] && cnt[s[p] - 'a']++; p++)
;
if (!s[p])
break;
else
ans[t++] = (now += (1 << (s[p++] - 'a')));
for (; s[p] && cnt[s[p] - 'a']; p++) cnt[s[p] - 'a']++;
}
}
sort(ans, ans + t);
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", s);
for (j = 0; j < 26; j++) cnt[j] = 0;
now = 0;
for (p = 0; s[p]; p++)
if (!cnt[s[p] - 'a']++) now += (1 << (s[p] - 'a'));
printf("%d\n",
upper_bound(ans, ans + t, now) - lower_bound(ans, ans + t, now));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> prime, ans;
void sieve() {
vector<bool> chk(n + 10, false);
prime.emplace_back(2);
for (int i = 3; i <= n; i += 2) {
if (!chk[i]) {
prime.emplace_back(i);
for (int j = i; j <= n; j += i) chk[j] = true;
}
}
}
int main() {
cin >> n;
if (n == 1) {
cout << "0\n";
return 0;
}
sieve();
for (int p : prime) {
int tmp = p;
while (p <= n) {
ans.emplace_back(p);
p *= tmp;
}
}
cout << ans.size() << "\n";
for (int a : ans) cout << a << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
vector<string> v[27];
char aux[7];
bool dp1[55][55][30];
bool dp2[55][55][30];
int dp[55][55];
void citire() {
int n;
cin >> a;
cin >> b;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> aux;
string temp;
temp = aux[3];
temp += aux[4];
v[aux[0] - 'a'].push_back(temp);
}
}
void dinamiciAjutatoare() {
for (int i = 1; i <= a.size(); i++) {
dp1[i][i][a[i - 1] - 'a'] = true;
for (int j = i - 1; j >= 1; j--) {
for (int c = 0; c <= 'z' - 'a'; c++) {
for (int p = 0; p < v[c].size(); p++) {
for (int k = j; k < i; k++) {
dp1[j][i][c] |= (dp1[j][k][v[c][p][0] - 'a'] &&
dp1[k + 1][i][v[c][p][1] - 'a']);
}
}
}
}
}
for (int i = 1; i <= b.size(); i++) {
dp2[i][i][b[i - 1] - 'a'] = true;
for (int j = i - 1; j >= 1; j--) {
for (int c = 0; c <= 'z' - 'a'; c++) {
for (int p = 0; p < v[c].size(); p++) {
for (int k = j; k < i; k++) {
dp2[j][i][c] |= (dp2[j][k][v[c][p][0] - 'a'] &&
dp2[k + 1][i][v[c][p][1] - 'a']);
}
}
}
}
}
}
void solveDP() {
for (int i = 1; i <= a.size(); i++) {
for (int j = 1; j <= b.size(); j++) {
for (int c = 0; c <= 'z' - 'a'; c++) {
dp[i][j] |= (dp1[1][i][c] && dp2[1][j][c]);
}
if (dp[i][j] == 1) continue;
for (int i2 = 1; i2 < i; i2++) {
for (int j2 = 1; j2 < j; j2++) {
for (int c = 0; c <= 'z' - 'a'; c++) {
if (dp[i2][j2] == 0 ||
(dp1[i2 + 1][i][c] && dp2[j2 + 1][j][c]) == false)
continue;
if (dp[i][j] == 0 || dp[i2][j2] + 1 < dp[i][j]) {
dp[i][j] = dp[i2][j2] + 1;
}
}
}
}
}
}
}
void afisareSolutie() {
if (dp[a.size()][b.size()] == 0)
cout << -1;
else
cout << dp[a.size()][b.size()];
}
int main() {
citire();
dinamiciAjutatoare();
solveDP();
afisareSolutie();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ar[505], br[505];
char ch[505];
int n, m;
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]);
for (int i = 1; i <= n; i++) scanf("%d", &br[i]);
if (n & 1 && ar[n / 2 + 1] != br[n / 2 + 1]) {
printf("No\n");
return;
}
map<pair<int, int>, int> mp;
for (int i = 1; i <= n / 2; i++) {
if (ar[i] > ar[n - i + 1]) swap(ar[i], ar[n - i + 1]);
mp[{ar[i], ar[n - i + 1]}]++;
}
for (int i = 1; i <= n / 2; i++) {
if (br[i] > br[n - i + 1]) swap(br[i], br[n - i + 1]);
if (mp[{br[i], br[n - i + 1]}] == 0) {
printf("No\n");
return;
}
mp[{br[i], br[n - i + 1]}]--;
}
printf("Yes\n");
}
int main() {
int t = 1;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
inline void print(int x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x >= 10) print(x / 10);
putchar((x % 10) | 48);
}
int T;
int n;
int a[510];
int pos[510];
struct node {
int val, id;
} b[510];
bool cmp(node x, node y) {
return x.val == y.val ? x.id < y.id : x.val < y.val;
}
int m;
int ans[250010];
map<int, int> vis;
int main() {
T = read();
while (T--) {
n = read();
m = 0;
for (int i = 1; i <= n; ++i) a[i] = read(), b[i].val = a[i], b[i].id = i;
sort(b + 1, b + n + 1, cmp);
for (int i = 1; i <= n; ++i) a[b[i].id] = i;
for (int i = 1; i <= n; ++i) pos[a[i]] = i;
for (int i = 1; i <= n - 2; ++i) {
int p = pos[i];
while (p >= i + 2) {
pos[a[p - 1]] = p, pos[a[p - 2]] = p - 1;
pos[a[p]] = p - 2;
swap(a[p - 2], a[p]);
swap(a[p - 1], a[p]);
ans[++m] = p - 2;
p -= 2;
}
if (p == i + 1) {
ans[++m] = i, ans[++m] = i;
pos[a[p]] = p - 1;
pos[a[p - 1]] = p + 1, pos[a[p + 1]] = p;
int t1 = a[p - 1], t2 = a[p + 1];
a[p - 1] = a[p], a[p] = t2, a[p + 1] = t1;
}
}
if (b[a[n - 1]].val > b[a[n]].val) {
vis.clear();
bool flag = 0;
for (int i = 1; i <= n; ++i) {
if (!vis.count(b[i].val)) {
vis[b[i].val] = b[i].id;
a[b[i].id] = i;
} else {
a[b[i].id] = i;
if (!flag) swap(a[vis[b[i].val]], a[b[i].id]);
flag = 1;
vis.erase(b[i].val);
}
}
for (int i = 1; i <= n; ++i) pos[a[i]] = i;
m = 0;
for (int i = 1; i <= n - 2; ++i) {
int p = pos[i];
while (p >= i + 2) {
pos[a[p - 1]] = p, pos[a[p - 2]] = p - 1;
pos[a[p]] = p - 2;
swap(a[p - 2], a[p]);
swap(a[p - 1], a[p]);
ans[++m] = p - 2;
p -= 2;
}
if (p == i + 1) {
ans[++m] = i, ans[++m] = i;
pos[a[p]] = p - 1;
pos[a[p - 1]] = p + 1, pos[a[p + 1]] = p;
int t1 = a[p - 1], t2 = a[p + 1];
a[p - 1] = a[p], a[p] = t2, a[p + 1] = t1;
}
}
if (b[a[n - 1]].val > b[a[n]].val) {
printf("-1\n");
} else {
printf("%d\n", m);
for (int i = 1; i <= m; ++i) printf("%d ", ans[i]);
printf("\n");
}
} else {
printf("%d\n", m);
for (int i = 1; i <= m; ++i) printf("%d ", ans[i]);
printf("\n");
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long Min(long long a, long long b) { return a < b ? a : b; }
long long Max(long long a, long long b) { return a > b ? a : b; }
long long l = 1, r, k, n;
char anss[15];
bool ask(long long a, long long bb) {
printf("%lld %lld\n", a, bb);
fflush(stdout);
scanf("%s", anss);
return anss[0] == 'Y' ? 1 : 0;
}
int main() {
std::srand(std::time(0));
long long yy, mid, h, n;
bool x;
scanf("%lld%lld", &n, &k);
r = n;
while (1) {
yy = r - l + 1;
mid = (l + r) >> 1;
if (yy <= 41) {
h = rand() % yy + l;
x = ask(h, h);
mid = l - 1;
if (x) return 0;
} else
x = ask(l, mid);
if (x)
l = Max(1ll, l - k), r = Min(n, mid + k);
else
l = Max(1ll, mid + 1 - k), r = Min(n, r + k);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 7e5 + 10;
const long long mod = 978123409;
const long double pi = 3.14159265359;
long long st[4 * maxn];
long long st1[4 * maxn];
struct tk {
pair<long long, long long> get(long long id, long long left, long long right,
long long x, long long y) {
if (left > y || right < x) return make_pair(0, 0);
if (x <= left && right <= y) {
return make_pair(st[id], st1[id]);
}
long long mid = (left + right) / 2;
pair<long long, long long> a = get(id * 2, left, mid, x, y);
pair<long long, long long> b = get(id * 2 + 1, mid + 1, right, x, y);
return make_pair(a.first + b.first, a.second + b.second);
}
void update(long long id, long long left, long long right, long long pos) {
if (pos < left || pos > right) return;
if (left == right) {
st[id] = 1;
st1[id] = left;
return;
}
long long mid = (left + right) / 2;
update(id * 2, left, mid, pos);
update(id * 2 + 1, mid + 1, right, pos);
st[id] = (st[id * 2] + st[id * 2 + 1]);
st1[id] = (st1[id * 2] + st1[id * 2 + 1]);
}
long long walk(long long id, long long left, long long right, long long k) {
if (st[id] < k) return -1;
if (left == right) return left;
long long mid = (left + right) / 2;
long long t = walk(id * 2, left, mid, k);
if (t == -1) return walk(id * 2 + 1, mid + 1, right, k - st[id * 2]);
return t;
}
} man;
long long a[maxn];
long long pos[maxn];
long long ans[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("t.inp", "r")) {
freopen("test.inp", "r", stdin);
freopen("test.out", "w", stdout);
}
long long n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
long long cnt = 0;
for (int i = 1; i <= n; i++) {
auto h1 = man.get(1, 1, n, pos[i], n);
cnt += h1.first;
man.update(1, 1, n, pos[i]);
long long h = i / 2;
ans[i] = 1e15;
if (h >= 1) {
auto p = man.walk(1, 1, n, h);
auto t = man.get(1, 1, n, 1, p);
auto t1 = man.get(1, 1, n, p, n);
ans[i] = cnt + p * t.first - t.second + (t1.second - p * t1.first) -
t.first * (t.first - 1) / 2 - t1.first * (t1.first - 1) / 2;
}
h++;
if (h >= 1 && h <= i) {
auto p = man.walk(1, 1, n, h);
auto t = man.get(1, 1, n, 1, p);
auto t1 = man.get(1, 1, n, p, n);
ans[i] =
min(ans[i],
cnt + p * t.first - t.second + (t1.second - p * t1.first) -
t.first * (t.first - 1) / 2 - t1.first * (t1.first - 1) / 2);
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 4e18;
const long double pai = acos(-1);
int n, m;
int f(int x, int y) { return x * m + y; }
vector<int> v[1000009], g[1000009];
int deg[1000009], p[1000009], val[1000009];
int get(int node) {
if (node == p[node]) return node;
return p[node] = get(p[node]);
}
void merge(int a, int b) {
a = get(a), b = get(b);
if (a == b) return;
if (g[a].size() < g[b].size()) swap(a, b);
for (auto u : g[b]) g[a].push_back(u);
g[b].clear();
p[b] = a;
}
void topo() {
queue<int> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x = get(f(i, j));
if (deg[x] == 0 && x == f(i, j)) {
q.push(x);
}
}
}
while (q.size()) {
int node = q.front();
int X = val[node];
q.pop();
for (auto u : g[node]) {
if (deg[u] == 0) continue;
deg[u]--;
val[u] = max(val[u], X + 1);
if (deg[u] == 0) q.push(u);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
v[i].resize(m + 9);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &v[i][j]);
int x = f(i, j);
p[x] = x;
}
}
for (int i = 0; i < n; i++) {
vector<pair<int, int> > ret;
for (int j = 0; j < m; j++) {
ret.push_back({v[i][j], f(i, j)});
}
sort(ret.begin(), ret.end());
for (int j = 0; j < ret.size() - 1; j++) {
int a = ret[j].first, A = ret[j].second;
int b = ret[j + 1].first, B = ret[j + 1].second;
if (a == b) merge(A, B);
}
}
for (int j = 0; j < m; j++) {
vector<pair<int, int> > ret;
for (int i = 0; i < n; i++) {
ret.push_back({v[i][j], f(i, j)});
}
sort(ret.begin(), ret.end());
for (int i = 0; i < ret.size() - 1; i++) {
int a = ret[i].first, A = ret[i].second;
int b = ret[i + 1].first, B = ret[i + 1].second;
if (a == b) merge(A, B);
}
}
for (int i = 0; i < n; i++) {
vector<pair<int, int> > ret;
for (int j = 0; j < m; j++) {
ret.push_back({v[i][j], f(i, j)});
}
sort(ret.begin(), ret.end());
for (int j = 0; j < ret.size() - 1; j++) {
int a = ret[j].first, A = ret[j].second;
int b = ret[j + 1].first, B = ret[j + 1].second;
if (a < b) {
A = get(A);
B = get(B);
deg[B]++;
g[A].push_back(B);
}
}
}
for (int j = 0; j < m; j++) {
vector<pair<int, int> > ret;
for (int i = 0; i < n; i++) {
ret.push_back({v[i][j], f(i, j)});
}
sort(ret.begin(), ret.end());
for (int i = 0; i < ret.size() - 1; i++) {
int a = ret[i].first, A = ret[i].second;
int b = ret[i + 1].first, B = ret[i + 1].second;
if (a < b) {
A = get(A);
B = get(B);
deg[B]++;
g[A].push_back(B);
}
}
}
topo();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%d ", val[get(f(i, j))] + 1);
}
printf("\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double p[100010][101];
double u[101], v[101];
int d[100010], dd[100010];
double g(int n, int k) {
int i;
double re = 1;
for (i = 0; i < k; i++) {
re = re * (n - i) / (i + 1);
}
return re;
}
double f(int a, int b, int m, int c) {
if (m - c > b || c > a || m > a + b) return 0;
return g(a, c) * g(b, m - c) / g(a + b, m);
}
int main() {
int n, m, x, y, z, i, j;
double ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
dd[i] = d[i] = x;
p[i][x] = 1;
if (x == 0) ans++;
}
scanf("%d", &m);
while (m--) {
scanf("%d%d%d", &x, &y, &z);
int ddd = min(dd[x], d[x]);
for (i = 0; i <= ddd; i++) {
u[i] = p[x][i];
v[i] = 0;
}
for (i = 0; i <= ddd; i++) {
for (j = 0; j <= z && j <= i; j++) {
v[i - j] += u[i] * f(i, d[x] - i, z, j);
}
}
ans += v[0] - u[0];
for (i = 0; i <= ddd; i++) {
p[x][i] = v[i];
}
d[y] += z;
d[x] -= z;
printf("%.10f\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Node {
int x, y, z;
Node() {}
Node(int _x, int _y, int _z) : x(_x), y(_y), z(_z) {}
bool operator<(const Node& _oth) const { return y > _oth.y; }
};
void solve() {
int n;
cin >> n;
vector<Node> a(n);
for (int i = 0; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
a[i] = {x, y, z};
}
sort(a.begin(), a.end());
vector<ll> dp(n + 1);
for (auto& p : a) {
for (int i = n - 1; i >= 0; i--) {
dp[i + 1] = max(dp[i + 1], dp[i] + p.x - (ll)p.y * i);
dp[i] = max(dp[i], dp[i] + p.x - (ll)p.y * p.z);
}
}
cout << *max_element(dp.begin(), dp.end());
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7;
long long w[N];
long long get(long long n) {
if (n & 1) {
return n * (n - 1) / 2 + 1;
} else {
return n * (n - 1) / 2 + (n >> 1);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
long long tmp;
for (long long i = 0; i < m; ++i) cin >> tmp >> w[i];
sort(w, w + m);
reverse(w, w + m);
long long l = -1;
long long r = m + 1;
while (l < r - 1) {
long long mid = (l + r) >> 1;
if (get(mid) <= n)
l = mid;
else
r = mid;
}
long long ans = 0;
for (long long i = 0; i < l; ++i) {
ans += w[i];
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ss[100005];
int bb[100005];
int main() {
ios::sync_with_stdio(false);
int n, s;
cin >> n >> s;
for (int(i) = 0; (i) < (n); (i)++) {
string s1;
cin >> s1;
int a1, b1;
cin >> a1 >> b1;
if (s1 == "B") {
bb[a1] += b1;
} else {
ss[a1] += b1;
}
}
int i = 0;
int cnt = 0;
for (i = 0; i < 100005; i++) {
if (ss[i] > 0) cnt++;
if (cnt == s) break;
}
for (int j = i; j >= 0; j--) {
if (ss[j] > 0) {
cout << "S " << j << " " << ss[j] << endl;
}
}
cnt = 0;
for (i = 100004; i >= 0; i--) {
if (bb[i] > 0) {
cout << "B " << i << " " << bb[i] << endl;
cnt++;
}
if (cnt == s) break;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<unsigned> a(n);
for (auto &e : a) {
cin >> e;
}
vector<unsigned> pl(n), pr(n);
pl[0] = -1;
for (int i = 0; i + 1 < n; ++i) {
pl[i + 1] = pl[i] & ~a[i];
}
pr[n - 1] = -1;
for (int i = n - 1; i > 0; --i) {
pr[i - 1] = pr[i] & ~a[i];
}
int imax = 0;
unsigned vmax = 0;
for (int i = 0; i < n; ++i) {
unsigned t = pl[i] & pr[i] & a[i];
if (t > vmax) {
imax = i;
vmax = t;
}
}
cout << a[imax] << ' ';
for (int i = 0; i < n; ++i) {
if (i != imax) {
cout << a[i] << ' ';
}
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int inf = (int)1e9 + 123;
const long long infl = (long long)1e18 + 123;
const double eps = 1e-10;
const int MAX_N = (int)5e5 + 123;
int n;
pair<int, int> a[MAX_N];
struct Tree {
int mini, id, add;
Tree operator+(const Tree &b) {
if (mini <= b.mini) return Tree({mini, id, 0});
return Tree({b.mini, b.id, 0});
}
} t[4 * MAX_N];
void build(int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
t[v] = Tree({a[tl].first, tl, 0});
return;
}
int tm = (tl + tr) / 2;
build(v * 2, tl, tm), build(v * 2 + 1, tm + 1, tr);
t[v] = t[v * 2] + t[v * 2 + 1];
}
void push(int v, int tl, int tr) {
if (!t[v].add) return;
t[v].mini += t[v].add;
if (tl != tr) {
t[v * 2].add += t[v].add;
t[v * 2 + 1].add += t[v].add;
}
t[v].add = 0;
}
void update(int l, int r, int x, int v = 1, int tl = 1, int tr = n) {
push(v, tl, tr);
if (tl > r || l > tr) return;
if (tl >= l && tr <= r) {
t[v].add += x;
push(v, tl, tr);
return;
}
int tm = (tl + tr) / 2;
update(l, r, x, v * 2, tl, tm), update(l, r, x, v * 2 + 1, tm + 1, tr);
t[v] = t[v * 2] + t[v * 2 + 1];
}
Tree get(int l, int r, int v = 1, int tl = 1, int tr = n) {
push(v, tl, tr);
if (tl > r || l > tr) return Tree({inf, -1, 0});
if (tl >= l && tr <= r) return t[v];
int tm = (tl + tr) / 2;
return get(l, r, v * 2, tl, tm) + get(l, r, v * 2 + 1, tm + 1, tr);
}
int where[MAX_N];
set<int> first, second, zero;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a + 1, a + n + 1);
build();
for (int i = 1; i <= n; i++) where[a[i].second] = i;
for (int it = 1; it <= n; it++) {
int i = where[it];
Tree now = get(i, i);
if (now.mini == 0) {
zero.insert(i);
} else if (now.mini < 0) {
second.insert(i);
update(i, n, 1);
if (a[*second.rbegin()].first == 0 - ((int)((second).size()) - 1)) {
auto it = --second.end();
update(*it, n, -1);
zero.insert(*it);
second.erase(it);
} else if (!zero.empty()) {
auto it = zero.begin();
update(*it, n, -1);
first.insert(*it);
zero.erase(it);
}
} else {
first.insert(i);
update(i, n, -1);
Tree nw = get(i, n);
if (nw.mini == -1) {
assert(first.count(nw.id));
update(nw.id, n, 1);
first.erase(nw.id);
zero.insert(nw.id);
}
}
printf("%d\n", (int)((first).size()) - (int)((second).size()));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 1e5 * 2 + 1;
const int TMXN = 1e5 * 8 + 1;
const int INF = 1e9 + 7;
const long long INFL = 1e18;
int n, m, l, r, res, c, mink, x;
int a[MXN], two = 1;
pair<int, int> zabei, zabei1;
pair<int, int> t[TMXN], d[TMXN];
inline void build(int v, int tl, int tr) {
if (tl == tr)
t[v].first = a[tl], t[v].second = tl, d[v].first = a[tl], d[v].second = tl;
else {
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
t[v].first = max(t[v * 2].first, t[v * 2 + 1].first);
if (t[v * 2].first > t[v * 2 + 1].first) {
t[v].second = t[v * 2].second;
} else {
t[v].second = t[v * 2 + 1].second;
}
d[v].first = min(d[v * 2].first, d[v * 2 + 1].first);
if (d[v * 2].first < d[v * 2 + 1].first) {
d[v].second = d[v * 2].second;
} else {
d[v].second = d[v * 2 + 1].second;
}
}
}
pair<int, int> combine(pair<int, int> c, pair<int, int> b) {
if (c.first > b.first) {
return c;
} else {
return b;
}
}
pair<int, int> combine1(pair<int, int> c, pair<int, int> b) {
if (c.first < b.first) {
return c;
} else {
return b;
}
}
pair<int, int> get(int v, int tl, int tr, int l, int r) {
if (l > r) return zabei;
if (l == tl && r == tr) return t[v];
int tm = (tl + tr) / 2;
return combine(get(v * 2, tl, tm, l, min(r, tm)),
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
pair<int, int> getmin(int v, int tl, int tr, int l, int r) {
if (l > r) return zabei1;
if (l == tl && r == tr) return d[v];
int tm = (tl + tr) / 2;
return combine1(getmin(v * 2, tl, tm, l, min(r, tm)),
getmin(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d", &n, &m);
zabei.first = 0;
zabei.second = 0;
zabei1.first = INF;
zabei.second = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
build(1, 1, n);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &l, &r, &x);
if (get(1, 1, n, l, r).first != x && get(1, 1, n, l, r).first != 0) {
cout << get(1, 1, n, l, r).second << '\n';
continue;
}
if (getmin(1, 1, n, l, r).first != x &&
getmin(1, 1, n, l, r).first != INF) {
cout << getmin(1, 1, n, l, r).second << '\n';
continue;
}
cout << -1 << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
const long long int inf = 1e18;
vector<long long int> v, arr;
void pf() {}
long long int sqrtfun(long long int num) {
long long int lo = 0, hi = (long long int)2e9, mid;
if (num == 1) return num;
while (lo + 1 < hi) {
mid = lo + hi >> 1LL;
if (mid * mid == num)
return mid;
else if (mid * mid > num)
hi = mid;
else
lo = mid;
}
return (mid * mid > num) ? mid - 1 : mid;
}
long long int get(long long int r) {
int ans = upper_bound(arr.begin(), arr.end(), r) - arr.begin();
return ans + sqrtl(r) - 1;
}
void solve() {
for (long long int i = 2; i <= N; i++) {
for (long long int j = i * i * i; j <= inf; j *= i) {
long long int x = sqrtfun(j);
if (x * x != j) v.push_back(j);
if (inf / i < j) break;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t, l, r, ans = 0;
cin >> t;
solve();
sort(v.begin(), v.end());
for (auto i : v) {
if (arr.empty())
arr.push_back(i);
else if (arr.back() != i)
arr.push_back(i);
}
while (t--) {
cin >> r;
cout << r - get(r) - 1 << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > vec[5005];
long long mn[5005], ans;
void solve() {
int n;
scanf("%d", &n);
vector<int> a(n - 1);
for (int i = 0; i < n - 1; i++) {
scanf("%d", &a[i]);
a[i]--;
}
int root = a[0];
int last = -1;
vector<int> used(n, 0);
printf("%d\n", root + 1);
int cur = n - 1;
for (int i = 0; i < n - 1; i++) {
used[a[i]] = 1;
while (used[cur]) cur--;
if (i == n - 2 || used[a[i + 1]]) {
printf("%d %d\n", a[i] + 1, cur + 1);
used[cur] = 1;
} else
printf("%d %d\n", a[i + 1] + 1, a[i] + 1);
}
}
int main() {
long long t;
t = 1;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long n, m;
cin >> n >> m;
vector<vector<pair<long long, string> > > v(m + 1);
string x;
long long y;
long long z;
for (long long i = 0; i < n; i++) {
cin >> x >> y >> z;
v[y].push_back(make_pair(z, x));
}
for (long long i = 1; i <= m; i++) {
sort(v[i].rbegin(), v[i].rend());
vector<pair<long long, string> > temp;
int j = 0;
for (vector<pair<long long, string> >::iterator it = v[i].begin();
it != v[i].end() && j < 3; it++, j++) {
temp.push_back(*it);
}
if (temp.size() == 2)
cout << temp[0].second << " " << temp[1].second << "\n";
else {
if (temp[1].first == temp[2].first)
cout << "?"
<< "\n";
else
cout << temp[0].second << " " << temp[1].second << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int a, b, c, d;
long long la;
int t;
cin >> t;
while (t--) {
long long res;
cin >> a >> b >> c >> d;
res = b;
a -= b;
if (a <= 0) {
cout << res << endl;
continue;
}
d = c - d;
if (d <= 0) {
cout << -1 << endl;
continue;
}
la = a / d;
if (a % d) la++;
res = res + la * c;
cout << res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 8 * 1e18;
const int big = 1e6 + 7;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y, long long p = mod) {
long long res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y >>= 1;
x = (x * x) % p;
}
return res;
}
long long lcm(long long x, long long y) { return ((x * y) / (gcd(x, y))); }
long long modi(long long x, long long p = mod) { return power(x, p - 2, p); }
void solve() {
int n;
long long m;
cin >> n >> m;
vector<long long> dp(n + 1, 0);
dp[1] = 1;
long long sum = 1;
for (int i = 2; i < n + 1; i++) {
long long an = sum;
int sq = sqrt(i);
for (int j = 2; j < sq + 1; j++) (an += dp[i / j]) %= m;
for (int j = 1; j < sq + 1; j++)
(an += dp[j] * ((i / j) - (i / (j + 1)))) %= m;
if ((i / sq) == sq) an -= dp[sq];
(an += m) %= m;
dp[i] = an;
sum += an;
}
cout << dp[n] << endl;
}
void fastio() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void preprocessing() {}
int main() {
cout << setprecision(10);
bool q = 0;
fastio();
int t = 1;
if (q) cin >> t;
preprocessing();
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
const long long inf = 100000000000000;
using namespace std;
template <class T>
void read_vector(vector<T> &__cur) {
for (T &_c : __cur) {
cin >> _c;
}
}
template <class T>
void write_vector(vector<T> &__cur, string separator) {
for (T &_c : __cur) {
cout << _c << separator;
}
}
unsigned long long fast_pow(unsigned long long a, unsigned long long n) {
unsigned long long res = 1;
while (n) {
if (n & 1) {
res *= a;
}
a *= a;
n >>= 1;
}
return res;
}
vector<set<int>> g, cg;
vector<pair<long long, long long>> bridges;
vector<bool> used;
vector<int> fup, tin, number;
int timer = 0;
void dfs(int v, int p) {
used[v] = true;
tin[v] = timer++;
fup[v] = tin[v];
for (int u : g[v]) {
if (u == p) {
continue;
}
if (used[u]) {
fup[v] = min(fup[v], tin[u]);
} else {
dfs(u, v);
fup[v] = min(fup[v], fup[u]);
if (fup[u] > tin[v]) bridges.push_back({v, u});
}
}
}
void dfs2(int v, int num) {
used[v] = true;
number[v] = num;
for (int u : g[v]) {
if (!used[u]) {
dfs2(u, num);
}
}
}
void dfs3(int v, vector<int> &dist, int len) {
used[v] = true;
dist[v] = len;
for (int u : cg[v]) {
if (!used[u]) {
dfs3(u, dist, len + 1);
}
}
}
void solve() {
long long n, m;
cin >> n >> m;
g.resize(n);
tin.resize(n, 0);
fup.resize(n);
number.resize(n);
used.resize(n, false);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].insert(b);
g[b].insert(a);
}
dfs(0, -1);
for (auto br : bridges) {
g[br.first].erase(br.second);
g[br.second].erase(br.first);
}
used.clear();
used.resize(n, false);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
dfs2(i, cnt);
cnt++;
}
}
cg.resize(cnt);
for (auto br : bridges) {
cg[number[br.first]].insert(number[br.second]);
cg[number[br.second]].insert(number[br.first]);
}
used.clear();
used.resize(cnt, false);
vector<int> d(cnt, 0);
dfs3(0, d, 0);
int v = max_element(d.begin(), d.end()) - d.begin();
d.clear();
d.resize(cnt, 0);
used.clear();
used.resize(cnt, false);
dfs3(v, d, 0);
cout << *max_element(d.begin(), d.end());
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(10);
srand(time(0));
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int sum[101][30030];
char g[101][30030];
int main() {
int i, j, ok = true;
cin >> n >> m;
for (i = 0; i < n; i++) {
bool f = false;
scanf("%s", g[i]);
for (j = 0; j < 3 * m; j++) {
if (j == 0)
sum[i][j + 1] = (g[i][j] == '1');
else
sum[i][j + 1] = sum[i][j] + (g[i][j % m] == '1');
if (sum[i][j + 1]) f = true;
}
if (!f) ok = false;
}
if (!ok) {
puts("-1");
return 0;
}
int res = 1000000000;
for (i = m + 1; i <= 2 * m; i++) {
int cnt = 0;
for (j = 0; j < n; j++) {
int l = 1, r = i, mid, p1, p2;
while (l <= r) {
mid = l + r >> 1;
if (sum[j][i] - sum[j][mid - 1]) {
p1 = mid;
l = mid + 1;
} else
r = mid - 1;
}
l = i, r = 3 * m;
while (l <= r) {
mid = l + r >> 1;
if (sum[j][mid] - sum[j][i - 1]) {
p2 = mid;
r = mid - 1;
} else
l = mid + 1;
}
cnt += min(i - p1, p2 - i);
}
res = min(res, cnt);
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
void solve() {
long double a, b, ans = 1e9;
cin >> a >> b;
int n;
cin >> n;
while (n--) {
long double x, y, v;
cin >> x >> y >> v;
ans = min(ans, sqrt(pow(x - a, 2) + pow(y - b, 2)) / v);
}
cout << fixed << setprecision(15) << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long n, m, temp, ans = 0;
long long a[N];
long long check(long long cur) {
if (cur % 2)
return (cur * (cur - 1) / 2 + 1) <= n;
else
return (cur * (cur - 1) / 2 + cur / 2) <= n;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (long long i = 1; i <= m; i++) cin >> temp >> a[i];
sort(a + 1, a + m + 1);
reverse(a + 1, a + m + 1);
for (long long i = 1; i <= m; i++) {
if (check(i))
ans += a[i];
else
break;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, V = 1000000, MV = 1001000, Inf = 1 << 30;
const double eps(1e-8);
int n, x[N] = {}, y[N] = {};
double ul[MV + MV] = {}, ur[MV + MV] = {}, *l = ul + MV, *r = ur + MV;
double ans = 0;
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &x[i], &y[i]);
x[n + 1] = x[1], y[n + 1] = y[1];
}
long long sqrsum(long long l, long long r) {
if (l == 1)
return r * (r + 1) * (r + r + 1) / 6;
else if (l > 1)
return sqrsum(1, r) - sqrsum(1, l - 1);
else
return sqrsum(1, -l) + sqrsum(1, r);
}
void work() {
double s0 = 0, s1 = 0, s2 = 0;
for (int i = -V; i <= V; ++i) l[i] = Inf, r[i] = -Inf;
int lx = V, rx = -V;
for (int i = 1; i <= n; ++i) {
lx = min(lx, x[i]), rx = max(rx, x[i]);
if (x[i] == x[i + 1])
l[x[i]] = min(y[i], y[i + 1]), r[x[i]] = max(y[i], y[i + 1]);
else {
bool flag = false;
if (x[i] > x[i + 1]) flag = true;
if (flag) swap(x[i], x[i + 1]), swap(y[i], y[i + 1]);
double t = 1.0 / (x[i + 1] - x[i]);
for (int j = x[i]; j <= x[i + 1]; ++j) {
double c = ((long long)(j - x[i]) * y[i + 1] +
(long long)(x[i + 1] - j) * y[i]) *
t;
l[j] = min(l[j], c);
r[j] = max(r[j], c);
}
if (flag) swap(x[i], x[i + 1]), swap(y[i], y[i + 1]);
}
}
for (int i = lx; i <= rx; ++i) {
long long tl = (int)ceil(l[i]), tr = (int)floor(r[i]);
s0 += tr - tl + 1;
s1 += (tr + tl) * (tr - tl + 1) / 2;
s2 += sqrsum(tl, tr);
}
ans += (s0 * s2 - s1 * s1) / s0 / (s0 - 1);
}
void swapxy() {
for (int i = 1; i <= n + 1; ++i) swap(x[i], y[i]);
}
int main() {
init();
work();
swapxy();
work();
printf("%.10f\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265359;
long long int INF = 1e18 + 10;
long long int MOD = 998244353;
long long int mod = 1e9 + 7;
inline long long int add(long long int a, long long int b, long long int m) {
if ((a + b) >= m) return (a + b) % m;
return a + b;
}
inline long long int mul(long long int a, long long int b, long long int m) {
if ((a * b) < m) return a * b;
return (a * b) % m;
}
long long int power(long long int x, long long int y, long long int m) {
long long int res = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % m;
y = y >> 1;
x = (x * x) % m;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void solve() {
int n, m;
cin >> n >> m;
int cost = 0;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
cost += a[i];
}
cost *= 2;
if (n == 2) {
cout << -1 << "\n";
return;
}
if (n == m) {
cout << cost << "\n";
for (int i = 0; i < n; i++) {
cout << i % n + 1 << " " << (i + 1) % n + 1 << "\n";
}
return;
}
cout << -1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t-- > 0) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string change(string s) {
string a = "";
for (int i = 0; i < s.size(); i++) {
if (isalpha(s[i])) {
a += toupper(s[i]);
}
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s1, s2, s3, s4;
cin >> s1 >> s2 >> s3;
s1 = change(s1);
s2 = change(s2);
s3 = change(s3);
int t;
cin >> t;
while (t--) {
cin >> s4;
s4 = change(s4);
if (s4 == s1 + s2 + s3 || s4 == s2 + s1 + s3 || s4 == s3 + s1 + s2 ||
s4 == s2 + s3 + s1 || s4 == s1 + s3 + s2 || s4 == s3 + s2 + s1)
cout << "ACC\n";
else
cout << "WA\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long powmod(long long a, long long b, long long MOD) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ans;
}
inline void getInt(int* p);
const int maxn = 1000010;
const int inf = 0x3f3f3f3f;
int a[maxn];
int n;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n * 2; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n * 2);
if (a[n] == a[n + 1]) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
}
inline void getInt(int* p) {
char ch;
do {
ch = getchar();
} while (ch == ' ' || ch == '\n');
if (ch == '-') {
*p = -(getchar() - '0');
while ((ch = getchar()) >= '0' && ch <= '9') {
*p = *p * 10 - ch + '0';
}
} else {
*p = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') {
*p = *p * 10 + ch - '0';
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
const int INF = 0x3f3f3f3f;
int nx, ny;
int g[N][N];
int linker[N], lx[N], ly[N];
int slack[N];
bool visx[N], visy[N];
bool DFS(int x) {
visx[x] = true;
for (int y = 0; y < ny; y++) {
if (visy[y]) continue;
int tmp = lx[x] + ly[y] - g[x][y];
if (tmp == 0) {
visy[y] = true;
if (linker[y] == -1 || DFS(linker[y])) {
linker[y] = x;
return true;
}
} else if (slack[y] > tmp)
slack[y] = tmp;
}
return false;
}
int KM() {
memset(linker, -1, sizeof(linker));
memset(ly, 0, sizeof(ly));
for (int i = 0; i < nx; i++) {
lx[i] = -INF;
for (int j = 0; j < ny; j++)
if (g[i][j] > lx[i]) lx[i] = g[i][j];
}
for (int x = 0; x < nx; x++) {
for (int i = 0; i < ny; i++) slack[i] = INF;
while (true) {
memset(visx, false, sizeof(visx));
memset(visy, false, sizeof(visy));
if (DFS(x)) break;
int d = INF;
for (int i = 0; i < ny; i++)
if (!visy[i] && d > slack[i]) d = slack[i];
for (int i = 0; i < nx; i++)
if (visx[i]) lx[i] -= d;
for (int i = 0; i < ny; i++) {
if (visy[i])
ly[i] += d;
else
slack[i] -= d;
}
}
}
int res = 0;
for (int i = 0; i < ny; i++)
if (linker[i] != -1) res += g[linker[i]][i];
return res;
}
int n, m;
int a[N];
int f(int x) {
int cnt = 0;
while (x) {
cnt += x & 1;
x >>= 1;
}
return cnt;
}
int used[N];
int val[N];
vector<pair<int, int> > out;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
nx = n;
ny = n + m;
for (int i = 0; i < nx; ++i)
for (int j = 0; j < ny; ++j) g[i][j] = -INF;
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j) g[j][n + i] = -f(a[j]);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (a[i] != a[j])
g[j][i] = -f(a[j]);
else
g[j][i] = 0;
int ans = -KM();
memset(used, -1, sizeof(used));
for (int i = 0; i < n; ++i) {
if (used[i] == -1) {
for (int j = 0; j < m; ++j)
if (linker[j + n] == i) {
out.push_back(pair<int, int>(j, a[i]));
out.push_back(pair<int, int>(-1, j));
val[j] = a[i];
if (linker[i] != -1) used[linker[i]] = j;
break;
}
} else {
int tx = used[i];
if (val[tx] == a[i])
out.push_back(pair<int, int>(-1, tx));
else {
out.push_back(pair<int, int>(tx, a[i]));
out.push_back(pair<int, int>(-1, tx));
}
val[tx] = a[i];
if (linker[i] != -1) used[linker[i]] = tx;
}
}
printf("%d %d\n", (int)out.size(), ans);
for (int i = 0; i < (int)out.size(); ++i) {
pair<int, int> tmp = out[i];
if (tmp.first == -1) {
printf("print(%c)\n", (char)(tmp.second + 'a'));
} else {
printf("%c=%d\n", (char)(tmp.first + 'a'), tmp.second);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
bool p = true;
int n;
cin >> s >> n;
if (s.length() % n == 0) {
for (int i = 0; i < n; i++) {
for (int k = 0; k < s.length() / n / 2; k++)
if (s[i * s.length() / n + k] != s[(i + 1) * s.length() / n - k - 1])
p = false;
}
if (p)
cout << "YES";
else
cout << "NO";
} else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, a2, x, k = 0, j, L;
cin >> a1 >> a2;
if (a1 == 1 && a2 == 1) {
cout << k;
return 0;
}
while (a1 != 0 && a2 != 0) {
if (a1 > a2) {
a1 -= 2;
a2++;
} else {
a2 -= 2;
a1++;
}
k++;
}
cout << k;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int n1 = 1e9 + 7;
struct compare {
inline bool operator()(const std::string& first,
const std::string& second) const {
return first.size() < second.size();
}
};
int main() {
{
long long n;
cin >> n;
if (n % 2 == 0) {
cout << 2;
} else {
cout << 1;
}
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Combo {
long long* fact;
long long* inv;
void build(long long n) {
fact = new long long[n];
inv = new long long[n];
fact[0] = 1;
inv[0] = 1;
for (int i = 1; i < n; i++) {
fact[i] = (fact[i - 1] * (long long)i) % 1000000007ll;
inv[i] = binexp(fact[i], 1000000007ll - 2);
}
}
long long binexp(long long a, long long b) {
if (b == 0) return 1ll;
if (b == 1) return a % 1000000007ll;
if (b % 2) return (a * binexp(a, b - 1)) % 1000000007ll;
return binexp((a * a) % 1000000007ll, b / 2);
}
long long choose(long long a, long long b) {
if (a < b) return 0;
long long res = (fact[a] * inv[b]) % 1000000007ll;
res *= inv[a - b];
res %= 1000000007ll;
return res;
}
} helper;
int n, q;
long long dp[1000010 * 3][3];
int main() {
scanf(" %d%d", &n, &q);
helper.build(3 * n + 2);
for (int i = 0; i < 3; i++) dp[0][i] = n;
long long inv3 = helper.binexp(3, 1000000007ll - 2);
for (int i = 1; i <= 3 * n; i++) {
dp[i][1] = helper.choose(3 * n + 1, i + 1);
long long B = dp[i - 1][1];
long long C = dp[i - 1][2];
dp[i][1] -= C;
dp[i][1] -= 2 * B;
dp[i][1] += 69 * 1000000007ll;
dp[i][1] %= 1000000007ll;
dp[i][1] *= inv3;
dp[i][1] %= 1000000007ll;
dp[i][2] = (B + dp[i][1]) % 1000000007ll;
dp[i][0] = (C + dp[i][2]) % 1000000007ll;
}
while (q--) {
int x;
scanf("%d", &x);
printf("%lld\n", dp[x][0]);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bitset<30005> bs;
int ok = 0, n, m;
const int DELTA = 10000;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int nums;
cin >> nums;
int oks = 0;
bs.reset();
for (int j = 1; j <= nums; j++) {
int now;
cin >> now;
bs.set(now + DELTA);
if (bs.test(DELTA - now)) {
oks = 1;
}
}
if (!oks) {
ok = 1;
}
}
(ok) ? printf("YES") : printf("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void f(int testCase) {
long long a;
long long k;
cin >> a >> k;
long long ans, temp;
for (int i = 0; i < k - 1; i++) {
temp = a;
long long up = -1, low = 10;
while (temp > 0) {
up = max(up, temp % 10);
low = min(temp % 10, low);
temp /= 10;
}
if (low == 0 || up == 0) {
cout << a << '\n';
return;
}
a += up * low;
}
cout << a << '\n';
}
int main() {
std::ios_base::sync_with_stdio(false);
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) f(i);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
vector<int> G[N];
int vis[N] = {0}, p[N];
long long sum[N] = {0};
stack<int> s;
void dfs(int u, int fa) {
s.push(u);
vis[u] = 1;
for (int i = 0; i < (int)G[u].size(); i++) {
int v = G[u][i];
if (v == fa) continue;
if (!vis[v])
dfs(v, u);
else if (vis[v] == 1) {
int maxx = u, minn = u;
while (!s.empty()) {
int t = s.top();
s.pop();
maxx = max(t, maxx);
minn = min(t, minn);
if (t == v) break;
}
p[minn] = maxx;
}
}
if (!s.empty() && s.top() == u) s.pop();
vis[u] = 2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= n + 1; i++) p[i] = n + 1;
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i, -1);
for (int i = n; i >= 1; i--) {
p[i] = min(p[i], p[i + 1]);
sum[i] = sum[i + 1] + p[i] - i;
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
int L = l, R = r + 1;
while (L < R) {
int m = (L + R) / 2;
if (p[m] > r)
R = m;
else
L = m + 1;
}
cout << sum[l] - sum[L] + 1ll * (r - L + 1) * (r - L + 2) / 2 << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a1[200], a2[200], s[200], d1[200][200], d2[200][200], l1, l2, boo1,
boo2, bo1[200], bo2[200], m, k1, k2, boo, booo;
int main() {
scanf("%d%d", &n, &k);
if (n == 1 && k == 1) {
printf("NO\n");
return 0;
}
for (int i = 0; i < n; i++) {
scanf("%d", &a1[i]);
d1[0][i] = i + 1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (a1[j] == i + 1) a2[i] = j + 1;
}
booo = 0;
for (int i = 0; i < n; i++)
if (a1[i] != a2[i]) booo = 1;
for (int i = 0; i < n; i++) {
scanf("%d", &s[i]);
d2[0][i] = i + 1;
}
if (k == 1) {
boo1 = 0;
boo2 = 0;
for (int i = 0; i < n; i++) {
if (s[i] != a1[i]) boo1 = 1;
if (s[i] != a2[i]) boo2 = 1;
}
if (boo1 == 0 || boo2 == 0)
printf("YES\n");
else
printf("NO\n");
return 0;
}
boo = 0;
for (int i = 0; i < n; i++)
if (s[i] != i) boo = 1;
if (boo == 0) {
printf("NO\n");
return 0;
}
for (int i = 1; i <= k; i++) {
for (int j = 0; j < n; j++) d1[i][j] = d1[i - 1][a1[j] - 1];
}
for (int i = 1; i <= k; i++) {
for (int j = 0; j < n; j++) d2[i][j] = d2[i - 1][a2[j] - 1];
}
for (int i = 0; i <= k; i++) {
boo1 = 0;
for (int j = 0; j < n; j++)
if (d1[i][j] != s[j]) boo1 = 1;
if (boo1 == 0) {
bo1[i] = 1;
}
}
l1 = k + 1;
for (int i = 0; i <= k; i++)
if (bo1[i] == 1) {
l1 = i;
break;
}
for (int i = 0; i <= k; i++) {
boo2 = 0;
for (int j = 0; j < n; j++)
if (d2[i][j] != s[j]) boo2 = 1;
if (boo2 == 0) {
bo2[i] = 1;
}
}
l2 = k + 1;
for (int i = 0; i <= k; i++)
if (bo2[i] == 1) {
l2 = i;
break;
}
if (booo == 0) {
for (int i = 0; i <= k; i++) {
k1 = i;
k2 = k - i;
if (k1 >= k2) {
m = k1 - k2;
if (bo1[m] == 1 && max(m, 2) <= l1) {
printf("YES\n");
return 0;
}
} else {
m = k2 - k1;
if (bo2[m] == 1 && max(m, 2) <= l2) {
printf("YES\n");
return 0;
}
}
}
} else {
for (int i = 0; i <= k; i++) {
k1 = i;
k2 = k - i;
if (k1 >= k2) {
m = k1 - k2;
if (bo1[m] == 1 && max(m, 1) <= l1) {
printf("YES\n");
return 0;
}
} else {
m = k2 - k1;
if (bo2[m] == 1 && max(m, 1) <= l2) {
printf("YES\n");
return 0;
}
}
}
}
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int val;
int id;
} num[111111];
bool cmp(node a, node b) { return a.val < b.val; }
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) {
num[i].id = i;
scanf("%d", &num[i].val);
}
sort(num + 1, num + 1 + n, cmp);
int maxlen = 1;
int len = 1;
for (int i = 1; i < n; i++) {
if (num[i + 1].id > num[i].id) {
len++;
maxlen = max(maxlen, len);
} else {
len = 1;
}
}
printf("%d\n", n - maxlen);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string vec[3];
int cont, cont2, cont3, a, b, c, cont4;
cont = cont2 = cont3 = cont4 = a = b = c = 0;
for (int i = 0; i < 3; i++) {
cin >> vec[i];
}
for (int i = 0; i < 3; i++) {
if (vec[i] == "rock") {
cont += 1;
a = i;
} else if (vec[i] == "paper") {
cont2 += 1;
b = i;
} else if (vec[i] == "scissors") {
cont3 += 1;
c = i;
}
}
for (int i = 0; i < 3; i++) {
if (cont == 2 && cont2 == 1 && cont4 == 0) {
if (b == 0) {
cout << "F";
} else if (b == 1) {
cout << "M";
} else if (b == 2) {
cout << "S";
}
cont4 = 1;
} else if (cont3 == 2 && cont == 1 && cont4 == 0) {
if (a == 0) {
cout << "F";
} else if (a == 1) {
cout << "M";
} else if (a == 2) {
cout << "S";
}
cont4 = 1;
} else if (cont2 == 2 && cont3 == 1 && cont4 == 0) {
if (c == 0) {
cout << "F";
} else if (c == 1) {
cout << "M";
} else if (c == 2) {
cout << "S";
}
cont4 = 1;
} else if (cont4 == 0) {
cout << "?";
cont4 = 1;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-') c = getchar(), f = -1;
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ '0');
return x * f;
}
inline long long readll() {
long long x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-') c = getchar(), f = -1;
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1ll) + (x << 3ll) + (c ^ '0');
return x * f;
}
const int maxn = 1e5 + 10;
char s1[maxn], s2[maxn];
int a1[maxn], a2[maxn], b1[maxn], b2[maxn];
int main() {
scanf("%s%s", s1 + 1, s2 + 1);
int n = strlen(s1 + 1), m = strlen(s2 + 1);
for (register int i = 1, iend = n; i <= iend; ++i) {
b1[i] = b1[i - 1];
if (s1[i] == 'A')
a1[i] = a1[i - 1] + 1;
else
b1[i]++, a1[i] = 0;
}
for (register int i = 1, iend = m; i <= iend; ++i) {
b2[i] = b2[i - 1];
if (s2[i] == 'A')
a2[i] = a2[i - 1] + 1;
else
b2[i]++, a2[i] = 0;
}
int T = read();
while (T--) {
int l1 = read(), r1 = read(), l2 = read(), r2 = read();
int u = b1[r1] - b1[l1 - 1], v = b2[r2] - b2[l2 - 1];
int x = min(a1[r1], r1 - l1 + 1), y = min(a2[r2], r2 - l2 + 1);
if ((u & 1) != (v & 1))
putchar('0');
else if (u > v)
putchar('0');
else if (x < y)
putchar('0');
else if (x % 3 != y % 3 && u + 2 > v)
putchar('0');
else if (x == y && x == r1 - l1 + 1 && y != r2 - l2 + 1)
putchar('0');
else
putchar('1');
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = ~(1 << 31);
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int m = 0, l = 0;
for (int i = 1; i < n; i++) {
if (v[i] < v[m] && m != 0) {
cout << 3 << endl;
cout << "1 " << m + 1 << " " << i + 1 << endl;
return 0;
}
if (v[i] > v[l] && l != 0) {
cout << 3 << endl;
cout << "1 " << l + 1 << " " << i + 1 << endl;
return 0;
}
if (v[i] > v[m]) {
m = i;
}
if (v[i] < v[l]) {
l = i;
}
}
cout << 0 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 100000;
const long long MOD = 1000000007;
const int inf = 222222222;
long long fast_exp(long long base, long long exp, long long mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
base = (base * base) % mod;
exp /= 2;
}
return res;
}
long long n, m, k;
long long a[100005], b[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 0, _i = (n); i < _i; ++i) cin >> a[i];
for (int j = 0, _j = (m); j < _j; ++j) cin >> b[j];
sort(a, a + n);
sort(b, b + m);
int flag = 0;
if (n > m) flag = 1;
for (int i = 1; i <= min(m, n); i++) {
if (a[n - i] > b[m - i]) flag = 1;
}
cout << (flag == 1 ? "YES" : "NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1LL * INF * INF;
const int MAX = 100010;
const long double PI = acos(-1.);
const double EPS = 1e-6;
long long mod = 1000LL * 1000 * 1000 + 7;
long long n, m, a, b;
long long binpow(long long a, long long x) {
long long res = 1;
while (x) {
if (x & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
x /= 2;
}
return res;
}
long long ober(long long x) { return binpow(x, mod - 2); }
long long fact[1000006];
long long oberfact[1000006];
long long A(long long n, long long k) {
return fact[n] * oberfact[n - k] % mod;
}
long long C(long long n, long long k) {
return fact[n] * oberfact[k] % mod * oberfact[n - k] % mod;
}
long long first(long long n, long long m) {
return m * binpow(n, n - m - 1) % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> a >> b;
fact[0] = 1;
for (int i = 1; i < 1000006; ++i) {
fact[i] = fact[i - 1] * i % mod;
}
oberfact[1000005] = ober(fact[1000005]);
for (int i = 1000005 - 1; i >= 0; --i) {
oberfact[i] = oberfact[i + 1] * (i + 1) % mod;
}
long long res = 0;
for (int k = 0; k < n - 1; ++k) {
if (m < k + 1) break;
long long cur =
C(m - 1, m - k - 1) * binpow(m, n - k - 2) % mod * A(n - 2, k) % mod;
if (k != n - 2) cur = cur * first(n, k + 2) % mod;
res = (res + cur) % mod;
}
cout << res << endl;
cin >> n;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int a[n], b[n];
long long int ans[n];
map<long long int, long long int> m, mp;
for (long long int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
m[b[i]]++;
mp[a[i]] = b[i];
if (a[i] == 0) {
ans[1] = b[i];
}
}
for (long long int i = 0; i < n; i++) {
if (m[a[i]] == 0) {
ans[0] = a[i];
break;
}
}
cout << ans[0] << " " << ans[1] << " ";
for (long long int i = 2; i < n; i++) {
ans[i] = mp[ans[i - 2]];
cout << ans[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res;
}
int main() {
int n;
cin >> n;
long long int ans = power(27, n);
ans = (ans - power(7, n) + 1000000007) % 1000000007;
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e2 + 10;
int d[N][N], vis[N];
long long ans[N];
int main() {
int n, x[N];
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &d[i][j]);
for (int i = 0; i < n; i++) {
scanf("%d", &x[i]);
x[i]--;
}
reverse(x, x + n);
for (int k = 0; k < n; k++) {
vis[x[k]] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
d[i][j] = min(d[i][j], d[i][x[k]] + d[x[k]][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (vis[i] && vis[j]) ans[n - k - 1] += d[i][j];
}
for (int i = 0; i < n; i++) printf("%I64d ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long double dis(double x, double y, double x1, double y1) {
return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
set<pair<int, int>> ans;
while (n--) {
vector<int> v(m);
for (int i = 0; i < m; i++) scanf("%d", &v[i]);
if (!k)
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++)
if (v[i] > v[j]) {
swap(v[i], v[j]);
ans.insert(make_pair(i + 1, j + 1));
}
}
else
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++)
if (v[i] < v[j]) {
swap(v[i], v[j]);
ans.insert(make_pair(j + 1, i + 1));
}
}
}
printf("%d\n", ans.size());
for (auto it = ans.begin(); it != ans.end(); it++)
printf("%d %d\n", it->first, it->second);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long mod) {
if (b == 0 || a == 1) {
if (mod == 1)
return 0;
else
return 1;
}
if (b % 2 == 0) {
long long k = powmod(a, b / 2, mod);
return (k * k) % mod;
} else {
long long k = powmod(a, b / 2, mod);
return ((k * k) % mod * a) % mod;
}
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b)
return gcd(a % b, b);
else
return gcd(b % a, a);
}
long long prime(long long p) {
for (long long i = 2; i * i <= p; i++) {
if (p % i == 0 && i < p) return i;
}
return 1;
}
long long sqr(long long i) { return i * i; }
long long n, a[200005], dp[200005][2];
bool visited[200005][2];
long long solve(long long x, bool d) {
if (x < 1 || x > n) return 0;
if (visited[x][d]) return dp[x][d];
visited[x][d] = 1;
dp[x][d] = -1;
long long ans = solve(x + a[x] * (d ? 1 : -1), !d);
if (ans != -1) ans += a[x];
return dp[x][d] = ans;
}
void solve(long long ppppppppp = 1) {
cin >> n;
for (long long i = 2; i <= n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
a[1] = i;
visited[1][0] = visited[1][1] = 0;
cout << solve(1, 1) << endl;
}
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tututu;
tututu = 1;
for (long long qwerty = 0; qwerty < tututu; qwerty++) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int MAXN = 1100000;
int l[MAXN], r[MAXN];
int f[MAXN], ld[MAXN], rd[MAXN];
void Build(int t, int depth) {
f[t] = ld[t] = rd[t] = MAXN;
if (depth == 0) return;
l[t] = t + t;
r[t] = t + t + 1;
Build(t + t, depth - 1);
Build(t + t + 1, depth - 1);
}
void Update(int t, int B) {
f[t] = min(f[l[t]], f[r[t]]);
f[t] = min(f[t], rd[l[t]] + ld[r[t]] + 1);
if (ld[l[t]] == MAXN) {
ld[t] = min(MAXN, ld[r[t]] + (1 << B));
} else {
ld[t] = ld[l[t]];
}
if (rd[r[t]] == MAXN) {
rd[t] = min(MAXN, rd[l[t]] + (1 << B));
} else {
rd[t] = rd[r[t]];
}
}
void Add(int t, int B, int a) {
if (B == -1) {
ld[t] = rd[t] = 0;
return;
}
if (a >> B & 1) {
Add(r[t], B - 1, a);
} else {
Add(l[t], B - 1, a);
}
Update(t, B);
}
void Change(int t, int B, int depth) {
if (depth == 0) {
swap(l[t], r[t]);
Update(t, B);
return;
}
Change(l[t], B - 1, depth - 1);
Change(r[t], B - 1, depth - 1);
Update(t, B);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
Build(1, k);
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
Add(1, k - 1, a);
}
if (k == 1) {
cout << 1 << " " << 1 << endl;
return 0;
}
vector<int> mask{0, 2, 3, 1};
for (int i = 3; i <= k; ++i) {
for (int j = (1 << (i - 1)) - 1; j >= 0; --j) {
mask.push_back(mask[j]);
}
for (int j = 0; j < (1 << (i - 1)); ++j) {
mask[j] = mask[j] << 1;
}
for (int j = (1 << (i - 1)); j < (1 << i); ++j) {
mask[j] = (mask[j] << 1) | 1;
}
}
vector<int> ans(1 << k);
ans[0] = f[1];
for (int i = 1; i < (1 << k); ++i) {
int t = 0;
while (((mask[i] ^ mask[i - 1]) >> t & 1) == 0) ++t;
Change(1, k - 1, k - 1 - t);
ans[mask[i]] = f[1];
}
for (int i : ans) cout << i << " ";
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int r, n, num = 0;
struct pnt {
long long x, y;
int id;
} in[500010], a[500010], b[500010];
bool cmp1(pnt x, pnt y) {
long long hh = (x.x + r) * y.y - (y.x + r) * x.y;
return hh == 0 ? (x.x + r) * (x.x + r) + x.y * x.y <
(y.x + r) * (y.x + r) + y.y * y.y
: hh > 0;
}
bool cmp2(pnt x, pnt y) {
long long hh = (x.x - r) * y.y - (y.x - r) * x.y;
return hh == 0 ? (x.x - r) * (x.x - r) + x.y * x.y <
(y.x - r) * (y.x - r) + y.y * y.y
: hh < 0;
}
bool cm1(int x, int y) { return cmp1(b[x], b[y]); }
bool cm2(int x, int y) { return cmp2(b[x], b[y]); }
bool eq1(pnt x, pnt y) { return (x.x + r) * y.y - (y.x + r) * x.y == 0; }
bool eq2(pnt x, pnt y) { return (x.x - r) * y.y - (y.x - r) * x.y == 0; }
int order[500010], rk[500010], l[500010];
struct tree {
int l, r, c;
tree *lc, *rc;
tree(int l, int r) : l(l), r(r), c(l), lc(NULL), rc(NULL) {}
} * root;
tree *bt(int l, int r) {
tree *i = new tree(l, r);
if (l < r) {
int md = l + r >> 1;
i->lc = bt(l, md);
i->rc = bt(md + 1, r);
i->c = max(i->lc->c, i->rc->c, cm2);
} else
i->c = order[l];
return i;
}
void chg(tree *i, int p) {
if (i->l == i->r) {
if (!b[i->c].y)
b[i->c] = in[b[i->c].id];
else
b[i->c].x = b[i->c].y = 0;
return;
}
int md = i->l + i->r >> 1;
if (p <= md)
chg(i->lc, p);
else
chg(i->rc, p);
i->c = max(i->lc->c, i->rc->c, cm2);
}
int get(tree *i, int l, int r) {
if (i->l == l && i->r == r) return i->c;
int md = i->l + i->r >> 1;
if (r <= md)
return get(i->lc, l, r);
else if (l > md)
return get(i->rc, l, r);
else
return max(get(i->lc, l, md), get(i->rc, md + 1, r), cm2);
}
int main() {
scanf("%d%d", &r, &n);
for (int i = 1; i <= n; i++) {
int op;
scanf("%d", &op);
if (op == 1) {
scanf("%lld%lld", &a[i].x, &a[i].y);
a[i].id = ++num;
b[num] = in[num] = a[i];
} else if (op == 2) {
scanf("%d", &a[i].id);
a[i].x = a[i].y = -1;
} else {
scanf("%lld%lld", &a[i].x, &a[i].y);
a[i].id = -1;
}
}
for (int i = 1; i <= num; i++) order[i] = i;
sort(order + 1, order + 1 + num, cm1);
for (int i = 1; i <= num; i++) rk[order[i]] = i;
l[1] = 1;
for (int i = 2; i <= num; i++) {
if (eq1(b[order[i - 1]], b[order[i]]))
l[i] = l[i - 1];
else
l[i] = i;
}
for (int i = 1; i <= num; i++) b[i].x = b[i].y = 0;
root = bt(1, num);
for (int i = 1; i <= n; i++) {
if (a[i].id == -1) {
int x = min(a[i].x, a[i].y, cm1), y = min(a[i].x, a[i].y, cm2);
if ((b[x].x + r) * (b[y].x - r) + b[x].y * b[y].y < 0) {
puts("NO");
continue;
}
chg(root, rk[a[i].x]);
chg(root, rk[a[i].y]);
int hh = get(root, l[rk[x]], num);
if (!b[hh].y) {
puts("YES");
chg(root, rk[a[i].x]);
chg(root, rk[a[i].y]);
continue;
}
chg(root, rk[a[i].x]);
chg(root, rk[a[i].y]);
if ((!eq2(b[hh], b[y]) && cm2(hh, y)) || (eq2(b[hh], b[y]) && cm1(hh, x)))
puts("YES");
else
puts("NO");
} else {
chg(root, rk[a[i].id]);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int infin = INT_MAX;
struct ans {
long long a, b, c;
};
map<long long, ans> m;
long long res, resa1, resb1, resa2, resb2;
void DFS(long long a, long long b, int c) {
if (!m[a * b].a) {
m[a * b] = {a, b, c};
} else
return;
if (a % 2 == 0) DFS(a / 2, b, c + 1);
if (a % 3 == 0) DFS(a / 3 * 2, b, c + 1);
if (b % 2 == 0) DFS(a, b / 2, c + 1);
if (b % 3 == 0) DFS(a, b / 3 * 2, c + 1);
}
void DFS2(long long a, long long b, int c) {
if (!m[a * b].a) {
m[a * b] = {-1, -1, -1};
} else if (m[a * b].a == -1)
return;
else {
long long c1 = m[a * b].c;
long long c2 = c;
if (c1 + c2 < res) {
res = c1 + c2;
resa1 = m[a * b].a;
resb1 = m[a * b].b;
resa2 = a;
resb2 = b;
}
return;
}
if (a % 2 == 0) DFS2(a / 2, b, c + 1);
if (a % 3 == 0) DFS2(a / 3 * 2, b, c + 1);
if (b % 2 == 0) DFS2(a, b / 2, c + 1);
if (b % 3 == 0) DFS2(a, b / 3 * 2, c + 1);
}
int main() {
long long a1, b1;
cin >> a1 >> b1;
DFS(a1, b1, 0);
res = infin;
long long a2, b2;
cin >> a2 >> b2;
DFS2(a2, b2, 0);
if (res == infin) return cout << -1, 0;
cout << res << endl;
cout << resa1 << " " << resb1 << endl;
cout << resa2 << " " << resb2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, a[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++)
if (a[i] & 1)
;
else
a[i]--;
for (int i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void rt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
rt(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
char s[505];
int main() {
scanf("%s", s);
int nw = 'a' - 1, n = strlen(s);
for (int i = 0; i <= (int)n - 1; i++) {
if (s[i] <= nw)
continue;
else if (s[i] > nw + 1)
return puts("NO"), 0;
else
nw++;
}
puts("YES");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == '-') {
s = s.substr(1, s.size());
if ((s.size() == 3 && s <= "128") || s.size() < 3)
cout << "byte";
else if ((s.size() == 5 && s <= "32768") || s.size() < 5)
cout << "short";
else if ((s.size() == 10 && s <= "2147483648") || s.size() < 10)
cout << "int";
else if ((s.size() == 19 && s <= "9223372036854775808") || s.size() < 19)
cout << "long";
else
cout << "BigInteger";
} else {
if ((s.size() == 3 && s <= "127") || s.size() < 3)
cout << "byte";
else if ((s.size() == 5 && s <= "32767") || s.size() < 5)
cout << "short";
else if ((s.size() == 10 && s <= "2147483647") || s.size() < 10)
cout << "int";
else if ((s.size() == 19 && s <= "9223372036854775807") || s.size() < 19)
cout << "long";
else
cout << "BigInteger";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void solve() {
int n, x;
cin >> n >> x;
vector<int> cs(n);
for (auto& c : cs) {
cin >> c;
}
int c_sum = accumulate(cs.begin(), cs.end(), 0);
vector<vector<T>> mass(n + 1, vector<T>(c_sum + 1, 0));
mass[0][0] = T(1);
for (int c : cs) {
for (int k = n - 1; k >= 0; --k) {
for (int s = c_sum - c; s >= 0; --s) {
mass[k + 1][s + c] += T(k + 1) / T(n - k) * mass[k][s];
}
}
}
T answer(0);
for (int k = 1; k <= n; ++k) {
for (int s = 0; s <= c_sum; ++s) {
answer +=
min(T(s) / T(k), T(x) / T(2) * (T(1) + T(n) / T(k))) * mass[k][s];
}
}
printf("%.17f\n", (double)answer);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve<long double>();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, a[101], b[101], k;
int dp[20003];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), b[i] = a[i] - b[i] * k;
for (int i = 0; i <= 20001; i++) dp[i] = -1;
dp[10000] = 0;
for (int i = 1; i <= n; i++) {
if (b[i] < 0) {
for (int j = 0; j <= 20001; j++)
if (j + b[i] <= 20001 && j + b[i] >= 0 && dp[j] != -1)
dp[j + b[i]] = max(dp[j + b[i]], dp[j] + a[i]);
} else {
for (int j = 20001; j >= 0; j--)
if (j + b[i] <= 20001 && j + b[i] >= 0 && dp[j] != -1)
dp[j + b[i]] = max(dp[j + b[i]], dp[j] + a[i]);
}
}
if (dp[10000] != 0)
printf("%d", dp[10000]);
else
printf("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, l, r, s1, s2, a[1005];
int main() {
int res = 0;
scanf("%d %d %d %d %d %d", &n, &k, &l, &r, &s1, &s2);
int tmp = s1 / n;
for (int i = 0; i < n; i++) a[i] += tmp;
s1 -= tmp * n;
while (s1 > 0) {
for (int i = n - 1; i >= n - k; i--) {
if (a[i] + 1 <= r) {
if (s1 == 0) break;
a[i]++;
s1--;
}
}
for (int i = 0; i < n - k; i++) {
if (a[i] + 1 <= r) {
if (s1 == 0) break;
a[i]++;
s1--;
}
}
}
int sum = 0;
for (int i = n - k; i < n; i++) sum += a[i];
while (sum != s2) {
int j = 0;
for (int i = n - k; i < n; i++) {
sum = 0;
while (a[j] - 1 < l) j++;
if (a[i] + 1 <= r) {
a[i]++;
a[j]--;
}
for (int i = n - k; i < n; i++) sum += a[i];
if (sum == s2) break;
}
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b, T c = -1234567, T d = -1234567) {
T ans = a > b ? a : b;
if (c != -1234567) ans = max1(ans, c);
if (d != -1234567) ans = max1(ans, d);
return ans;
}
template <class T>
inline T min1(T a, T b, T c = -1234567, T d = -1234567) {
T ans = a < b ? a : b;
if (c != -1234567) ans = min(ans, c);
if (d != -1234567) ans = min(ans, d);
return ans;
}
template <class T>
inline T gcd1(T a, T b) {
if (a < b) swap(a, b);
if (a % b == 0) return b;
return gcd1(b, a % b);
}
template <class T>
inline T lb(T num) {
return num & (-num);
}
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / abs1(a) < eps)
return 0;
if (a < b) return -1;
return 1;
}
template <typename t>
inline int jud(t a, t b) {
if (a < b) return -1;
if (a == b) return 0;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
inline int bitnum(unsigned long long nValue) {
nValue = ((0xaaaaaaaaaaaaaaaaull & nValue) >> 1) +
(0x5555555555555555ull & nValue);
nValue = ((0xccccccccccccccccull & nValue) >> 2) +
(0x3333333333333333ull & nValue);
nValue = ((0xf0f0f0f0f0f0f0f0ull & nValue) >> 4) +
(0x0f0f0f0f0f0f0f0full & nValue);
nValue = ((0xff00ff00ff00ff00ull & nValue) >> 8) +
(0x00ff00ff00ff00ffull & nValue);
nValue = ((0xffff0000ffff0000ull & nValue) >> 16) +
(0x0000ffff0000ffffull & nValue);
nValue = ((0xffffffff00000000ull & nValue) >> 32) +
(0x00000000ffffffffull & nValue);
return nValue;
}
long long pow(long long n, long long m, long long mod = 0) {
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
int dp[25][50][100], ans[50];
int n, m;
int a[22], b[22];
inline void upd(int a, int &b) {
if (b == -1 || a < b) b = a;
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", b + i);
memset(dp, -1, sizeof(dp));
dp[0][n * 2][n * 2] = 0;
for (int i = 0; i < n; i++) {
int now = i & 1, nxt = 1 - now;
memset(dp[nxt], -1, sizeof(dp[nxt]));
for (int j = n * 2 - i; j <= n * 2; j++)
for (int k = j; k <= i + n * 2; k++)
if (dp[now][j][k] != -1) {
int temp = b[i] + dp[now][j][k];
upd(temp, dp[nxt][min(j, k - 1)][k - 1]);
temp = a[i] + dp[now][j][k];
upd(temp, dp[nxt][j][k + 1]);
}
}
memcpy(dp[0], dp[n & 1], sizeof(dp[0]));
memset(dp[1], -1, sizeof(dp[1]));
memset(ans, -1, sizeof(ans));
ans[0] = 0;
for (int ii = 0; m; m >>= 1, ii++) {
if (m & 1) {
int temp[50];
memset(temp, -1, sizeof(temp));
for (int i = 0; i < n * 2; i++)
if (ans[i] != -1) {
for (int j = n * 2 - i; j <= n * 2; j++)
for (int k = j; k - n * 2 + i < n * 2 && k < n * 4; k++)
if (dp[ii][j][k] != -1) {
upd(ans[i] + dp[ii][j][k], temp[i + k - n * 2]);
}
}
memcpy(ans, temp, sizeof(temp));
}
for (int i = 0; i <= n * 2; i++)
for (int j = i; j < n * 4; j++)
if (dp[ii][i][j] != -1)
for (int i1 = max(0, n * 2 - j); i1 <= n * 2; i1++)
for (int j11 = i1; j11 + j < n * 6 && j11 < n * 4; j11++)
if (dp[ii][i1][j11] != -1) {
upd(dp[ii][i][j] + dp[ii][i1][j11],
dp[ii + 1][min(i, j + i1 - n * 2)][j + j11 - n * 2]);
}
}
cout << ans[0] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int f[100000 + 100], g[100000 + 100];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> g[i];
}
int gns = g[0];
for (int i = 1; i < n; ++i)
if (g[i] > g[i - 1]) gns += g[i] - g[i - 1];
int w = g[0], x = 0;
while (w--) {
f[x] = 1;
x++;
}
cout << gns << endl;
g[n] = 0;
for (int i = 1; i <= n; ++i) {
if (g[i] >= g[i - 1]) {
int q = (g[i] - g[i - 1]);
while (q--) {
f[x] = i + 1;
x++;
}
} else {
int p = g[i - 1] - g[i];
while (p--) {
x--;
cout << f[x] << " " << i << endl;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int mod = 1000000007;
int mp[1010][1010];
int f[12][12];
int use[12];
int two[12];
int n, m, k;
int Log[1 << 12];
int dfs(int x, int y) {
if (y == m + 1) {
x++;
if (x > n) return 1;
y = 1;
}
int state = f[x - 1][y] | f[x][y - 1];
int w = -1, sum = 0;
for (int j = ~state & (two[k] - 1); j; j -= j & -j) {
int who = Log[j & -j];
if (!mp[x][y] || mp[x][y] == who + 1) {
use[who + 1]++;
f[x][y] = state | two[who];
if (use[who + 1] == 1) {
if (w == -1) w = dfs(x, y + 1);
sum += w;
} else if (use[who + 1]) {
sum += dfs(x, y + 1);
}
if (sum >= mod) sum -= mod;
use[who + 1]--;
}
}
return sum;
}
int main() {
two[0] = 1;
Log[1] = 0;
for (int i = 1; i <= 10; i++) two[i] = two[i - 1] * 2, Log[1 << i] = i;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &mp[i][j]);
use[mp[i][j]]++;
}
}
if (n + m - 1 > k) return puts("0"), 0;
printf("%d\n", dfs(1, 1));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 17;
const int MX = (int)1e6 + 17;
const int MOD = (int)1e9 + 7;
const long long oo = LLONG_MAX;
const int INF = INT_MAX;
const long double Pi = 3.14159265358979323846264338327950288419716939937510;
const int di[4] = {-1, 0, 1, 0};
const int dj[4] = {0, 1, 0, -1};
inline long long IN() {
long long x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void OUT(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
OUT(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
void IOI2017() {
freopen(
"partition"
".in",
"r", stdin);
freopen(
"partition"
".out",
"w", stdout);
}
string s;
int dp2[N], dp3[N];
set<string> ans;
int main() {
cin >> s;
dp2[(int)s.size()] = dp3[(int)s.size()] = 1;
for (int i = (int)s.size() - 2; i >= 5; i--) {
if (dp2[i + 2] && s.substr(i, 2) != s.substr(i + 2, 2) || dp3[i + 2])
dp2[i] = 1, ans.insert(s.substr(i, 2));
if (dp3[i + 3] && s.substr(i, 3) != s.substr(i + 3, 3) || dp2[i + 3])
dp3[i] = 1, ans.insert(s.substr(i, 3));
}
cout << (int)ans.size() << endl;
for (auto i : ans) cout << i << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
const int INF = 2000000010;
int n, m, t, k, x, l, r;
int a[maxn], b[maxn];
long long ans[maxn];
map<int, int> mp;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i], mp[a[i]] = i;
for (int i = 1; i <= m; i++) cin >> b[i];
int idx = 1, la = 1;
for (int i = 1; i <= m; i++) {
if (!mp[b[i]]) {
puts("0");
return 0;
}
}
for (int i = 1; i <= n; i++) {
if (a[i] < b[idx]) {
puts("0");
return 0;
}
if (a[i] < b[idx + 1]) la = i;
if (a[i] == b[idx + 1] && mp[b[idx + 1]] == i) {
ans[idx] = i - la;
idx++;
la = i;
}
}
long long A = 1;
for (int i = 1; i < m; i++) A = (long long)(A * ans[i]) % 998244353;
cout << A << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string q;
long long int r, s = -1, f = 1e12 + 200, mid, b = 0, ss = 0, c = 0, nb, nc, ns,
ps, pb, pc;
bool value(long long int a) {
long long int mb = a * b, ms = a * ss, mc = a * c;
if (nb > mb)
mb = 0;
else
mb -= nb;
if (ns > ms)
ms = 0;
else
ms -= ns;
if (nc > mc)
mc = 0;
else
mc -= nc;
if (mc * pc + mb * pb + ms * ps <= r)
return true;
else
return false;
}
int main() {
cin >> q >> nb >> ns >> nc >> pb >> ps >> pc >> r;
for (int i = 0; i < q.length(); i++) {
if (q[i] == 'S')
ss++;
else if (q[i] == 'B')
b++;
else
c++;
}
while (f - s > 1) {
mid = (s + f) / 2;
if (!value(mid))
f = mid;
else
s = mid;
}
cout << s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int &v : a) {
cin >> v;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long x = a[i], c = 0;
while (i < n and x == a[i]) {
++i;
++c;
}
--i;
ans += (c * c + c) / 2;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int q, n, i, j, k, arr[201];
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d", &n);
for (j = 0; j < n; j++) {
scanf("%d", &arr[j]);
}
for (j = 0; j < n; j++) {
int count = 1;
int p;
p = arr[j] - 1;
while (arr[p] != arr[j]) {
p = arr[p] - 1;
count++;
}
printf("%d ", count);
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int num = 3e5 + 5;
int idx, h[num], e[num * 4], ne[num * 4];
int n, z1[num], z2[num], col[num];
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
bool findx(int u, int k) {
col[u] = k;
for (int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
if (!col[j]) {
if (!findx(j, 3 - k))
return 0;
else if (col[j] == k)
return 0;
}
}
return 1;
}
int main() {
cin >> n;
memset(h, -1, sizeof h);
for (int i = 1; i <= n; i++) {
cin >> z1[i] >> z2[i];
add(z1[i], z2[i]), add(z2[i], z1[i]);
add(2 * i, 2 * i - 1), add(2 * i - 1, 2 * i);
}
for (int i = 1; i <= 2 * n; i++) {
if (!col[i]) {
if (!findx(i, 1)) {
cout << -1 << endl;
return 0;
}
}
}
for (int i = 1; i <= n; i++) cout << col[z1[i]] << " " << col[z2[i]] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int ar[1000000];
int main() {
int t;
cin >> t;
while (t--) {
long long int i, n, sum1 = 0, a;
cin >> n;
for (i = 0; i < n; i++) {
cin >> ar[i];
sum1 = sum1 + ar[i];
}
a = ar[0];
for (i = 1; i < n; i++) {
a = a ^ ar[i];
}
if (2 * a == sum1) {
cout << 0 << endl;
cout << endl;
} else {
long long int a1, a2;
a1 = a;
sum1 = sum1 + a1;
a2 = sum1;
cout << 2 << endl;
cout << a1 << " " << a2 << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, cnt;
int k[1005], t[1005];
bool vis[1005], c[1005][1005];
int main() {
cin >> n;
for (int i = 1; i <= n - 1; i++) {
cin >> x >> y;
if (x > y) swap(x, y);
if (y != n) {
cout << "NO" << endl;
return 0;
}
if (!vis[x])
vis[x] = true, c[x][n] = true, k[x] = x;
else
t[++cnt] = x;
}
for (int i = 1; i <= cnt; i++) {
bool flag = true;
for (int j = t[i]; j >= 1; j--) {
if (!vis[j]) {
vis[j] = true, c[j][n] = true, c[k[t[i]]][n] = false,
c[j][k[t[i]]] = true;
k[t[i]] = j, flag = false;
break;
}
}
if (flag) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (c[i][j]) cout << i << ' ' << j << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int a[100009];
struct nod {
int f, lz;
nod *l, *r;
nod() {
f = 0;
lz = 0;
l = NULL;
r = NULL;
}
nod(int x, int z, nod *lf = NULL, nod *ri = NULL) {
lz = z;
f = x;
l = lf;
r = ri;
}
};
nod *sg[100009];
void rfr(nod *root, int st, int en) {
int d = en - st + 1;
int p = root->lz;
if (p == 0) return;
root->f = d - root->f;
root->lz = 0;
if (st == en) return;
if (root->l == NULL) root->l = new nod();
if (root->r == NULL) root->r = new nod();
nod *g1 = new nod(root->l->f, 1 - root->l->lz, root->l->l, root->l->r);
nod *g2 = new nod(root->r->f, 1 - root->r->lz, root->r->l, root->r->r);
root->l = g1;
root->r = g2;
}
nod *chn(nod *root, int x, int z, int st = 0, int en = n * m - 1) {
rfr(root, st, en);
if (x < st || x > en) return root;
if (st == en) return new nod(z, 0);
int mid = st + (en - st) / 2;
if (root->l == NULL) root->l = new nod();
if (root->r == NULL) root->r = new nod();
nod *rt1 = chn(root->l, x, z, st, mid);
nod *rt2 = chn(root->r, x, z, mid + 1, en);
return new nod(rt1->f + rt2->f, 0, rt1, rt2);
}
nod *go(nod *root, int qst, int qen, int st = 0, int en = n * m - 1) {
rfr(root, st, en);
if (qst > en || qen < st) return root;
if (st >= qst && en <= qen) {
nod *z = new nod(root->f, 1 - root->lz, root->l, root->r);
rfr(z, st, en);
return z;
}
int mid = st + (en - st) / 2;
if (root->l == NULL) root->l = new nod();
if (root->r == NULL) root->r = new nod();
nod *rt1 = go(root->l, qst, qen, st, mid);
nod *rt2 = go(root->r, qst, qen, mid + 1, en);
return new nod(rt1->f + rt2->f, 0, rt1, rt2);
}
long long cal(nod *root, int qst = 0, int qen = n * m - 1, int st = 0,
int en = n * m - 1) {
rfr(root, st, en);
if (st > qen || en < qst) return 0;
if (st >= qst && en <= qen) return root->f;
int mid = st + (en - st) / 2;
if (root->l == NULL) root->l = new nod();
if (root->r == NULL) root->r = new nod();
return cal(root->l, qst, qen, st, mid) + cal(root->r, qst, qen, mid + 1, en);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> q;
sg[0] = new nod();
int t = 0, d, i, j;
while (q--) {
cin >> d;
if (d == 1) {
cin >> i >> j;
int u = ((i - 1) * m + (j - 1));
t++;
sg[t] = chn(sg[t - 1], u, 1);
}
if (d == 2) {
cin >> i >> j;
int u = ((i - 1) * m + (j - 1));
t++;
sg[t] = chn(sg[t - 1], u, 0);
}
if (d == 3) {
cin >> i;
int u = (i - 1) * m, v = i * m - 1;
t++;
sg[t] = go(sg[t - 1], u, v);
}
if (d == 4) {
cin >> i;
t++;
sg[t] = sg[i];
}
cout << cal(sg[t]) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int xa, ya, xb, yb;
cin >> xa >> ya >> xb >> yb;
int q;
cin >> q;
int x[q], y[q], r[q];
for (int i = 0; i < q; i++) {
cin >> x[i] >> y[i] >> r[i];
}
int ans = 0;
for (int i = min(xa, xb); i <= max(xa, xb); i++) {
int f = 0;
for (int j = 0; j < q; j++) {
if ((((i - x[j]) * (i - x[j])) + ((ya - y[j]) * (ya - y[j]))) <=
(r[j] * r[j])) {
f = 1;
break;
}
}
if (f == 0) ans++;
}
for (int i = min(xa, xb); i <= max(xa, xb); i++) {
int f = 0;
for (int j = 0; j < q; j++) {
if ((((i - x[j]) * (i - x[j])) + ((yb - y[j]) * (yb - y[j]))) <=
(r[j] * r[j])) {
f = 1;
break;
}
}
if (f == 0) ans++;
}
for (int i = min(ya, yb) + 1; i < max(yb, ya); i++) {
int f = 0;
for (int j = 0; j < q; j++) {
if ((((xa - x[j]) * (xa - x[j])) + ((i - y[j]) * (i - y[j]))) <=
(r[j] * r[j])) {
f = 1;
break;
}
}
if (f == 0) ans++;
}
for (int i = min(ya, yb) + 1; i < max(ya, yb); i++) {
int f = 0;
for (int j = 0; j < q; j++) {
if ((((xb - x[j]) * (xb - x[j])) + ((i - y[j]) * (i - y[j]))) <=
(r[j] * r[j])) {
f = 1;
break;
}
}
if (f == 0) ans++;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using tint = long long;
using ld = long double;
using vi = vector<int>;
using pi = pair<int, int>;
const tint MOD = 1e9 + 7;
const int MX = 1e5 + 5;
const int INF = 1e9;
const long double PI = acos((-1));
void NACHO(string name = "factory") {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int main() {
NACHO();
int n, m;
cin >> n >> m;
vi a(n), b(m);
for (int i = 0; i < int(n); i++) cin >> a[i];
for (int i = 0; i < int(m); i++) cin >> b[i];
for (int num = 0; num < int(513); num++) {
bool ok = 1;
for (int i = 0; i < int(n); i++) {
bool oki = 0;
for (int j = 0; j < int(m); j++) {
if (((a[i] & b[j]) | num) == num) {
oki = 1;
}
}
if (!oki) ok = 0;
}
if (ok) {
cout << num << endl;
return 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int maxm = (1 << 8) + 5;
const int mod = 1e9 + 7;
const int MAX = 1000000010;
const double eps = 1e-6;
const double PI = acos(-1);
template <typename T>
inline void read(T &x) {
x = 0;
T f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do x = x * 10 + ch - '0', ch = getchar();
while (ch <= '9' && ch >= '0');
x *= f;
}
template <typename A, typename B>
inline void read(A &x, B &y) {
read(x);
read(y);
}
template <typename A, typename B, typename C>
inline void read(A &x, B &y, C &z) {
read(x);
read(y);
read(z);
}
template <typename A, typename B, typename C, typename D>
inline void read(A &x, B &y, C &z, D &w) {
read(x);
read(y);
read(z);
read(w);
}
template <typename A, typename B>
inline A fexp(A x, B p) {
A ans = 1;
for (; p; p >>= 1, x = 1LL * x * x % mod)
if (p & 1) ans = 1LL * ans * x % mod;
return ans;
}
template <typename A, typename B>
inline A fexp(A x, B p, A mo) {
A ans = 1;
for (; p; p >>= 1, x = 1LL * x * x % mo)
if (p & 1) ans = 1LL * ans * x % mo;
return ans;
}
int n;
char st[maxn];
int A[maxn];
vector<int> has[8];
int dis[maxn][8], d[8][8];
int mask[maxn], f[8][maxm];
int Ans1;
long long Ans2;
queue<int> Q;
int vi[8];
void bfs(int c) {
for (int i = (0); i <= (7); i++) vi[i] = 0;
for (int i = (1); i <= (n); i++) dis[i][c] = MAX;
for (int i = (1); i <= (n); i++)
if (A[i] == c) Q.push(i), dis[i][c] = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
if (!vi[A[u]]) {
vi[A[u]] = 1;
for (auto v : has[A[u]])
if (dis[v][c] == MAX) {
dis[v][c] = dis[u][c] + 1;
Q.push(v);
}
}
if (dis[u - 1][c] == MAX) {
dis[u - 1][c] = dis[u][c] + 1;
Q.push(u - 1);
}
if (dis[u + 1][c] == MAX) {
dis[u + 1][c] = dis[u][c] + 1;
Q.push(u + 1);
}
}
}
void add(int x, int y) {
if (x > Ans1)
Ans1 = x, Ans2 = y;
else if (x == Ans1)
Ans2 += y;
}
int calc(int x, int y) {
int ans = y - x;
for (int i = (0); i <= (7); i++) ans = min(ans, dis[x][i] + dis[y][i] + 1);
return ans;
}
void Work() {
Ans1 = Ans2 = 0;
for (int i = (1); i <= (n); i++) {
for (int j = (max(1, i - 15)); j <= (i - 1); j++) {
int x = calc(j, i);
add(x, 1);
}
if (i > 16) {
for (int s = mask[i - 16];; s = (s - 1) & mask[i - 16]) {
f[A[i - 16]][s]++;
if (!s) break;
}
}
for (int j = (0); j <= (7); j++)
if (f[j][0]) {
int D = MAX;
for (int k = (0); k <= (7); k++) D = min(D, dis[i][k] + d[j][k] + 1);
if (D == MAX) continue;
int t = 0;
for (int k = (0); k <= (7); k++)
if (dis[i][k] + d[j][k] + 1 == D) t |= 1 << k;
if (f[j][t])
add(D + 1, f[j][t]);
else
add(D, f[j][0]);
}
}
cout << Ans1 << ' ' << Ans2 << endl;
}
void Init() {
read(n);
scanf("%s", st + 1);
for (int i = (0); i <= (7); i++) has[i].clear();
for (int i = (1); i <= (n); i++) A[i] = st[i] - 'a', has[A[i]].push_back(i);
for (int i = (0); i <= (7); i++) bfs(i);
for (int i = (0); i <= (7); i++)
for (int j = (0); j <= (7); j++) d[i][j] = 20;
for (int i = (1); i <= (n); i++)
for (int j = (0); j <= (7); j++) d[A[i]][j] = min(d[A[i]][j], dis[i][j]);
for (int i = (1); i <= (n); i++) {
mask[i] = 0;
for (int j = (0); j <= (7); j++) {
int c = dis[i][j] - d[A[i]][j];
if (c) mask[i] |= 1 << j;
}
}
}
int main() {
int T = 1;
while (T--) {
Init();
Work();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int mind(long long int x, long long int y) {
if (x > y) {
return y;
} else {
return x;
}
}
long long int maxd(long long int x, long long int y) {
if (x > y) {
return x;
} else {
return y;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int op[26] = {0};
long long int cl[26] = {0};
bool b = true;
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
for (long long int i = 0; i < n; i++) {
if (op[s[i] - 65] == 0) {
op[s[i] - 65] = i + 1;
}
cl[s[i] - 65] = i + 1;
}
long long int t = 1;
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
if (op[s[i] - 65] == t) {
sum++;
}
if (sum > k) {
b = false;
break;
}
if (cl[s[i] - 65] == t) {
sum--;
}
t++;
}
if (b == true) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void _dbg(char const *s, const T &t) {
cout << s << "=" << t << endl;
}
template <typename T, typename... TA>
void _dbg(char const *s, const T &t, const TA &...ta) {
while (*s != ',') cout << *s++;
cout << "=" << t << ",";
_dbg(s + 1, ta...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &print_iterable(ostream &os, T beg, T end) {
os << '[';
for (auto it = beg; it != end; ++it) {
if (it != beg) os << ", ";
os << *it;
}
return os << ']';
}
template <typename T, size_t N>
ostream &operator<<(ostream &os, const array<T, N> &x) {
return print_iterable(os, x.begin(), x.end());
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &x) {
return print_iterable(os, x.begin(), x.end());
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &x) {
return print_iterable(os, x.begin(), x.end());
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &x) {
return print_iterable(os, x.begin(), x.end());
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &x) {
return print_iterable(os, x.begin(), x.end());
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const map<T1, T2> &x) {
return print_iterable(os, x.begin(), x.end());
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const unordered_map<T1, T2> &x) {
return print_iterable(os, x.begin(), x.end());
}
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<ld, ld>;
void solve() {
int n, k;
string s, t;
cin >> n >> k;
cin >> s >> t;
if (s == t) {
printf("%d\n", n);
return;
}
vector<int> sub(n);
for (int i = n - 1, prv = 0; i >= 0; --i) {
int a = t[i] == 'b';
int b = s[i] == 'b';
int c = a - b - prv;
prv = 0;
while (c < 0) {
c += 2;
prv++;
}
sub[i] = c;
}
ll z = 0;
for (int i = 0; i < n; ++i) {
z = 2 * z + sub[i];
if (z >= (ll)1e10) break;
};
z = min<ll>(k, z + 1);
;
int p = 0;
while (p < n && s[p] == t[p]) ++p;
ll fb = 0;
ll ans = p;
for (int i = p; i < n; ++i) {
;
if (fb + 2 >= z) {
ans += (n - i) * z;
break;
} else {
ans += fb + 2;
};
ll nb = fb * 2;
if (i + 1 < n && t[i + 1] == 'b') ++nb;
if (i + 1 < n && s[i + 1] == 'a') ++nb;
fb = nb;
}
printf("%lld\n", ans);
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int INF = 0x3f3f3f3f;
const int mo = 1e9 + 7;
void solve() {
long long n, k;
scanf("%lld", &(n)), scanf("%lld", &(k));
if (n == 1) {
puts("0");
return;
}
long long hav = 1;
long long t = 0;
while (hav <= k && hav < n) {
t++;
hav = hav * 2;
}
if (n > hav) {
t += (n - hav + k - 1) / k;
}
printf("%lld\n", t);
}
int main() {
int t = 1;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long int ans = 0;
ans = (long long int)(4 * pow(2, n / 2 - 1) - 2);
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> s[100005];
long long a[100005];
bool vis[100005];
long long val[100005];
int type[100005], u[100005], v[100005];
int bigNumber[100005], bigPos[335];
int bigAdj[335][100005];
long long wei[100005], tmpVal[100005];
int tmp[100005];
void solve() {
int nn, m, q;
scanf("%d %d %d", &nn, &m, &q);
for (int i = 1; i <= nn; ++i) {
scanf("%lld ", &a[i]);
}
int pos = 0;
for (int i = 1; i <= m; ++i) {
int k, x;
scanf("%d ", &k);
if (k >= 335) {
bigNumber[i] = pos;
bigPos[pos++] = i;
}
while (k--) {
scanf("%d ", &x);
s[i].push_back(x);
}
}
for (int i = 0; i < pos; ++i) {
for (int x : s[bigPos[i]]) {
vis[x] = true;
}
for (int j = m; j; --j) {
for (int x : s[j]) {
if (vis[x]) {
++bigAdj[i][j];
}
}
}
for (int x : s[bigPos[i]]) {
vis[x] = false;
}
}
char str[123];
for (int i = 1; i <= q; ++i) {
scanf(" %s %d", str, &u[i]);
if (str[0] == '?') {
type[i] = 1;
} else {
type[i] = 2;
scanf(" %d ", &v[i]);
}
}
for (int ii = 1; ii <= q; ii += 335) {
int ed = min(ii + 335 - 1, q);
set<int> rr;
for (int j = ii; j <= ed; ++j) {
rr.insert(u[j]);
}
int p = 0;
for (int x : rr) {
tmp[p++] = x;
}
for (int j = 0; j < p; ++j) {
int id = tmp[j];
wei[tmp[j]] = tmpVal[tmp[j]] = 0;
for (int x : s[id]) {
tmpVal[tmp[j]] += a[x];
}
}
for (int j = ii; j <= ed; ++j) {
int ver = u[j];
if (type[j] == 1) {
long long ret = 0;
if (s[ver].size() < 335) {
for (int x : s[ver]) {
ret += a[x];
}
for (int k = 0; k < p; ++k) {
int node = tmp[k];
if (s[node].size() >= 335) {
ret += wei[node] * bigAdj[bigNumber[node]][ver];
}
}
} else {
ret = tmpVal[ver];
for (int k = 0; k < p; ++k) {
int node = tmp[k];
ret += wei[node] * bigAdj[bigNumber[ver]][node];
}
}
printf("%lld\n", ret);
} else {
int w = v[j];
wei[ver] += w;
if (s[ver].size() < 335) {
for (int x : s[ver]) {
a[x] += w;
}
}
}
}
for (int j = 0; j < p; ++j) {
int id = tmp[j];
if (s[id].size() >= 335) {
for (int x : s[id]) {
a[x] += wei[id];
}
}
}
}
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, r;
double ans[1005] = {};
int x[1005] = {};
double f(int a, int b) {
return ans[a] + sqrt(4 * r * r - (x[a] - x[b]) * (x[a] - x[b]));
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
for (int i = 1; i <= n; i++) {
ans[i] = (double)r;
for (int j = 1; j <= i - 1; j++) {
if ((x[i] - x[j] >= -2 * r) && (x[i] - x[j] <= 2 * r)) {
if (ans[i] < f(j, i)) ans[i] = f(j, i);
}
}
printf("%.10f ", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
vector<pair<int, int>> p(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
p[i] = make_pair(v[i], i);
}
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
int ans = 0;
for (int i = 0; i < k; i++) ans += p[i].first;
cout << ans << endl;
ans = 0;
for (int i = 0; i < k; i++) {
v[p[i].second] = 0;
}
int r = 1;
for (int i = 0; i < n; i++) {
if (v[i])
ans++;
else {
if (r < k)
cout << ans + 1 << ' ';
else
cout << ans + 1 + n - 1 - i << endl;
ans = 0;
r++;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[500001], num[500001];
int n, mod;
long long sum;
inline int add(int a, int b) { return a + b - mod >= 0 ? a + b - mod : a + b; }
inline int mul(int a, int b) { return (long long)a * b % mod; }
int power(int a, int b) {
int ret = 1;
for (int t = a; b; b >>= 1) {
if (b & 1) ret = mul(ret, t);
t = mul(t, t);
}
return ret;
}
int calD() {
long long t = (long long)n * (n + 1) * (n - 1) / 6;
int x = n & 1 ? mul(t / 2 % mod, n) : mul(t % mod, n / 2);
int y = sum % mod;
y = (-mul(y, y) + mod) % mod;
for (int i = 0; i < n; i++) y = add(y, mul(mul(a[i], a[i]), n));
if (x) {
int d2 = mul(y, power(x, mod - 2));
for (int i = 0; i < n; i++) {
int d = a[i] - a[0];
if (mul(d, d) == d2) return d;
}
return -1;
}
if (y) return -1;
return a[n - 1] - a[0];
}
int calX(int d) {
if (d == -1) return -1;
long long t = sum - (long long)n * (n - 1) * d / 2;
t = ((t % mod) + mod) % mod;
if (n % mod == 0) return t % n == 0 ? t / n : -1;
return mul(t, power(n, mod - 2));
}
bool check(int d, int x) {
if (x == -1) return false;
static int b[500001];
for (int i = 0; i < n; i++, x = add(x, d)) b[i] = x;
sort(b, b + n);
return memcmp(a, b, sizeof(int) * n) == 0;
}
int main() {
scanf("%d%d", &mod, &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
sort(a, a + n);
int d = calD(), x = calX(d);
if (check(d, x))
printf("%d %d", x, d);
else
printf("-1");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
vector<long long> a(t);
vector<long long> b(t);
vector<long long> x(t);
for (long long i = 0; i < t; ++i) {
cin >> a[i] >> b[i] >> x[i];
}
for (long long i = 0; i < t; ++i) {
long long ans = 0;
if (x[i] % 2 == 0) {
ans += (x[i]) / 2 * a[i];
ans -= (x[i] / 2) * b[i];
} else {
ans += (x[i] + 1) / 2 * a[i];
ans -= (x[i] / 2) * b[i];
}
cout << ans << endl;
}
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.