solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
long double _ld;
using namespace std;
int n, m;
int i, j, k, l;
pair<int, int> p[111111];
bool cmp(pair<int, int> s1, pair<int, int> s2) {
int p1 = s1.first;
int l1 = s1.second;
int p2 = s2.first;
int l2 = s2.second;
return l1 * (100 - p2) * p1 > l2 * (100 - p1) * p2;
}
int main() {
cin >> n;
for (i = 0; i < n; ++i) {
int ll, pp;
cin >> ll >> pp;
p[i] = make_pair(pp, ll);
}
sort(p, p + n, cmp);
typeof(_ld) el = 0;
typeof(_ld) et = 0;
for (i = 0; i < n; ++i) {
typeof(_ld) pr = (typeof(_ld))p[i].first / 100;
int len = p[i].second;
et = pr * (et + len) + (1 - pr) * (et + el + len);
el = el + pr * len;
}
printf("%.15lf\n", (double)et);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
;
int x[400005] = {0};
int a, n, i, T, y, ans = 0, cnt = 0;
cin >> n >> a;
for (i = 0; i < n; i++) {
cin >> y;
x[y % a]++;
while (true) {
if (x[cnt % a] > cnt / a)
cnt++;
else {
cout << cnt << "\n";
break;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, c;
long long dpp[4123];
long long dp(long long k) {
if (k < 0) return -10000000000000;
if (dpp[k] != -1) return dpp[k];
if (k == 0) return dpp[k] = 0;
return dpp[k] = 1 + max(dp(k - a), max(dp(k - b), dp(k - c)));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long k;
cin >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long s[n];
s[0] = 0;
for (long long i = 0; i < k; i++) s[0] += a[i];
for (long long i = 1; i < n - k + 1; i++)
s[i] = s[i - 1] - a[i - 1] + a[k + i - 1];
long long aa = 0, bb = k;
long long pa = -1, push_back = -1;
for (long long i = k + 1; i < n - k + 1; i++) {
if (pa == -1) {
pa = aa;
push_back = bb;
} else {
if (s[aa] + s[bb] > s[pa] + s[push_back]) {
pa = aa;
push_back = bb;
}
}
if (s[i - k] > s[aa]) aa = i - k;
bb = i;
}
if (pa == -1) {
pa = aa;
push_back = bb;
} else {
if (s[aa] + s[bb] > s[pa] + s[push_back]) {
pa = aa;
push_back = bb;
}
}
cout << pa + 1 << " " << push_back + 1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 1e9;
const long long IINF = 1e18;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const char dir[4] = {'D', 'R', 'U', 'L'};
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
os << v[i] << (i + 1 == v.size() ? "" : " ");
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &m) {
os << '{';
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << '(' << itr->first << ',' << itr->second << ')';
if (++itr != m.end()) os << ',';
--itr;
}
os << '}';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
os << '{';
for (auto itr = s.begin(); itr != s.end(); ++itr) {
os << *itr;
if (++itr != s.end()) os << ',';
--itr;
}
os << '}';
return os;
}
void debug_out() { cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
cerr << head;
if (sizeof...(Tail) > 0) cerr << ", ";
debug_out(move(tail)...);
}
template <typename T>
T gcd(T x, T y) {
return y != 0 ? gcd(y, x % y) : x;
}
template <typename T>
T lcm(T x, T y) {
return x / gcd(x, y) * y;
}
template <class T1, class T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
struct CumulativeSum2D {
int H, W;
vector<vector<T>> dat;
CumulativeSum2D(vector<vector<T>> v) {
H = v.size(), W = v[0].size();
dat.assign(H + 1, vector<T>(W + 1, 0));
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
dat[i + 1][j + 1] = v[i][j];
dat[i + 1][j + 1] += dat[i + 1][j] + dat[i][j + 1] - dat[i][j];
}
}
}
T query(int sx, int gx, int sy, int gy) {
return dat[gx][gy] - dat[sx][gy] - dat[gx][sy] + dat[sx][sy];
}
};
const int MAX_N = 55;
int dp[MAX_N][MAX_N][MAX_N][MAX_N];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<string> S(n);
cin >> S;
vector<vector<int>> v(n, vector<int>(n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
v[i][j] = (S[i][j] == '#');
}
}
CumulativeSum2D<int> CS(v);
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= n; ++k) {
for (int l = 0; l <= n; ++l) {
dp[i][j][k][l] = n;
}
}
}
}
for (int i = 0; i <= n; ++i) {
for (int k = 0; k <= n; ++k) {
dp[i][i][k][k] = 0;
}
}
for (int j = 0; j <= n; ++j) {
for (int i = 0; i + j <= n; ++i) {
for (int l = 0; l <= n; ++l) {
for (int k = 0; k + l <= n; ++k) {
chmin(dp[i][i + j][k][k + l], max(j, l));
if (j >= 1 && CS.query(i, i + 1, k, k + l) == 0)
chmin(dp[i][i + j][k][k + l], dp[i + 1][i + j][k][k + l]);
if (j >= 1 && CS.query(i + j - 1, i + j, k, k + l) == 0)
chmin(dp[i][i + j][k][k + l], dp[i][i + j - 1][k][k + l]);
if (l >= 1 && CS.query(i, i + j, k, k + 1) == 0)
chmin(dp[i][i + j][k][k + l], dp[i][i + j][k + 1][k + l]);
if (l >= 1 && CS.query(i, i + j, k + l - 1, k + l) == 0)
chmin(dp[i][i + j][k][k + l], dp[i][i + j][k][k + l - 1]);
for (int m = 1; m < j; ++m)
chmin(dp[i][i + j][k][k + l],
dp[i][i + m][k][k + l] + dp[i + m][i + j][k][k + l]);
for (int m = 1; m < l; ++m)
chmin(dp[i][i + j][k][k + l],
dp[i][i + j][k][k + m] + dp[i][i + j][k + m][k + l]);
}
}
}
}
cout << dp[0][n][0][n] << '\n';
}
| 7 |
#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;
}
};
template <typename T>
void db(T x) {
debug() << ">>> " << x;
}
template <typename T>
void db(T x, T y) {
debug() << ">>> " << x << " , " << y;
}
template <typename T>
void db(T x, T y, T z) {
debug() << ">>> " << x << " , " << y << " , " << z;
}
template <typename T>
void db(T x, T y, T z, T a) {
debug() << ">>> " << x << " , " << y << " , " << z << " , " << a;
}
const long long xx = 2e5;
const long long Mod = 1e9 + 7;
const long long inf = 1e18;
const long long Maxn = 20010;
long long Cnt[100][2];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
memset(Cnt, 0, sizeof Cnt);
long long n, m;
cin >> n >> m;
long long mat[60][60];
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cin >> mat[i][j];
}
}
for (long long i = 1; i <= m; i++) {
long long r = 1, c = i;
while (r <= n && c >= 1) {
Cnt[i][0] += mat[r][c] == 0;
Cnt[i][1] += mat[r][c] == 1;
r++, c--;
}
}
long long d = m + 1;
for (long long i = 2; i <= n; i++) {
long long r = i, c = m;
while (r <= n && c >= 1) {
Cnt[d][0] += mat[r][c] == 0;
Cnt[d][1] += mat[r][c] == 1;
r++, c--;
}
d++;
}
for (long long i = 1; i <= n + m - 1; i++) {
debug() << "\033[94m ["
<< "i"
": "
<< (i)
<< "]\033[0m"
"\033[94m ["
<< "Cnt[i][0]"
": "
<< (Cnt[i][0])
<< "]\033[0m"
"\033[94m ["
<< "Cnt[i][1]"
": "
<< (Cnt[i][1]) << "]\033[0m";
}
long long ans = 0;
for (long long i = 1; i <= (n + m - 1) / 2; i++) {
long long x =
min(Cnt[i][0] + Cnt[n + m - i][0], Cnt[i][1] + Cnt[n + m - i][1]);
debug() << "\033[94m ["
<< "i"
": "
<< (i)
<< "]\033[0m"
"\033[94m ["
<< "x"
": "
<< (x) << "]\033[0m";
ans += x;
}
cout << ans << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int res = 0, q = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') q = -1, ch = getchar();
while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0', ch = getchar();
return res * q;
}
const double eps = 1e-12, pi = M_PI;
const int oo = (int)2e9, mod = (int)1e9 + 7;
const long long INF = (long long)1e17;
const int N = (int)1e6;
int n, m, K, d;
char s[2][N + 10];
int f[N + 10][22];
int main() {
scanf("%s", s[0]), n = strlen(s[0]);
int cur = 0;
scanf(
"%d"
"\n",
&m);
for (; m--;) {
scanf(
"%d"
"%d"
"\n",
&K, &d);
cur ^= 1;
if (d == 1) {
for (int i = (0), end = (n - 1); i <= end; ++i) s[cur][i] = s[cur ^ 1][i];
for (int i = (0), end = (n - 1); i <= end; ++i) printf("%c", s[cur][i]);
printf("\n");
continue;
}
int tot = 0;
for (int i = (0), end = (d - 1); i <= end; ++i) {
f[i][0] = tot++;
for (int j = i + d; j < K; j += d) f[j][0] = f[j - d][0] + 1, ++tot;
}
for (int i = (1), end = (20); i <= end; ++i) {
int to = 1 << (i - 1);
if (to > n) break;
for (int j = (0), end = (K - 1); j <= end; ++j) {
int k = f[j][i - 1];
if (k <= to)
f[j][i] = k;
else
f[j][i] = f[k - to][i - 1] + to;
}
}
int u = K - 1;
for (int i = (0), end = (n - 1); i <= end; ++i) {
int tot = 0, now = min(i, u), ed = min(n - i, n - K + 1);
for (int j = (20), end = (0); j >= end; --j)
if (tot + (1 << j) <= ed) {
if (now <= tot) break;
now = tot + f[now - tot][j], tot += (1 << j);
}
now += max(0, i - u);
s[cur][now] = s[cur ^ 1][i];
}
for (int i = (0), end = (n - 1); i <= end; ++i) printf("%c", s[cur][i]);
printf("\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000003;
struct A {
char a[500005];
int n, m;
char& at(const int& x, const int& y) { return a[x * m + y]; }
} ma;
int main() {
int i, j, n, m;
scanf("%d%d", &n, &m);
ma.n = n;
ma.m = m;
char str[500005];
for (i = 0; i < n; ++i) {
scanf("%s", str);
for (j = 0; j < m; ++j) {
switch (str[j]) {
case '.':
ma.at(i, j) = -1;
break;
case '3':
ma.at(i, j) = 3;
break;
case '4':
ma.at(i, j) = 2;
break;
default:
ma.at(i, j) = str[j] - '1';
}
}
}
bool tag;
int ans = 1, dir;
for (i = 0; i < n; ++i) {
tag = false;
for (j = 0; j < m; ++j) {
if (ma.at(i, j) != -1) {
if (!tag) {
tag = true;
dir = (ma.at(i, j) ^ (j << 1)) & 2;
} else if (((ma.at(i, j) ^ (j << 1)) & 2) != dir) {
puts("0");
return 0;
}
}
}
if (!tag) {
ans = (ans << 1) % mod;
}
}
for (j = 0; j < m; ++j) {
tag = false;
for (i = 0; i < n; ++i) {
if (ma.at(i, j) != -1) {
if (!tag) {
tag = true;
dir = (ma.at(i, j) ^ i) & 1;
} else if (((ma.at(i, j) ^ i) & 1) != dir) {
puts("0");
return 0;
}
}
}
if (!tag) {
ans = (ans << 1) % mod;
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long cross(long long *a, long long *b) {
long long s = 0;
for (int i = 0; i < 3; i++) s += a[i] * b[i];
return s;
}
long long dis(long long *a) { return cross(a, a); }
int p[10][3], q[10][3];
int fg;
bool find(long long *a) {
for (int i = 0; i < 8; i++) {
if (a[0] == q[i][0] && a[1] == q[i][1] && a[2] == q[i][2]) return 1;
}
return 0;
}
bool check() {
long long dx[3], dy[3], dz[3], a[3], b[3], c[3], d[3];
for (int i = 1; i < 8; i++)
for (int j = i + 1; j < 8; j++)
for (int k = j + 1; k < 8; k++) {
for (int l = 0; l < 3; l++) dx[l] = q[i][l] - q[0][l];
for (int l = 0; l < 3; l++) dy[l] = q[j][l] - q[0][l];
for (int l = 0; l < 3; l++) dz[l] = q[k][l] - q[0][l];
if (dis(dx) != 0 && cross(dx, dy) == 0 && cross(dx, dz) == 0 &&
cross(dy, dz) == 0 && dis(dx) == dis(dy) && dis(dy) == dis(dz)) {
for (int l = 0; l < 3; l++) a[l] = q[0][l] + dx[l] + dy[l];
for (int l = 0; l < 3; l++) b[l] = q[0][l] + dx[l] + dz[l];
for (int l = 0; l < 3; l++) c[l] = q[0][l] + dy[l] + dz[l];
for (int l = 0; l < 3; l++) d[l] = q[0][l] + dx[l] + dy[l] + dz[l];
if (find(a) && find(b) && find(c) && find(d)) return 1;
}
}
return 0;
}
void dfs(int u) {
if (u >= 8) {
if (check()) {
puts("YES");
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 3; j++) printf("%d ", q[i][j]);
puts("");
}
throw 1;
}
} else {
q[u][0] = p[u][0];
q[u][1] = p[u][1];
q[u][2] = p[u][2];
dfs(u + 1);
q[u][0] = p[u][0];
q[u][1] = p[u][2];
q[u][2] = p[u][1];
dfs(u + 1);
q[u][0] = p[u][1];
q[u][1] = p[u][0];
q[u][2] = p[u][2];
dfs(u + 1);
q[u][0] = p[u][1];
q[u][1] = p[u][2];
q[u][2] = p[u][0];
dfs(u + 1);
q[u][0] = p[u][2];
q[u][1] = p[u][0];
q[u][2] = p[u][1];
dfs(u + 1);
q[u][0] = p[u][2];
q[u][1] = p[u][1];
q[u][2] = p[u][0];
dfs(u + 1);
}
}
int main() {
for (int i = 0; i < 8; i++)
for (int j = 0; j < 3; j++) scanf("%d", &p[i][j]);
for (int i = 0; i < 3; i++) q[0][i] = p[0][i];
try {
dfs(1);
} catch (int e) {
fg = 1;
}
if (!fg) puts("NO");
}
| 6 |
#include <bits/stdc++.h>
const int N = 1e6, NO = -1;
const double PI = 3.14;
using namespace std;
long long n, m, k, a[N], sum;
bool ok(int x) {
long long sum2 = 0, u = 0;
for (int i = 1; i <= n; i++) {
sum2 += max(a[i] - (i - 1) / x, u);
}
if (sum2 >= m) return true;
return false;
}
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
sum += a[i];
}
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
if (sum < m) {
printf("%d", NO);
return 0;
}
int lo = 1, hi = n + 5, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (ok(mid))
hi = mid;
else
lo = mid + 1;
}
cout << lo;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define maxn 400005
#define mod 1000000007
typedef long long ll;
typedef pair<int, int> P;
int n;
bool used[maxn];
int a[maxn], b[maxn];
queue<int> q;
int main()
{
//freopen("tree.txt", "r", stdin);
//freopen("1.out", "w", stdout);
//std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int T;
cin >> T;
for (int kase = 1; kase <= T; kase++)
{
scanf("%d", &n);
for (int i = 1; i <= 2 * n; i++)
used[i] = 0;
for (int i = 1; i <= n; i++)
{
scanf("%d", &b[i]);
used[b[i]] = 1;
}
while (!q.empty())
q.pop();
for (int i = 1; i <= 2 * n; i++)
if (used[i] == 0)
q.push(i);
int x = 0;
for (int i = 1; i <= 2 * n; i++)
{
if (used[i])
{
while (!q.empty() && q.front() < i)
q.pop();
if (!q.empty())
{
q.pop();
x++;
}
}
}
while (!q.empty())
q.pop();
for (int i = 2 * n; i >= 1; i--)
if (used[i] == 0)
q.push(i);
int y = 0;
for (int i = 2 * n; i >= 1; i--)
{
if (used[i])
{
while (!q.empty() && q.front() > i)
q.pop();
if (!q.empty())
{
q.pop();
y++;
}
}
}
y = n - y;
//printf("x=%d y=%d\n", x, y);
printf("%d\n", x - y + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> mp[350000];
int f[350000];
int vis[350000];
int sum[350000];
int root, maxn;
int find(int a) {
int r = a;
while (f[r] != r) r = f[r];
int i = a;
int j;
while (i != r) {
j = f[i];
f[i] = r;
i = j;
}
return r;
}
void merge(int a, int b) {
int A, B;
A = find(a);
B = find(b);
if (A == B) return;
if (sum[A] > sum[B]) {
f[B] = A;
sum[A] = max(sum[A], (sum[A] + 1) / 2 + (sum[B] + 1) / 2 + 1);
} else {
f[A] = B;
sum[B] = max(sum[B], (sum[A] + 1) / 2 + (sum[B] + 1) / 2 + 1);
}
}
void Dfs(int u, int from, int depth) {
if (depth == 0) root = u;
if (depth > maxn) {
maxn = depth;
root = u;
}
vis[u] = 1;
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i];
if (v == from)
continue;
else {
Dfs(v, u, depth + 1);
}
}
}
void dfs(int u, int from, int depth) {
if (depth > maxn) {
maxn = depth;
}
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i];
if (v == from)
continue;
else {
dfs(v, u, depth + 1);
}
}
}
int main() {
int n, m, q;
while (~scanf("%d%d%d", &n, &m, &q)) {
for (int i = 1; i <= n; i++) mp[i].clear();
for (int i = 1; i <= n; i++) f[i] = i, sum[i] = 0;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
mp[x].push_back(y);
mp[y].push_back(x);
merge(x, y);
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
maxn = 0;
Dfs(i, -1, 0);
maxn = 0;
dfs(root, -1, 0);
sum[find(i)] = maxn;
}
}
for (int i = 1; i <= q; i++) {
int op;
scanf("%d", &op);
if (op == 1) {
int x;
scanf("%d", &x);
printf("%d\n", sum[find(x)]);
} else {
int x, y;
scanf("%d%d", &x, &y);
if (find(x) == find(y))
continue;
else
merge(x, y);
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, t = 0;
string s;
cin >> n >> s;
vector<int> ans(n);
vector<int> p0, p1;
for (int i = 0; i < n; i++) {
int np = p0.size() + p1.size();
if (s[i] == '0') {
if (p1.empty()) {
p0.push_back(np);
} else {
np = p1.back();
p1.pop_back();
p0.push_back(np);
}
} else {
if (p0.empty()) {
p1.push_back(np);
} else {
np = p0.back();
p0.pop_back();
p1.push_back(np);
}
}
ans[i] = np;
}
cout << p0.size() + p1.size() << endl;
for (auto i : ans) {
cout << i + 1 << ' ';
}
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long w, h, k, ans = 0;
cin >> w >> h >> k;
while (k-- && w >= 2 && h >= 2) {
ans += 2 * (max(w, h)) + 2 * (min(w, h) - 2);
w -= 4;
h -= 4;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 14) + 100;
bool mp[2][N];
int f[2][N];
bool vis[2][N];
char st[N];
int mfa[N];
int solve(char x) {
if (x >= '0' && x <= '9')
return x - '0';
else
return x - 'A' + 10;
}
void change(int tmp) {
int len = strlen(st);
int bef = 1;
memset(vis[tmp], false, sizeof(vis[tmp]));
for (int i = len - 1; i >= 0; i--) {
int now = solve(st[i]);
for (int j = 0; j < 4; j++) {
if ((now >> j) & 1) {
vis[tmp][j + bef] = true;
}
}
bef += 4;
}
}
int Find(int x, int op) {
return f[op][x] == x ? x : f[op][x] = Find(f[op][x], op);
}
int main() {
int n, m;
cin >> n >> m;
int tmp = 1;
int ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", st);
change(tmp);
memset(mp, false, sizeof(mp));
memset(mfa, -1, sizeof(mfa));
for (int j = 1; j <= m; j++) {
int fj = Find(j, 1 - tmp);
if (vis[1 - tmp][j]) mp[0][fj] = true;
if (vis[tmp][j] && vis[1 - tmp][j]) {
mp[1][fj] = true;
mfa[fj] = j;
}
}
for (int j = 1; j <= m; j++)
if (mp[0][j] != mp[1][j]) ans++;
for (int j = 1; j <= m; j++)
if (vis[tmp][j] && vis[1 - tmp][j])
f[tmp][j] = mfa[Find(j, 1 - tmp)];
else
f[tmp][j] = j;
for (int j = 2; j <= m; j++) {
if (vis[tmp][j] == false || vis[tmp][j - 1] == false) continue;
int fa = Find(j, tmp);
int fb = Find(j - 1, tmp);
f[tmp][fa] = fb;
}
if (i == n) {
set<int> ret;
for (int j = 1; j <= m; j++)
if (vis[tmp][j]) ret.insert(Find(j, tmp));
ans += ret.size();
}
tmp = 1 - tmp;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
vector<int> G[MAXN], dp[MAXN];
int w[MAXN], de[MAXN], r;
void init_G() {
for (int i = 0; i <= 1000; i++) {
G[i].resize(0);
}
}
void init_dfs() {
for (int i = 0; i <= 1000; i++) {
dp[i].resize(0);
w[i] = de[i] = 0;
}
}
void ask(vector<int> &vec) {
printf("? %d", (int)vec.size());
for (auto x : vec) {
printf(" %d", x);
}
puts("");
fflush(stdout);
}
void ans(int x, int y) {
printf("! %d %d\n", x, y);
fflush(stdout);
scanf("%*s");
}
void dfs1(int u, int p, int d) {
int x = d;
for (auto v : G[u]) {
if (v != p) {
dfs1(v, u, d + 1);
x = max(x, w[v]);
}
}
w[u] = x;
}
void del(int u) {
for (auto v : G[u]) {
if (w[v] == w[u]) {
de[v] = 1;
return;
}
}
}
void dfs2(int u, int p, int d) {
dp[d].push_back(u);
r = max(r, d);
for (auto v : G[u]) {
if (v != p && de[v] != 1) {
dfs2(v, u, d + 1);
}
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
init_G();
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
vector<int> temp;
for (int i = 1; i <= n; i++) {
temp.push_back(i);
}
ask(temp);
int x, dis;
scanf("%d%d", &x, &dis);
init_dfs();
dfs1(x, -1, 0);
del(x);
r = 0;
dfs2(x, -1, 0);
int l = 1;
int y, z;
while (l <= r) {
int mid = (l + r) >> 1;
ask(dp[mid]);
scanf("%d%d", &y, &z);
if (z == dis) {
x = y;
l = mid + 1;
} else {
r = mid - 1;
}
}
init_dfs();
dfs2(x, -1, 0);
ask(dp[dis]);
scanf("%d%d", &y, &z);
ans(x, y);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int q, n;
int a[200200];
int used[200200];
int ans[200200];
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
used[i] = 0;
scanf("%d", a + i);
a[i]--;
}
for (int i = 0; i < n; i++) {
if (!used[i]) {
vector<int> c;
int x = i;
while (!used[x]) {
c.push_back(x);
used[x] = 1;
x = a[x];
}
for (__typeof(c.begin()) it = c.begin(); it != c.end(); it++)
ans[*it] = c.size();
}
}
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
}
int main() {
scanf("%d", &q);
while (q--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename F, typename... Args>
void timeit(F func, Args&&... args) {
clock_t start = clock();
func(std::forward<Args>(args)...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 2e5 + 1000;
long long val[maxn];
long long presum[maxn], sufsum[maxn];
void solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> val[i];
sufsum[i] = presum[i] = val[i];
}
for (long long i = n; i > 0; i--) sufsum[i] += sufsum[i + 2];
for (long long i = 3; i <= n; i++) presum[i] += presum[i - 2];
long long ans = presum[n], tmp;
for (long long i = 1; i < n; i++) {
tmp = val[i] + val[i + 1] + (i - 2 > 0 ? presum[i - 2] : 0) +
(i + 3 <= n ? sufsum[i + 3] : 0);
ans = max(ans, tmp);
}
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false), cin.tie(NULL);
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void GO() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
const long long INF = 1e9 + 7;
const long long mod = (1e9) + 7;
const int maxn = (int)2001;
const long double PI = acos(-1.0);
const long double eps = 0.000000001;
mt19937 rnd(time(0));
int dp[maxn][maxn];
void solve() {
int n, k;
cin >> n >> k;
vector<string> a(n);
for (auto &i : a) cin >> i;
dp[0][0] = (a[0][0] != 'a');
for (int i = 1; i < n; ++i) {
dp[0][i] = dp[0][i - 1] + (a[0][i] != 'a');
dp[i][0] = dp[i - 1][0] + (a[i][0] != 'a');
}
for (int i = 1; i < n; ++i) {
for (int j = 1; j < n; ++j) {
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + (a[i][j] != 'a');
}
}
set<pair<int, int> > mas;
int mx = -1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (dp[i][j] > k) continue;
if (i + j > mx) mas.clear(), mx = i + j;
if (i + j == mx) mas.insert({i, j});
}
}
string ans;
if (!int(mas.size())) {
ans += a[0][0];
mas.insert({0, 0});
} else
for (int i = 0; i < mas.begin()->first + mas.begin()->second + 1; ++i)
ans += 'a';
while (int(mas.size())) {
set<pair<int, int> > mas2;
char best = '~';
for (auto &c : mas) {
int i = c.first, j = c.second;
if (i + 1 < n) {
if (a[i + 1][j] < best) best = a[i + 1][j], mas2.clear();
if (a[i + 1][j] == best) mas2.insert({i + 1, j});
}
if (j + 1 < n) {
if (a[i][j + 1] < best) best = a[i][j + 1], mas2.clear();
if (a[i][j + 1] == best) mas2.insert({i, j + 1});
}
}
if (best != '~') ans += best;
mas = mas2;
}
cout << ans;
}
signed main() {
GO();
int Q = 1;
while (Q--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
const int maxlen = 1e7 + 10;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
pair<pair<int, int>, int> q[maxlen];
char a[4][maxn][maxn];
int n, m, l = 1, r, to[1 << 8], nxt[1 << 8], dp[4][maxn][maxn];
void make(char ch, bool b1, bool b2, bool b3, bool b4) {
to[ch] = (b1 << 0) + (b2 << 1) + (b3 << 2) + (b4 << 3);
}
void init() {
nxt['+'] = '+';
nxt['-'] = '|';
nxt['|'] = '-';
nxt['^'] = '>';
nxt['>'] = 'v';
nxt['<'] = '^';
nxt['v'] = '<';
nxt['L'] = 'U';
nxt['R'] = 'D';
nxt['U'] = 'R';
nxt['D'] = 'L';
nxt['*'] = '*';
make('+', 1, 1, 1, 1);
make('-', 0, 1, 0, 1);
make('|', 1, 0, 1, 0);
make('^', 1, 0, 0, 0);
make('>', 0, 0, 0, 1);
make('<', 0, 1, 0, 0);
make('v', 0, 0, 1, 0);
make('L', 1, 0, 1, 1);
make('R', 1, 1, 1, 0);
make('U', 0, 1, 1, 1);
make('D', 1, 1, 0, 1);
make('*', 0, 0, 0, 0);
}
bool pd(int x, int y) { return x > 0 && y > 0 && x <= n && y <= m; }
bool pass(int hx, int hy, int which, int chk) {
return to[a[which][hx][hy]] & 1 << chk;
}
int main() {
init();
char buf[maxn];
int sx, sy, tx, ty;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
gets(buf);
for (int j = 1; j <= m; j++) {
a[0][i][j] = getchar();
for (int k = 1; k < 4; k++) {
a[k][i][j] = nxt[a[k - 1][i][j]];
}
}
}
scanf("%d %d %d %d", &sx, &sy, &tx, &ty);
if (sx == tx && sy == ty) {
return puts("0"), 0;
}
dp[0][sx][sy] = 1;
q[++r] = make_pair(make_pair(sx, sy), 0);
for (; l <= r;) {
pair<pair<int, int>, int> u = q[l++];
int px = u.first.first, py = u.first.second, t = dp[u.second][px][py];
if (!dp[(u.second + 1) % 4][px][py]) {
dp[(u.second + 1) % 4][px][py] = t + 1;
q[++r] = make_pair(u.first, (u.second + 1) % 4);
}
for (int i = 0; i < 4; i++) {
int nx = px + dx[i], ny = py + dy[i];
if (pd(nx, ny) && pass(px, py, u.second, i) &&
pass(nx, ny, u.second, (i + 2) % 4)) {
if (nx == tx && ny == ty) {
printf("%d", t);
return 0;
}
if (!dp[u.second][nx][ny]) {
dp[u.second][nx][ny] = t + 1;
q[++r] = make_pair(make_pair(nx, ny), u.second);
}
}
}
}
puts("-1");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
struct dat {
int t, u, o;
};
int n, m, c[N], fa[N], sz[N], vsz[N], ch[N][2], pa[N];
long long sz2[N], vsz2[N], ans[N];
vector<int> E[N];
vector<dat> eve[N];
void dfs(int u) {
for (auto v : E[u])
if (v ^ pa[u]) pa[v] = u, dfs(v);
}
long long sqr(int x) { return 1ll * x * x; }
void pushup(int x) {
sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + vsz[x] + 1;
sz2[x] = vsz2[x] + sqr(sz[ch[x][0]]) + sqr(sz[ch[x][1]]);
}
bool isroot(int x) { return ch[fa[x]][0] != x && ch[fa[x]][1] != x; }
void rotate(int x) {
int y = fa[x], z = fa[y], w = ch[y][1] == x;
if (!isroot(y)) ch[z][ch[z][1] == y] = x;
ch[y][w] = ch[x][w ^ 1];
fa[ch[y][w]] = y;
ch[x][w ^ 1] = y;
fa[y] = x;
fa[x] = z;
pushup(y);
pushup(x);
}
void splay(int x) {
while (!isroot(x)) {
int y = fa[x], z = fa[y];
if (!isroot(y)) (ch[y][0] == x) ^ (ch[z][0] == y) ? rotate(x) : rotate(y);
rotate(x);
}
}
void access(int x) {
for (int t = 0; x; t = x, x = fa[x]) {
splay(x);
vsz[x] += sz[ch[x][1]];
vsz2[x] += sqr(sz[ch[x][1]]);
ch[x][1] = t;
vsz[x] -= sz[t];
vsz2[x] -= sqr(sz[t]);
pushup(x);
}
}
int findroot(int x) {
access(x);
splay(x);
while (ch[x][0]) x = ch[x][0];
splay(x);
return x;
}
void link(int x, int ff) {
access(ff);
splay(ff);
splay(x);
vsz[ff] += sz[x];
vsz2[ff] += sqr(sz[x]);
fa[x] = ff;
pushup(ff);
}
void cut(int x, int ff) {
access(ff);
splay(ff);
splay(x);
vsz[ff] -= sz[x];
vsz2[ff] -= sqr(sz[x]);
fa[x] = 0;
pushup(ff);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) c[i] = gi();
for (int i = 1, u, v; i < n; i++)
u = gi(), v = gi(), E[u].push_back(v), E[v].push_back(u);
dfs(1), pa[1] = n + 1;
for (int i = 1; i <= n + 1; i++) sz[i] = 1;
for (int i = 1; i <= n; i++) link(i, pa[i]);
for (int i = 1; i <= n; i++) eve[c[i]].push_back((dat){0, i, 0});
for (int i = 1; i <= m; i++) {
int u = gi(), x = gi();
eve[c[u]].push_back((dat){i, u, 1});
eve[c[u] = x].push_back((dat){i, u, 0});
}
for (int i = 1; i <= n; i++) eve[c[i]].push_back((dat){m + 1, i, 1});
for (int i = 1; i <= n; i++)
for (auto x : eve[i]) {
int t = x.t, u = x.u, ff = findroot(pa[u]);
if (x.o) {
splay(ff), splay(u), ans[t] += sz2[ff] + sz2[u];
link(u, pa[u]), splay(ff), ans[t] -= sz2[ff];
} else {
splay(ff), ans[t] += sz2[ff], cut(u, pa[u]);
splay(ff), splay(u), ans[t] -= sz2[ff] + sz2[u];
}
}
for (int i = 1; i <= m; i++) ans[i] += ans[i - 1];
for (int i = 0; i <= m; i++) cout << ans[i] << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int N, M, Q, edgeRule[13 + 3][2], lcaRule[100 + 3][3];
bool counted[(1 << 13) + 3];
long long int dp[13 + 3][(1 << 13) + 3];
bool validateEdgeRule(int root, int mask, int newRoot, int newMask) {
for (int i = 0; i < M; i++) {
for (int k = 0; k < 2; k++) {
if ((mask & (1 << edgeRule[i][0])) && (newMask & (1 << edgeRule[i][1]))) {
if (edgeRule[i][0] != root || edgeRule[i][1] != newRoot) return false;
}
swap(edgeRule[i][0], edgeRule[i][1]);
}
}
return true;
}
bool validateLcaRule(int root, int mask, int newRoot, int newMask) {
for (int i = 0; i < Q; i++) {
for (int k = 0; k < 2; k++) {
if ((mask & (1 << lcaRule[i][0])) && (newMask & (1 << lcaRule[i][1]))) {
if (lcaRule[i][2] != root) return false;
}
swap(lcaRule[i][0], lcaRule[i][1]);
}
}
return true;
}
int lsb(int mask) { return (mask & -mask); }
long long int solve(int root, int mask) {
if (mask - lsb(mask) == 0) return 1;
if (dp[root][mask] != -1) return dp[root][mask];
long long int result = 0;
int maskWithoutRoot = mask ^ (1 << root);
memset(counted, false, sizeof(counted));
for (int newMask = maskWithoutRoot; newMask > 0;
newMask = (newMask - 1) & maskWithoutRoot) {
if (lsb(newMask) == lsb(maskWithoutRoot)) {
for (int newRoot = 0; newRoot < N; newRoot++) {
if (newMask & (1 << newRoot)) {
if (validateEdgeRule(root, (mask ^ newMask), newRoot, newMask) &&
validateLcaRule(root, (mask ^ newMask), newRoot, newMask))
result += solve(newRoot, newMask) * solve(root, mask ^ newMask);
}
}
}
}
return dp[root][mask] = result;
}
int main() {
cin >> N >> M >> Q;
for (int i = 0; i < M; i++) {
cin >> edgeRule[i][0] >> edgeRule[i][1];
for (int k = 0; k < 2; k++) edgeRule[i][k] -= 1;
}
for (int i = 0; i < Q; i++) {
cin >> lcaRule[i][0] >> lcaRule[i][1] >> lcaRule[i][2];
for (int k = 0; k < 3; k++) lcaRule[i][k] -= 1;
if (lcaRule[i][0] == lcaRule[i][1] && lcaRule[i][2] != lcaRule[i][0]) {
cout << 0 << endl;
return 0;
}
}
memset(dp, -1, sizeof(dp));
cout << solve(0, (1 << N) - 1) << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, i, j, k, x, y, mark = -1, ans = 0, num = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, greater<int>());
if (a[n - 1] != 0) {
cout << "-1\n";
} else {
for (i = 0; i < n; i++) {
if (a[i] == 5) {
ans++;
} else {
num++;
}
}
if (ans < 9) {
cout << "0";
} else {
long long int cnt = (ans / 9) * 9;
for (i = 0; i < cnt; i++) {
cout << "5";
}
for (i = 0; i < num; i++) {
cout << "0";
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U>& l, const std::pair<T, U>& r) {
return {l.first + r.first, l.second + r.second};
}
typedef void (*callback_function)(void);
const long long INF64 = 1e18;
const long long INF32 = 1e9;
const long long MOD = 1e9 + 7;
const long double PI = acos(-1.0L);
const long double EPS = static_cast<long double>(1e-9);
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
{
long long n;
cin >> n;
pair<long long, long long> a[n];
for (long long i = (0); i < (n); i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort(a, a + n);
cout << (n + 1) / 2 << endl;
for (long long i = 0; i < n; i += 2) cout << a[i].second << ' ';
cout << endl << n / 2 << endl;
for (long long i = 1; i < n; i += 2) cout << a[i].second << ' ';
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007, m = 1 << 20;
int n, f[m + 10], two[m + 10], ans;
void work() {
scanf("%d", &n);
for (int i = 1, x; i <= n; i++) scanf("%d", &x), f[x]++;
for (int i = 0; i < 20; i++)
for (int j = 0; j < m; j++)
if (j & (1 << i)) f[j ^ (1 << i)] += f[j];
two[0] = 1;
for (int i = 1; i <= n; i++) two[i] = (two[i - 1] << 1) % mo;
for (int i = 0; i < m; i++) {
int x = i, p = 0;
while (x) p += x & 1, x >>= 1;
if (p & 1)
ans = (ans - two[f[i]] + mo) % mo;
else
ans = (ans + two[f[i]]) % mo;
}
printf("%d", ans);
}
int main() {
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
int a[maxn + 1], l[maxn + 1], r[maxn + 1], ans[maxn + 1], p[maxn + 1];
int v[maxn + 1];
int main() {
int n, i, m, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] <= maxn) v[a[i]]++;
}
for (i = 1; i <= m; i++) scanf("%d%d", &l[i], &r[i]);
for (i = 1; i <= maxn; i++) {
if (v[i] >= i) {
p[0] = 0;
for (j = 1; j <= n; j++) {
p[j] = p[j - 1] + (a[j] == i);
}
for (j = 1; j <= m; j++) {
ans[j] += p[r[j]] - p[l[j] - 1] == i;
}
}
}
for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 205;
int a[maxn], b[maxn];
int n, m;
bool check(int num) {
for (int i = 1; i <= n; ++i) {
bool flag = 0;
for (int j = 1; j <= m; ++j) {
if (((a[i] & b[j]) | num) == num) {
flag = 1;
break;
}
}
if (!flag) return false;
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; ++i) {
scanf("%d", &b[i]);
}
int ansLimit = 512;
int minAns = 511;
for (int i = 0; i < ansLimit; ++i) {
if (check(i)) {
minAns = i;
break;
}
}
printf("%d\n", minAns);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 7;
const int inf = INT_MAX;
const long long inff = 1e18;
const long long mod = 1e9 + 7;
long long n;
long long a[maxn];
vector<long long> v;
long long dp[maxn], Minn[maxn];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long minn = inff;
for (long long i = 1; i <= n; i++) {
if (a[i] == -1)
;
else if (minn != -1)
v.push_back(0);
else
v.push_back(a[i]);
minn = min(minn, a[i]);
}
long long now = n, cnt = 0;
while (now != 1) {
for (long long i = 1; i <= n - 1; i++) dp[i] = inff;
for (long long i = now - 1; i <= n - 1 - cnt; i++)
dp[i] = v[i - 1] + Minn[i + 1];
for (long long i = n - 1; i >= 1; i--) {
if (i == n - 1)
Minn[i] = dp[i];
else
Minn[i] = min(dp[i], Minn[i + 1]);
}
now /= 2;
cnt++;
}
cout << Minn[1] << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
priority_queue<int, vector<int>, greater<int> > pq;
vector<int> v;
multiset<int> ms;
int vec[100];
int num[101];
char ans[101];
vector<int> o, t, th;
queue<int> lo[101];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &vec[i]);
lo[vec[i]].push(i);
num[vec[i]]++;
}
for (int i = 1; i <= 100; i++) {
if (num[i] == 1) o.push_back(i);
if (num[i] == 2) t.push_back(i);
if (num[i] >= 3) th.push_back(i);
}
if ((int)(o).size() % 2 && (int)(th).size() == 0) return !printf("NO");
printf("YES\n");
int tt;
for (int i = 0; i < (int)(o).size() / 2; i++) {
tt = lo[o[i]].front();
lo[o[i]].pop();
ans[tt] = 'A';
}
for (int i = (int)(o).size() / 2; i < (int)(o).size(); i++) {
tt = lo[o[i]].front();
lo[o[i]].pop();
ans[tt] = 'B';
}
for (int i = 0; i < (int)(t).size(); i++) {
while (!lo[t[i]].empty()) {
tt = lo[t[i]].front();
lo[t[i]].pop();
ans[tt] = 'A';
}
}
if ((int)(o).size() % 2 == 0) {
for (int i = 0; i < (int)(th).size(); i++) {
while (!lo[th[i]].empty()) {
tt = lo[th[i]].front();
lo[th[i]].pop();
ans[tt] = 'A';
}
}
} else {
tt = lo[th[0]].front();
lo[th[0]].pop();
ans[tt] = 'A';
for (int i = 0; i < (int)(th).size(); i++) {
while (!lo[th[i]].empty()) {
tt = lo[th[i]].front();
lo[th[i]].pop();
ans[tt] = 'B';
}
}
}
printf("%s", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int pow(int a, int b) {
if (b == 0)
return 1;
else if (b % 2 == 0)
return pow(a * a, b / 2);
else
return a * pow(a * a, b / 2);
}
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void solve() {
long long n;
cin >> n;
if (n % 2 == 0) {
cout << n / 2 - 1 << endl;
return;
} else {
cout << n / 2 << endl;
}
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
using vint = vector<int>;
using vll = vector<ll>;
using vld = vector<ld>;
using vpii = vector<pii>;
using vpil = vector<pil>;
using vpli = vector<pli>;
using vpll = vector<pll>;
template <typename... Args>
void readln(Args&... args) {
((cin >> args), ...);
}
template <typename... Args>
void writeln(Args... args) {
((cout << args << " "), ...);
cout << '\n';
}
void solve() {
int n, m;
readln(n, m);
;
vector<vint> a(n + 1, vint(m + 1));
for (int i = 1; i <= n; i++) {
string s;
readln(s);
;
for (int j = 1; j <= m; j++) a[i][j] = (s[j - 1] == '1');
}
auto cs = a;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) cs[j][i] += cs[j - 1][i];
}
const auto F = [&](int s, int e, int j) {
return (e - s - 1) - (cs[e - 1][j] - cs[s][j]);
};
const auto G = [&](int s, int e, int j) {
return !a[s][j] + !a[e][j] + (cs[e - 1][j] - cs[s][j]);
};
int ans = n * m;
vint b(m + 1), s(m + 1);
for (int i = 1; i <= n; i++) {
for (int j = i + 4; j <= n; j++) {
for (int k = 1; k <= m; k++) s[k] = s[k - 1] + G(i, j, k);
for (int k = m; k >= 1; k--)
b[k] = min(k == m ? int(1e9) : b[k + 1], s[k - 1] + F(i, j, k));
for (int k = 1; k + 3 <= m; k++)
ans = min(ans, b[k + 3] + F(i, j, k) - s[k]);
}
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
readln(t);
;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void print(long long t) { cerr << t; }
void print(string t) { cerr << t; }
void print(char t) { cerr << t; }
void print(long double t) { cerr << t; }
void print(double t) { cerr << t; }
void print(unsigned long long t) { cerr << t; }
template <class T, class V>
void print(pair<T, V> p);
template <class T>
void print(vector<T> v);
template <class T>
void print(set<T> v);
template <class T, class V>
void print(map<T, V> v);
template <class T>
void print(multiset<T> v);
template <class T, class V>
void print(pair<T, V> p) {
cerr << "{";
print(p.first);
cerr << ",";
print(p.second);
cerr << "}";
}
template <class T>
void print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void print(set<T> v) {
cerr << "[ ";
for (T i : v) {
print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
print(i);
cerr << " ";
}
cerr << "]";
}
const long long inf = 0x3f3f3f3f3f3f3f3f;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void zz() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); }
long long f(string x, string y) {
long long n = x.size();
long long m = y.size();
long long i = 0;
long long j = 0;
long long cnt = 0;
while (i < n && j < m) {
if (x[i] == y[j])
i += 1, j += 1;
else {
i += 1;
cnt += 1;
}
}
cnt += (n - i);
cnt += (m - j);
return cnt;
}
vector<string> v;
void slv() {
string s;
cin >> s;
long long x = inf;
for (long long i = 0; i < 62; i++) {
x = min(x, f(s, v[i]));
}
cout << x << endl;
}
int32_t main() {
zz();
for (long long i = 0; i < 62; i++) {
long long x = (1LL << i);
v.emplace_back(to_string(x));
};
long long t = 1;
cin >> t;
while (t--) {
slv();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int K = 10;
int n, k;
vector<int> e[N];
long long d[N], siz[N], sum[N], num[N][K], f[N][K];
void dfs1(int u, int fa) {
siz[u] = 1;
for (auto v : e[u]) {
if (v != fa) {
dfs1(v, u);
siz[u] += siz[v];
}
}
}
void dfs2(int u, int fa) {
d[u] = 0;
for (auto v : e[u]) {
if (v != fa) {
dfs2(v, u);
sum[u] += (d[v] + siz[v]) * (siz[u] - siz[v]);
d[u] += d[v] + siz[v];
}
}
}
void dfs3(int u, int fa) {
for (int o = 0; o < k; ++o) num[u][o] = 0;
num[u][0] = 1;
for (auto v : e[u]) {
if (v != fa) {
dfs3(v, u);
for (int ou = 0; ou < k; ++ou) {
for (int ov = 0; ov < k; ++ov) {
int nw = (ou + ov + 1) % k;
if (nw != 0) nw = k - nw;
f[u][nw] += num[u][ou] * num[v][ov];
}
}
for (int ov = 0; ov < k; ++ov) {
num[u][(ov + 1) % k] += num[v][ov];
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 0);
dfs3(1, 0);
long long s = 0;
for (int i = 1; i <= n; ++i) {
s += sum[i];
}
for (int i = 1; i <= n; ++i) {
for (int o = 0; o < k; ++o) {
s += f[i][o] * o;
}
}
cout << s / k << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long L[200010], R[200010];
int ans[200010];
struct node {
long long dis1, dis2;
int id;
bool operator<(const node &t) const {
return dis2 == t.dis2 ? dis1 < t.dis1 : dis2 < t.dis2;
}
} dis[200010];
struct Bridge {
long long a;
int id;
Bridge(long long a = 0, int id = 0) : a(a), id(id) {}
bool operator<(const Bridge &t) const {
return a == t.a ? id < t.id : a < t.a;
}
} in;
set<Bridge> bridge;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d", &L[i], &R[i]);
}
for (int i = 1; i < n; i++) {
dis[i].dis1 = L[i + 1] - R[i];
dis[i].dis2 = R[i + 1] - L[i];
dis[i].id = i;
}
sort(dis + 1, dis + n);
for (int i = 1; i <= m; i++) {
scanf("%I64d", &in.a);
in.id = i;
bridge.insert(in);
}
set<Bridge>::iterator it;
bool isok = true;
for (int i = 1; i < n; i++) {
if (bridge.empty()) {
isok = false;
break;
}
it = bridge.lower_bound(Bridge(dis[i].dis1, 0));
if (it == bridge.end() || (*it).a > dis[i].dis2) {
isok = false;
break;
}
ans[dis[i].id] = (*it).id;
bridge.erase(it);
}
if (!isok) {
puts("No");
return 0;
}
puts("Yes");
for (int i = 1; i < n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long N, M, Q;
cin >> N >> M >> Q;
vector<vector<long long>> A(N, vector<long long>(M, 0));
vector<vector<long long>> Queries(Q);
for (long long i = 0; i < Q; i++) {
long long t;
cin >> t;
if (t == 1 || t == 2) {
long long x;
cin >> x;
Queries[i].push_back(t);
Queries[i].push_back(x);
} else {
long long x, y, z;
cin >> x >> y >> z;
Queries[i].push_back(t);
Queries[i].push_back(x);
Queries[i].push_back(y);
Queries[i].push_back(z);
}
}
reverse(Queries.begin(), Queries.end());
for (long long i = 0; i < Q; i++) {
if (Queries[i].at(0) == 3) {
A[Queries[i].at(1) - 1][Queries[i].at(2) - 1] = Queries[i].at(3);
} else if (Queries[i].at(0) == 1) {
long long fst = A[Queries[i].at(1) - 1][M - 1];
for (long long j = M - 1; j >= 1; j--) {
A[Queries[i].at(1) - 1][j] = A[Queries[i].at(1) - 1][j - 1];
}
A[Queries[i].at(1) - 1][0] = fst;
} else {
long long fst = A[N - 1][Queries[i].at(1) - 1];
for (long long j = N - 1; j >= 1; j--) {
A[j][Queries[i].at(1) - 1] = A[j - 1][Queries[i].at(1) - 1];
}
A[0][Queries[i].at(1) - 1] = fst;
}
}
for (long long i = 0; i < N; i++) {
for (long long j = 0; j < M; j++) {
cout << A[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> x(n), y(n);
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
}
function<int(int, int)> gcd = [&](int x, int y) {
return (y == 0 ? x : gcd(y, x % y));
};
auto slope = [&](int x1, int y1, int x2, int y2) {
int dx = x1 - x2;
int dy = y1 - y2;
int g = gcd(dx, dy);
return make_pair(dx / g, dy / g);
};
long long ret = 1LL * n * (n - 1) * (n - 2) / 6;
map<pair<int, int>, int> mp;
for (int i = 0; i < n; ++i) {
mp.clear();
for (int j = i + 1; j < n; ++j) {
ret -= mp[slope(x[i], y[i], x[j], y[j])]++;
}
}
cout << ret << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, turns = 0;
string s1, s2;
cin >> n >> s1 >> s2;
for (int i = 0; i < n; i++) {
int h = max(s1[i], s2[i]) - min(s2[i], s1[i]);
if (h >= 5) {
turns += 10 - h;
} else {
turns += h;
}
}
cout << turns;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
set<int> d;
map<int, int> b;
int n, i, k, x, a[200100];
int main() {
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < k; i++) {
d.insert(a[i]);
b[a[i]]++;
if (b[a[i]] >= 2) d.erase(a[i]);
}
if (!d.size())
printf("Nothing\n");
else
printf("%d\n", *d.rbegin());
for (i = k; i < n; i++) {
b[a[i]]++;
b[a[i - k]]--;
if (!b[a[i - k]])
d.erase(a[i - k]);
else if (b[a[i - k]] == 1)
d.insert(a[i - k]);
if (b[a[i]] == 2)
d.erase(a[i]);
else if (b[a[i]] == 1)
d.insert(a[i]);
if (!d.size())
printf("Nothing\n");
else
printf("%d\n", *d.rbegin());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
int inc[n], dec[n];
inc[0] = 1;
int maxi = 1;
for (long long i = 1; i < n; i++) {
if (a[i] > a[i - 1]) {
inc[i] = inc[i - 1] + 1;
} else {
inc[i] = 1;
}
maxi = max(maxi, inc[i]);
}
dec[n - 1] = 1;
for (long long i = n - 2; i > -1; i--) {
if (a[i] < a[i + 1]) {
dec[i] = dec[i + 1] + 1;
} else {
dec[i] = 1;
}
}
for (long long i = 1; i < n - 1; i++) {
if (a[i] <= a[i - 1]) {
if (a[i + 1] > a[i - 1]) maxi = max(maxi, inc[i - 1] + dec[i + 1]);
}
if (a[i + 1] <= a[i] && a[i + 1] > a[i - 1]) {
maxi = max(maxi, inc[i - 1] + dec[i + 1]);
}
}
cout << maxi << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 31, mo[2] = {998244353, 1004535809}, INF = 1e9;
int n, m, K, h1[2][N], h2[2][N], p[2][N], f[N][M];
char s[N], t[N];
bool Same(int x, int y, int l) {
for (int i = 0; i < 1; i++) {
if ((mo[i] +
(h1[i][x + l - 1] - (long long)h1[i][x - 1] * p[i][l]) % mo[i]) %
mo[i] !=
(mo[i] +
(h2[i][y + l - 1] - (long long)h2[i][y - 1] * p[i][l]) % mo[i]) %
mo[i])
return 0;
}
return 1;
}
int getlcp(int x, int y) {
int l, r, mid;
for (l = 0, r = ((n - x + 1) < (m - y + 1) ? (n - x + 1) : (m - y + 1)),
mid = r >> 1;
l < r; mid = l + r >> 1)
if (!Same(x, y, mid))
r = mid;
else
l = mid + 1;
if (!Same(x, y, l)) l--;
return l;
}
int main() {
scanf("%d%s%d%s%d", &n, s + 1, &m, t + 1, &K);
for (int j = 0; j < 2; j++) {
p[j][0] = 1;
for (int i = 1; i < N; i++) p[j][i] = (long long)p[j][i - 1] * 26 % mo[j];
for (int i = 1; i <= n; i++)
h1[j][i] = ((long long)h1[j][i - 1] * 26 + s[i] - 'a') % mo[j];
for (int i = 1; i <= m; i++)
h2[j][i] = ((long long)h2[j][i - 1] * 26 + t[i] - 'a') % mo[j];
}
f[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < K; j++)
if (f[i][j] < m) {
int k = f[i][j], lcp = getlcp(i + 1, k + 1);
f[i + 1][j] = ((f[i + 1][j]) > (k) ? (f[i + 1][j]) : (k));
if (lcp > 0)
f[i + lcp][j + 1] =
((f[i + lcp][j + 1]) > (k + lcp) ? (f[i + lcp][j + 1])
: (k + lcp));
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= K; j++)
if (f[i][j] == m) {
printf("YES\n");
return 0;
}
printf("NO\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int m;
cin >> m;
int b[m];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (x > 1) a[x - 2] += y - 1;
if (x < n) a[x] += a[x - 1] - y;
a[x - 1] = 0;
}
for (int i = 0; i < n; i++) cout << a[i] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const bool db = false;
int n, m, mod;
int g[555], ones, twos;
int dp[555][555];
int calc(int o, int t) {
if (dp[o][t] != -1) return dp[o][t];
if (o == 0 && t == 1) return 0;
if (o == 0 && t == 0) return 1;
int &res = dp[o][t];
res = 0;
if (o >= 2) {
res += o * 1LL * (o - 1) / 2 % mod * calc(o - 2, t) % mod;
res %= mod;
}
if (o >= 1 && t >= 1) {
res += o * 1LL * t % mod * calc(o, t - 1) % mod;
res %= mod;
}
if (t >= 2) {
res += t * 1LL * (t - 1) / 2 % mod * calc(o + 2, t - 2) % mod;
res %= mod;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &mod);
for (int i = 1; i <= n; ++i) g[i] = 2;
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= n; ++j) {
char c;
cin >> c;
if (c == '1') --g[j];
}
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; ++i)
if (g[i] == 1)
++ones;
else if (g[i] == 2)
++twos;
cout << calc(ones, twos) << endl;
getchar();
getchar();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int main() {
cin >> n >> a >> b;
n -= a;
if (b >= n)
cout << n;
else
cout << b + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200010];
double calc(double val) {
double minres = 200010 * 30010, maxres = -200010 * 30010, smin = 0, smax = 0,
cur = 0;
for (int i = 1; i <= n; ++i) {
cur += a[i] - val;
minres = min(minres, cur - smax);
maxres = max(maxres, cur - smin);
smin = min(cur, smin);
smax = max(cur, smax);
}
return max(abs(minres), abs(maxres));
}
double ans() {
double l = -20000.0, r = 20000.0;
while (r - l > 1e-11) {
double tl = (2 * l + r) / 3, tr = (2 * r + l) / 3;
double res_tl = calc(tl), res_tr = calc(tr);
if (res_tl - res_tr > 1e-11)
l = tl;
else if (res_tl - res_tr < 1e-11)
r = tr;
else if (res_tl - res_tr <= 1e-11)
return res_tl;
}
return (l + r) / 2;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
printf("%0.6lf", calc(ans()));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[100005][2], b[100005], m;
bool check() {
int i;
for (i = 0; i < m; i++) {
if (a[b[i]][0] == b[i + 1]) return false;
if (a[b[i]][1] == b[i + 1]) return false;
}
return true;
}
int main() {
int n, i, k;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (a[x][0])
a[x][1] = y;
else
a[x][0] = y;
if (a[y][0])
a[y][1] = x;
else
a[y][0] = x;
}
i = n;
b[n] = 1;
while (i--) b[i] = i + 1;
for (k = 1; k <= 1000; k++) {
if (check()) {
while (m--) printf("%d %d\n", b[m], b[m + 1]);
return 0;
}
random_shuffle(b, b + n);
b[n] = b[0];
}
puts("-1");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int factor(int n) {
for (int x = (int)sqrt(n); x >= 1; x--) {
if (n % x == 0) {
return x;
}
}
}
int main() {
int n;
cin >> n;
vector<int> ar(n), ar1(101);
int sum = 0;
for (int x = 0; x < n; x++) {
cin >> ar[x];
ar1[ar[x]]++;
sum += ar[x];
}
int min = sum;
for (int x = 1; x <= 100; x++) {
if (ar1[x] != 0) {
for (int y = 2; y <= x / 2; y++) {
if (x % y == 0) {
for (int z = 1; z <= 100; z++) {
if (ar1[z] != 0) {
int nsum = sum - x + x / y - z + z * y;
if (nsum < min && min > 0) {
min = nsum;
}
}
}
}
}
}
}
cout << min << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000009;
struct MinCostFlow {
MinCostFlow(int _n, int _s, int _t) : n(_n), s(_s), t(_t), fl(0), cost(0) {
first.resize(n, -1);
phi.resize(n, 0);
dist.resize(n);
prev.resize(n);
};
struct Edge {
Edge(int _to, int _cap, int _cost, int _next)
: to(_to), cap(_cap), cost(_cost), next(_next){};
int to, next, cap, cost;
};
void addEdge(int u, int v, int cap, int cost) {
a.push_back(Edge(v, cap, cost, first[u]));
first[u] = a.size() - 1;
a.push_back(Edge(u, 0, -cost, first[v]));
first[v] = a.size() - 1;
}
bool augment() {
dist.assign(n, inf);
dist[s] = 0;
priority_queue<pair<int, int> > q;
q.push(make_pair(0, s));
while (q.size()) {
pair<int, int> top = q.top();
q.pop();
if (dist[top.second] != -top.first) continue;
int u = top.second;
for (int e = first[u]; e != -1; e = a[e].next) {
int v = a[e].to, ndist = -top.first + a[e].cost + phi[u] - phi[v];
if (a[e].cap > 0 && dist[v] > ndist) {
dist[v] = ndist;
q.push(make_pair(-ndist, v));
prev[v] = e;
}
}
}
return dist[t] != inf;
}
pair<int, int> flow() {
while (augment()) {
int cur = t, size = inf;
while (cur != s) {
int e = prev[cur];
size = min(size, a[e].cap);
cur = a[e ^ 1].to;
}
fl += size;
cost += (dist[t] + phi[t] - phi[s]) * size;
cur = t;
while (cur != s) {
int e = prev[cur];
a[e].cap -= size;
a[e ^ 1].cap += size;
cur = a[e ^ 1].to;
}
for (int i = 0; i < n; ++i)
if (phi[i] < inf) phi[i] += dist[i];
}
return make_pair(fl, cost);
}
int n, s, t, fl, cost;
vector<int> first, phi, prev, dist;
vector<Edge> a;
};
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
string ss;
map<string, int> f;
int m;
cin >> ss;
cin >> m;
for (int i = 0; i < m; ++i) {
string w;
int p;
cin >> w >> p;
f[w] = max(f[w], p);
}
int x;
cin >> x;
int s = n + 2, t = s + 1;
MinCostFlow flow(t + 1, s, t);
flow.addEdge(s, 0, x, 0);
flow.addEdge(n, t, x, 0);
for (int i = 0; i < n; ++i) flow.addEdge(i, i + 1, x, 0);
for (int i = 0; i < n; ++i) {
for (auto p : f) {
if (i + p.first.size() <= n && ss.substr(i, p.first.size()) == p.first) {
flow.addEdge(i, i + p.first.size(), 1, -p.second);
}
}
}
cout << -flow.flow().second << endl;
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pi;
typedef vector<ll> vi;
typedef vector<pi> vpi;
typedef long double ld;
const int inf = 1e9 + 7;
#define mod 1000000007
const int maxn = 1e6 + 3;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define rep(i, a, b) for(int i = a; i < b; i++)
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define lb lower_bound
#define ub upper_bound
#define fact(n) rep(i, 1, n+1)ft.pb((ft[i-1]*i)%mod);
#define mod_in(a) exp(a, mod-2)
#define ncr(n, r) ((ft[n]*mod_in((ft[r]*ft[(n)-(r)])%mod))%mod)
#define deb(x) cout << #x << " " << x << endl;
#define flash ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl '\n'
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<typename T>
using ordered_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
template<typename T>
using ordered_multiset = tree<T,null_type,less_equal<T>,rb_tree_tag,tree_order_statistics_node_update>;*/
ll prime[4000005];
ll exp(ll a,ll b);
void sieve(ll n);
ll gcd(ll a ,ll b);
ll countdigit(ll n);
vector<ll>ft;
ll dp[100005];
int main()
{
flash;
ll t=1;
// sieve(4000003);
//ft.pb(1);
//fact(10000001);
cin >> t;
while(t--) {
ll n;
cin >> n;
ll a[n];
rep(i,0,n) cin >> a[i];
unordered_map<ll,ll>seedha;
unordered_map<ll,ll>ulta;
vector<ll>ans1,ans2(n);
set<ll>se;
for(ll i = 0; i < n;i++){
se.insert(i);
ulta[a[i]]++;
}
stack<ll>st;
queue<ll>st2;
for(ll i = n; i >= 1; i--) {
if(ulta.find(i) == ulta.end()){st.push(i);}
}
ll xx = a[n-1];
ll yy = a[0];
ll h = yy-1;
while(h > 0){
if(ulta.find(h) == ulta.end()){st2.push(h);ulta[h]++;}
h--;
}
h = xx-1;
while(h > 0){
if(ulta.find(h) == ulta.end()){st2.push(h);}
h--;
}
ans1.pb(a[0]);
for(ll i = 1; i < n; i++) {
if(a[i] != a[i-1]){
ans1.pb(a[i]);
}
else {
if(st.size() > 0){
ll x = st.top();
ans1.pb(x);
st.pop();
}
}
}
for(ll i=0;i<n;i++)
{
ll j = i+1;
ans2[i] = a[i];
while(j<n && a[j]==a[i])
{
auto it = se.lower_bound(a[i]);
it--;
ll s = *it;
ans2[j] = s;
se.erase(s);
j++;
}
se.erase(a[i]);
i = j-1;
}
for(auto it : ans1){
cout << it << " ";
}
cout << endl;
// reverse(all(ans2));
for(auto it : ans2){
cout << it << " ";
}
cout << endl;
}
}
//
//
//
//
//
// IMPORTANT FUNCTIONS
ll exp(ll a, ll b) {
int res=1;
while(b) {
if(b&1)
res=(res*a)%mod;
a=(a*a)%mod;
b>>=1;
}
return res%mod;
}
ll gcd(ll a,ll b){
if(a==0)return b;
return gcd(b%a,a);
}
void sieve(ll n) {
for(ll i=0;i<=n;i++) {
prime[i]=1;
}
prime[0]=0;prime[1]=0;
for(ll i=2;i<=n;i++) {
if(prime[i]==1) {
for(ll j=2;i*j<=n;j++) {
prime[i*j]=0;
}
}
}
}
ll countdigit(ll n)
{
return floor(log10(n) + 1);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int INF = 1e9 + 7;
const int N = 1010;
const double pi = 3.1415926;
int a[100010];
int main() {
int n, x;
while (~scanf("%d%d", &n, &x)) {
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
if (x - sum == n - 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, outDeg[100000 + 10], ans[100000 + 10];
vector<int> tnod[100000 + 10];
priority_queue<int> pq;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int nod1, nod2;
cin >> nod1 >> nod2;
tnod[nod2].push_back(nod1);
outDeg[nod1]++;
}
for (int i = 1; i <= n; i++)
if (!outDeg[i]) pq.push(i);
int nr = n;
while (!pq.empty()) {
int a = pq.top();
pq.pop();
ans[a] = nr;
nr--;
for (auto u : tnod[a]) {
outDeg[u]--;
if (!outDeg[u]) pq.push(u);
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cout << '\n'; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << "[" << *it << " = " << a << "] ";
err(++it, args...);
}
pair<int, int> dx[] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
const int inf = 2e9 + 7;
const long long INF = 3e18 + 7;
const long double pi = 3.1415926535897932384626433;
const long double eps = 1e-6;
const long double EPS = 1e-9;
const int mod = 1e9 + 7;
long long MOD = 1e15 + 7;
int gcd(int a, int b) {
if (a < b) swap(a, b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
const bool multiple_tests = 0;
const int N = 1e5 + 7;
int n, a[N];
int rec(int l, int r) {
int mn = inf;
for (int i = l; i <= r; i++) {
mn = min(a[i], mn);
}
int prev = 0, sum = 0;
for (int i = l; i <= r; i++) {
a[i] -= mn;
if (!a[i]) {
if (prev) {
sum += rec(prev, i - 1);
prev = 0;
}
} else if (!prev)
prev = i;
}
if (prev) sum += rec(prev, r);
for (int i = l; i <= r; i++) {
a[i] += mn;
}
return min(sum + mn, r - l + 1);
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cout << min(n, rec(1, n));
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TT = 1;
if (multiple_tests) cin >> TT;
for (int T = 1; T <= TT; T++) {
solve();
cout << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int calc(int a, int b, int c) { return abs(a - b) + abs(a - c) + abs(b - c); }
int main() {
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int a, b, c;
cin >> a >> b >> c;
int ans = calc(a, b, c);
for (int da = -1; da <= 1; ++da) {
for (int db = -1; db <= 1; ++db) {
for (int dc = -1; dc <= 1; ++dc) {
int na = a + da;
int nb = b + db;
int nc = c + dc;
ans = min(ans, calc(na, nb, nc));
}
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct cmp {
inline bool operator()(const int& a, const int& b) const { return a > b; }
};
int n, d[500100], inc[500100];
long long pre[500100], suf[500100], low[500100], high[500100];
inline long long calc(int i, int k) {
int x = upper_bound(inc + 1, inc + n + 1, k) - inc;
int p = max(i, n - x + 2);
return 1LL * (p - i) * k + suf[p];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> d[i];
inc[i] = d[i];
}
sort(inc + 1, inc + n + 1);
sort(d + 1, d + n + 1, cmp());
pre[0] = suf[n + 1] = 0;
for (int i = 1; i <= n; ++i) pre[i] = pre[i - 1] + d[i];
for (int i = n; i; --i) suf[i] = suf[i + 1] + d[i];
for (int i = 1; i <= n; ++i) {
low[i] = pre[i] - 1LL * i * (i - 1) - calc(i + 1, i);
high[i] = 1LL * i * (i + 1) + calc(i + 1, i + 1) - pre[i];
}
low[0] = 0, high[n + 1] = n + 1;
for (int i = 1; i <= n; ++i) low[i] = max(low[i], low[i - 1]);
for (int i = n; i; --i) high[i] = min(high[i], high[i + 1]);
vector<int> ret;
int deg;
if (pre[n] & 1)
deg = 1;
else
deg = 0;
for (int candidate = deg; candidate <= n; candidate += 2) {
int x = upper_bound(inc + 1, inc + n + 1, candidate) - inc;
int p = n - x + 2;
if (low[p - 1] > candidate) continue;
if (high[p] < candidate) continue;
if (pre[p - 1] + candidate > 1LL * p * (p - 1) + calc(p, p)) continue;
ret.emplace_back(candidate);
}
if (ret.empty())
cout << -1 << endl;
else {
for (auto x : ret) cout << x << " ";
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define endl "\n"
using namespace std;
int main()
{
fastio;
// code goes here
int tt,n;
cin>>tt;
while(tt--)
{
cin>>n;
int arr[n];
for(int i=0;i<n;i++) cin>>arr[i];
sort(arr,arr+n);
map<int, int> m;
for(int i=0;i<n-1;i+=2)
{
int avg=(arr[i]+arr[i+1])/2;
for(int j=0;j<n;j++)
{
if(arr[j]>avg)
m[arr[j]]++;
}
}
int ans=0;
for(int i=0;i<n;i++)
{
if(m[arr[i]])
ans++;
}
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int MOD = int(1e9) + 7;
inline int add(int a, int b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline void inc(int &a, int b) { a = add(a, b); }
inline int sub(int a, int b) { return (a - b < 0) ? (a - b + MOD) : (a - b); }
inline void dec(int &a, int b) { a = sub(a, b); }
inline int mul(int a, int b) { return (a * 1ll * b) % MOD; }
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
if (a % 2)
y++;
else
x++;
}
int player = 0;
for (; player < n - k - 1; player++) {
if (player % 2 == 0) {
if (x)
x--;
else
y--;
} else if (y)
y--;
else
x--;
}
string A = "Stannis", B = "Daenerys", ans;
if (k == n)
ans = y % 2 ? A : B;
else if (!y)
ans = B;
else if (!x) {
y--;
ans = y % 2 ? A : B;
} else
ans = player % 2 ? B : A;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
mt19937 eng(chrono::steady_clock::now().time_since_epoch().count());
void solve() {
ll x, y, k;
cin >> x >> y >> k;
ll need = (y + 1) * k - 1;
cout << (need + x - 2) / (x - 1) + k << "\n";
}
int main() {
ios::sync_with_stdio(0);
cout.tie(0), cin.tie(0);
int z = 1;
cin >> z;
while (z--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
int mul(int a, int b) { return 1ll * a * b % P; }
int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
int n, r, v, s, f;
double calc(double t) { return v * t + fabs(2 * r * sin(v * t / 2 / r)); }
void solve() {
cin >> s >> f;
int d = f - s;
double l = 0, r = 2e9;
for (int i = (0); i < (100); i++) {
double mid = (l + r) / 2;
if (calc(mid) >= d) {
r = mid;
} else {
l = mid;
}
}
cout << setiosflags(ios::fixed);
cout << setprecision(7);
cout << l << "\n";
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> r >> v;
while (n--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 21;
using namespace std;
bool flag, visit[N][N];
int n, m;
string a, b;
bool valid(int x1, int y1) {
return (x1 >= 0 and x1 < n and y1 >= 0 and y1 < m);
}
void dfs(int x, int y) {
if (!valid(x, y)) return;
if (visit[x][y]) return;
visit[x][y] = true;
if (a[x] == '>') dfs(x, y + 1);
if (a[x] == '<') dfs(x, y - 1);
if (b[y] == '^') dfs(x - 1, y);
if (b[y] == 'v') dfs(x + 1, y);
}
int main() {
cin >> n >> m;
cin >> a >> b;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
memset(visit, false, sizeof visit);
dfs(i, j);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!visit[i][j]) {
cout << "NO" << '\n';
return 0;
}
}
}
}
}
cout << "YES" << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int t = n / 2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (abs(i - t) + abs(j - t) <= t)
cout << 'D';
else
cout << '*';
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int n = 10000000;
bitset<n> b;
vector<int> v;
void sieve() {
b.set();
b[0] = 0;
b[1] = 0;
for (long long i = 2; i <= n; i++) {
if (b[i]) {
v.push_back(i);
for (long long j = i * i; j <= n; j = j + i) {
b[j] = 0;
}
}
}
}
bool large_prime(long long no) {
if (no <= n) {
if (b[no]) {
return true;
} else {
return false;
}
}
for (long long i = 0; v[i] * (long long)v[i] <= no; i++) {
if (no % v[i] == 0) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
sieve();
long long a, b;
while (t--) {
cin >> a >> b;
if (a - b == 1) {
long long ans = (a - b) * (a + b);
if (large_prime(ans)) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
} else {
cout << "NO"
<< "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
inline int read() {
char c = getchar();
int n = 0;
bool f = false;
while (c < '0' || c > '9') {
if (c == '-') {
f = true;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
n = (n << 1) + (n << 3) + (c & 15);
c = getchar();
}
return f ? -n : n;
}
const int maxN = 100005, p = 1e9 + 7;
int n, m;
struct Matrix {
int a[2][2];
} emp, uni, fib, ans;
bool operator!=(const Matrix &x, const Matrix &y) {
return x.a[0][0] != y.a[0][0] || x.a[0][1] != y.a[0][1] ||
x.a[1][0] != y.a[1][0] || x.a[1][1] != y.a[1][1];
}
Matrix operator+(const Matrix &x, const Matrix &y) {
static Matrix res;
res.a[0][0] = x.a[0][0] + y.a[0][0];
if (res.a[0][0] >= p) {
res.a[0][0] -= p;
}
res.a[0][1] = x.a[0][1] + y.a[0][1];
if (res.a[0][1] >= p) {
res.a[0][1] -= p;
}
res.a[1][0] = x.a[1][0] + y.a[1][0];
if (res.a[1][0] >= p) {
res.a[1][0] -= p;
}
res.a[1][1] = x.a[1][1] + y.a[1][1];
if (res.a[1][1] >= p) {
res.a[1][1] -= p;
}
return res;
}
Matrix operator*(const Matrix &x, const Matrix &y) {
static Matrix res;
res.a[0][0] = (1ll * x.a[0][0] * y.a[0][0] + 1ll * x.a[0][1] * y.a[1][0]) % p;
res.a[0][1] = (1ll * x.a[0][0] * y.a[0][1] + 1ll * x.a[0][1] * y.a[1][1]) % p;
res.a[1][0] = (1ll * x.a[1][0] * y.a[0][0] + 1ll * x.a[1][1] * y.a[1][0]) % p;
res.a[1][1] = (1ll * x.a[1][0] * y.a[0][1] + 1ll * x.a[1][1] * y.a[1][1]) % p;
return res;
}
Matrix operator^(Matrix x, int y) {
static Matrix res;
res = uni;
for (; y; y >>= 1, x = x * x) {
if (y & 1) {
res = res * x;
}
}
return res;
}
struct SegmentTree {
Matrix f[maxN << 2], tag[maxN << 2];
inline void pushUp(int u) { f[u] = f[u << 1] + f[u << 1 | 1]; }
inline void pushTag(int u, const Matrix &x) {
tag[u] = tag[u] * x;
f[u] = f[u] * x;
}
inline void pushDown(int u) {
if (tag[u] != uni) {
pushTag(u << 1, tag[u]);
pushTag(u << 1 | 1, tag[u]);
tag[u] = uni;
}
}
void build(int u, int l, int r) {
if (l == r) {
f[u] = fib ^ (read() - 1);
return;
}
int mid = l + r >> 1;
tag[u] = uni;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushUp(u);
}
void modify(int u, int l, int r, int pl, int pr, const Matrix &x) {
if (l == pl && r == pr) {
pushTag(u, x);
return;
}
int mid = l + r >> 1;
pushDown(u);
if (pr <= mid) {
modify(u << 1, l, mid, pl, pr, x);
} else if (pl > mid) {
modify(u << 1 | 1, mid + 1, r, pl, pr, x);
} else {
modify(u << 1, l, mid, pl, mid, x);
modify(u << 1 | 1, mid + 1, r, mid + 1, pr, x);
}
pushUp(u);
}
void query(int u, int l, int r, int pl, int pr, Matrix &res) {
if (l == pl && r == pr) {
res = res + f[u];
return;
}
int mid = l + r >> 1;
pushDown(u);
if (pr <= mid) {
query(u << 1, l, mid, pl, pr, res);
} else if (pl > mid) {
query(u << 1 | 1, mid + 1, r, pl, pr, res);
} else {
query(u << 1, l, mid, pl, mid, res);
query(u << 1 | 1, mid + 1, r, mid + 1, pr, res);
}
pushUp(u);
}
} tr;
int main() {
n = read();
m = read();
uni.a[0][0] = uni.a[1][1] = 1;
fib.a[0][0] = fib.a[0][1] = fib.a[1][0] = 1;
tr.build(1, 1, n);
for (; m; m--) {
int opt = read(), l = read(), r = read();
if (opt == 1) {
tr.modify(1, 1, n, l, r, fib ^ read());
} else {
ans = emp;
tr.query(1, 1, n, l, r, ans);
printf("%d\n", ans.a[0][0]);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:20000000")
using namespace std;
using namespace std;
int main() {
int n, k;
cin >> n >> k;
multiset<long long> tmp;
for (int i = 0; i < k; i++) tmp.insert(0);
for (int i = 0; i < n; i++) {
long long s, m;
scanf("%I64d%I64d", &s, &m);
multiset<long long>::iterator it;
it = tmp.begin();
if (*it <= s) {
printf("%I64d\n", s + m);
tmp.erase(it);
tmp.insert(s + m);
} else {
long long x = *it;
printf("%I64d\n", x + m);
tmp.erase(it);
tmp.insert(x + m);
}
}
return 0;
}
| 4 |
#include <iostream>
#include <vector>
#include <bits/stdc++.h>
#include <string.h>
#include <algorithm>
#include <math.h>
using namespace std;
#define ll long long int
#define lll unsigned long long
#define ssl signed long long
#define pb push_back
bool sortcol( const vector<int>& v1, const vector<int>& v2 ) {
return v1[1] < v2[1];
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--){
string s;
cin>>s;
int n=s.length();
int i=1,j=n-2;
while(i<n){
if(s[i]=='1' && s[i]==s[i-1])
break;
i++;
}
while(j>=0){
if(s[j]=='0' && s[j]==s[j+1])
break;
j--;
}
if(i>j){
cout<<"YES"<<endl;
}
else{
cout<<"NO"<<endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using D = double;
using uint = unsigned int;
template <typename T>
using pair2 = pair<T, T>;
const long double pi = acos((ld)-1.0);
const int maxn = 1 << 16;
complex<double> oddc[maxn], evenc[maxn], tmp[maxn];
complex<double> w[maxn], invw[maxn];
ll odd[maxn], even[maxn];
int oldodd[maxn], oldeven[maxn];
int btr[maxn];
int n, A, mod;
int st2;
int answer;
inline int bitrev(int x) { return btr[x]; }
void fft(complex<double> *a, int n, complex<double> *w, complex<double> *res) {
for (int i = 0; i < n; i++) res[bitrev(i)] = a[i];
for (int len = 2; len <= n; len *= 2) {
int step = n / len;
for (int i = 0; i < n; i += len) {
int curw = 0;
for (int j = 0; j < len / 2; j++) {
complex<double> x = res[i + j];
complex<double> y = res[i + len / 2 + j] * w[curw];
res[i + j] = x + y;
res[i + len / 2 + j] = x - y;
curw += step;
}
}
}
}
void preparefft(int n) {
for (int i = 0; i < n; i++) {
int cur = i;
for (int j = 0; (1 << j) < n; j++) {
btr[i] = (btr[i] << 1) | (cur & 1);
cur >>= 1;
}
}
for (int i = 0; i < n; i++) {
w[i] = complex<double>(cos(2 * pi / n * i), sin(2 * pi / n * i));
invw[i] = w[i];
}
reverse(invw + 1, invw + n);
}
void conv(ll *from, complex<double> *to) {
for (int i = n + 1; i < st2; i++) tmp[i] = 0;
for (int i = 0; i <= n; i++) tmp[i] = from[i];
fft(tmp, st2, w, to);
}
void convback(complex<double> *from, ll *to) {
fft(from, st2, invw, tmp);
for (int i = 0; i < st2; i++) tmp[i] /= st2;
for (int i = 0; i <= n; i++) {
to[i] = (ll)(tmp[i].real() + 0.5);
assert(abs(tmp[i].imag()) < 0.1);
}
}
void addans() {
for (int i = 1; i <= n; i += 2) answer = (answer + odd[i]) % mod;
}
void go(int A) {
if (A == 1) {
even[0] = 1;
odd[0] = 0;
odd[1] = 1;
addans();
return;
}
go(A / 2);
for (int i = 0; i <= n; i++) oldodd[i] = odd[i];
for (int i = 0; i <= n; i++) oldeven[i] = even[i];
conv(even, evenc);
conv(odd, oddc);
for (int i = 0; i < st2; i++) {
if ((A / 2) % 2 == 0) {
tie(oddc[i], evenc[i]) =
make_pair((oddc[i] + evenc[i]) * oddc[i],
(oddc[i] + evenc[i]) * (evenc[i] - (complex<double>)1));
} else {
tie(evenc[i], oddc[i]) =
make_pair((oddc[i] + evenc[i]) * oddc[i],
(oddc[i] + evenc[i]) * (evenc[i] - (complex<double>)1));
}
}
convback(oddc, odd);
convback(evenc, even);
for (int i = n + 1; i <= 2 * n; i++) {
odd[i] = 0;
even[i] = 0;
}
for (int i = 0; i <= n; i++) {
odd[i] = (odd[i] + oldodd[i]) % mod;
even[i] = (even[i] + oldeven[i]) % mod;
}
if (A % 2 == 1) {
for (int i = n; i >= 1; i--) {
odd[i] = (odd[i] + odd[i - 1] + even[i - 1]) % mod;
}
}
addans();
}
int main() {
cin >> n >> A >> mod;
if (A == 1) {
cout << 0 << endl;
return 0;
}
st2 = 0;
while ((1 << st2) <= n) st2++;
st2++;
st2 = 1 << st2;
preparefft(st2);
go(A / 2);
cout << answer << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
inline long long pow(long long x, long long y, long long mod) {
long long ans = 1;
for (; y; y >>= 1, x = (x * x) % mod)
if (y & 1) ans = (ans * x) % mod;
return ans % mod;
}
const long long mod = 1000000007;
const int maxn = 100005;
long long fac[maxn << 1];
int main() {
long long n;
cin >> n;
fac[0] = 1;
for (int i = 1; i <= (n << 1); ++i) fac[i] = fac[i - 1] * i % mod;
cout << (fac[n << 1] * pow(fac[n] * fac[n] % mod, mod - 2, mod)) % mod - n
<< endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, R;
cin >> N >> R;
int bestx;
int bestval = 1000000;
for (int x = 1; x <= R; x++) {
int t = x;
int b = R;
char last = 0;
int len = 0;
int bad = 0;
while (t > 1 && b > 1) {
if (t > b) {
int cnt = t / b;
t -= cnt * b;
if (last == 'T') bad++;
bad += cnt - 1;
last = 'T';
len += cnt;
} else {
int cnt = b / t;
b -= cnt * t;
if (last == 'B') bad++;
bad += cnt - 1;
last = 'B';
len += cnt;
}
}
if (t == 0 || b == 0) continue;
if (t > 1) {
int cnt = t - 1;
t = 1;
if (last == 'T') bad++;
bad += cnt - 1;
len += cnt;
} else if (b > 1) {
int cnt = b - 1;
b = 1;
if (last == 'B') bad++;
bad += cnt - 1;
len += cnt;
}
len++;
if (len == N) {
if (bad < bestval) {
bestval = bad;
bestx = x;
}
}
}
if (bestval == 1000000)
cout << "IMPOSSIBLE" << endl;
else {
cout << bestval << endl;
string seq;
int t = bestx;
int b = R;
while (t != 0 && b != 0) {
if (t == 1 && b == 1) {
if (seq.length() == 0) {
seq.append(1, 'T');
} else {
seq.append(1, 'T' + 'B' - seq[seq.size() - 1]);
}
t = 0;
break;
}
if (t > b) {
t -= b;
seq.append(1, 'T');
} else {
b -= t;
seq.append(1, 'B');
}
}
reverse(seq.begin(), seq.end());
if (seq[0] == 'B') {
for (int i = 0; i < N; i++) seq[i] ^= 'T' ^ 'B';
}
cout << seq << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long x[100001], y[100001];
int main() {
ios::sync_with_stdio(false);
long long i, j, k, n, d, dis, ind1, ind2, sx, sy;
long double m, m1;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
dis = LLONG_MAX;
for (i = 1; i < n; i++) {
d = (x[i] - x[0]) * (x[i] - x[0]) + (y[i] - y[0]) * (y[i] - y[0]);
if (d < dis) {
dis = d;
ind1 = i + 1;
sx = (x[i] - x[0]);
sy = (y[i] - y[0]);
if (sy == 0)
m = 1000000000000.00;
else
m = (sy * 1.0) / sx;
}
}
dis = LLONG_MAX;
for (i = 1; i < n; i++) {
if (i == ind1 - 1) continue;
d = (x[i] - x[0]) * (x[i] - x[0]) + (y[i] - y[0]) * (y[i] - y[0]);
sx = (x[i] - x[0]);
sy = (y[i] - y[0]);
if (sy == 0)
m1 = 1000000000000.00;
else
m1 = (sy * 1.0) / sx;
if (d < dis && m != m1) {
dis = d;
ind2 = i + 1;
}
}
cout << 1 << " " << ind1 << " " << ind2;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
template <class T, class... U>
void DEBUG(const T &head, const U &...tail) {}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e5 + 10;
int d[20][SIZE], a[SIZE], mi = 18;
int ans[20];
int tmp[20];
void dfs(int lv, int dn, int num) {
if (num >= mi) return;
if (!dn) {
for (int i = 0; i < (num); ++i) ans[i] = tmp[i];
mi = num;
return;
}
if (lv > 18) return;
int odd = 0;
for (int i = 0; i < (dn); ++i) {
if (d[lv][i] % 2) {
odd = 1;
break;
}
}
if (!odd) {
for (int i = 0; i < (dn); ++i) d[lv + 1][i] = d[lv][i] / 2;
dfs(lv + 1, dn, num);
} else {
vector<int> dif{-1, 1};
if (rand() & 1) swap(dif[0], dif[1]);
for (int dd : dif) {
int it = 0;
for (int i = 0; i < (dn); ++i) {
int nxt_v = 0;
if (d[lv][i] % 2) {
nxt_v = (d[lv][i] - dd) / 2;
} else
nxt_v = d[lv][i] / 2;
if (!nxt_v) continue;
if (it == 0 || d[lv + 1][it - 1] != nxt_v) {
d[lv + 1][it++] = nxt_v;
}
}
tmp[num] = dd * (1 << lv);
dfs(lv + 1, it, num + 1);
}
}
}
int main() {
int n;
R(n);
for (int i = 0; i < (n); ++i) {
R(a[i]);
}
sort(a, a + n);
n = unique(a, a + n) - a;
int dn = 0;
for (int i = 0; i < (n); ++i) {
if (a[i]) d[0][dn++] = a[i];
}
dfs(0, dn, 0);
W(mi);
vector<int> res;
if (mi == 18) {
for (int i = 0; i < (mi - 1); ++i) res.push_back(1 << i);
res.push_back(-(1 << 17));
} else
res = vector<int>(ans, ans + mi);
W(res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
signed main() {
fast();
long long t;
cin >> t;
while (t--) {
long long n, a, b, ans2, ans1, cntob;
cin >> n >> a >> b;
ans2 = min(n, a - 1 + b);
ans1 = n - min(n - 1, n - a + n - b);
if (a + b > n) ans1++;
ans1 = min(ans1, n);
cout << ans1 << " " << ans2 << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
cin >> n;
long long ans = 0;
n--;
while (n) {
long long sum = 1, cnt = 1, now = 1, last = 1;
while (cnt <= n) {
last = now;
now = sum + cnt * 2;
sum = now + sum;
cnt <<= 1;
}
cnt >>= 1;
ans += last;
n -= cnt;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct N {
int x, y;
} p[100100];
int xx[100010], yy[100010];
int sumx = 0, sumy = 0;
bool cmp(N a, N b) {
if (a.x == b.x) {
if (a.y > 0 && b.y > 0) return a.y < b.y;
return a.y > b.y;
}
if (a.x > 0 && b.x > 0) return a.x < b.x;
return a.x > b.x;
}
bool cmp2(int a, int b) {
if (a > 0 && b > 0)
return a < b;
else
return a > b;
}
void solve(int t) {
if (p[t].x > 0) {
if (p[t].y > 0)
printf("1 %d %c\n1 %d %c\n2\n1 %d %c\n1 %d %c\n3\n", p[t].x, 'R', p[t].y,
'U', p[t].x, 'L', p[t].y, 'D');
else
printf("1 %d %c\n1 %d %c\n2\n1 %d %c\n1 %d %c\n3\n", p[t].x, 'R', -p[t].y,
'D', p[t].x, 'L', -p[t].y, 'U');
} else {
if (p[t].y > 0)
printf("1 %d %c\n1 %d %c\n2\n1 %d %c\n1 %d %c\n3\n", -p[t].x, 'L', p[t].y,
'U', -p[t].x, 'R', p[t].y, 'D');
else
printf("1 %d %c\n1 %d %c\n2\n1 %d %c\n1 %d %c\n3\n", -p[t].x, 'L',
-p[t].y, 'D', -p[t].x, 'R', -p[t].y, 'U');
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].x >> p[i].y;
if (i >= 0 && p[i].x == 0) {
xx[sumx++] = p[i].y;
i--;
n--;
}
if (i >= 0 && p[i].y == 0) {
yy[sumy++] = p[i].x;
i--;
n--;
}
}
sort(xx, xx + sumx, cmp2);
sort(yy, yy + sumy, cmp2);
if (n) sort(p, p + n, cmp);
cout << 4 * (sumx + sumy) + 6 * n << endl;
for (int i = 0; i < sumx; i++) {
if (xx[i] > 0)
printf("1 %d %c\n2\n1 %d %c\n3\n", xx[i], 'U', xx[i], 'D');
else
printf("1 %d %c\n2\n1 %d %c\n3\n", -xx[i], 'D', -xx[i], 'U');
}
for (int i = 0; i < sumy; i++) {
if (yy[i] > 0)
printf("1 %d %c\n2\n1 %d %c\n3\n", yy[i], 'R', yy[i], 'L');
else
printf("1 %d %c\n2\n1 %d %c\n3\n", -yy[i], 'L', -yy[i], 'R');
}
for (int i = 0; i < n; i++) solve(i);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
vector<long long int> a(n + 1);
a[0] = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) a[i] += a[i - 1];
int mx = -1;
for (int i = 0; i <= n; i++) {
auto it = upper_bound(a.begin(), a.end(), a[i] + t);
it--;
int index = it - a.begin();
mx = max(mx, (index - i));
}
cout << mx << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const M = 5e5 + 10, M2 = 1e7 + 10, mod = 1e9 + 7, mod2 = 1e9 + 9,
inf = 1e9 + 30;
int fen[1000 + 10][1000 + 10], mn[1000 + 10], k, p, a[M], ps[M],
dp[M][100 + 10];
void add(int id, int ind, int now) {
int tmp = ind;
mn[id] = min(mn[id], now - tmp);
for (; ind <= p; ind += ind & -ind)
fen[id][ind] = min(fen[id][ind], now - tmp);
}
int get(int id, int ind) {
int ans = inf;
for (; ind; ind -= ind & -ind) ans = min(fen[id][ind], ans);
return ans;
}
int32_t main() {
int n;
cin >> n >> k >> p;
for (int i = 1; i <= n; i++)
cin >> a[i], ps[i] = ps[i - 1] + a[i], ps[i] %= p;
for (int i = 1; i <= n; i++) ps[i]++;
for (int i = 0; i <= k; i++) {
mn[i] = inf;
for (int j = 0; j <= p; j++) fen[i][j] = inf;
}
add(k, 1, 0);
ps[n + 1] = ps[n];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; j++) {
int hlp = get(j + 1, ps[i]);
hlp = min(hlp, mn[j + 1] + p);
hlp += ps[i];
dp[i][j] = hlp;
add(j, ps[i], dp[i][j]);
}
}
cout << dp[n][0];
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
int main() {
int n;
long long a[110], Max = 0, GCD, ps;
scanf("%d", &n);
scanf("%I64d", &a[0]);
GCD = a[0];
Max = a[0];
for (long long i = 1; i <= n - 1; i++) {
scanf("%I64d", &a[i]);
GCD = gcd(a[i], GCD);
Max = max(Max, a[i]);
}
ps = Max / GCD - n;
if (ps % 2 == 0)
printf("Bob\n");
else
printf("Alice\n");
return (0);
}
| 4 |
#include <bits/stdc++.h>
const int kMaxn = 5e5 + 10;
long long ans;
int n, m, k, cnt, col[kMaxn];
bool no[kMaxn];
int top, fa[kMaxn << 1], size[kMaxn << 1];
struct Stack {
int u, v, fa, size;
} st[kMaxn << 1];
int e_num;
struct Edge {
int u, v, colu, colv;
} e[kMaxn];
inline int read() {
int f = 1, w = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
return f * w;
}
void Chkmax(int &fir_, int sec_) {
if (sec_ > fir_) fir_ = sec_;
}
void Chkmin(int &fir_, int sec_) {
if (sec_ < fir_) fir_ = sec_;
}
bool CompareEdge(Edge f_, Edge s_) {
if (f_.colu != s_.colu) return f_.colu < s_.colu;
return f_.colv < s_.colv;
}
int Find(int x_) {
while (x_ != fa[x_]) x_ = fa[x_];
return x_;
}
void Union(int u_, int v_) {
int fu = Find(u_), fv = Find(v_);
if (size[fu] > size[fv]) std::swap(fu, fv);
st[++top] = (Stack){fu, fv, fa[fu], size[fu]};
if (fu != fv) {
fa[fu] = fv;
size[fv] += size[fu];
size[fu] = 0;
}
}
void Restore() {
Stack now = st[top];
if (now.u != now.v) {
fa[now.u] = now.fa;
size[now.u] = now.size;
size[now.v] -= now.size;
}
top--;
}
int main() {
n = read(), m = read(), cnt = k = read();
for (int i = 1; i <= n; ++i) col[i] = read();
for (int i = 1; i <= 2 * n; ++i) {
fa[i] = i;
size[i] = 1;
}
for (int i = 1; i <= m; ++i) {
int u_ = read(), v_ = read();
if (col[u_] != col[v_]) {
e[++e_num] = (Edge){u_, v_, col[u_], col[v_]};
if (e[e_num].colu > e[e_num].colv) {
std::swap(e[e_num].colu, e[e_num].colv);
}
continue;
}
if (no[col[u_]]) continue;
if (Find(u_) == Find(v_)) {
cnt--;
no[col[u_]] = true;
continue;
}
Union(u_, v_ + n);
Union(v_, u_ + n);
}
ans = 1ll * (cnt - 1ll) * cnt / 2ll;
int last_top = top, flag = false;
std::sort(e + 1, e + e_num + 1, CompareEdge);
for (int i = 1; i <= e_num; ++i) {
Edge now = e[i];
if (no[now.colu] || no[now.colv]) continue;
if (now.colu != e[i - 1].colu || now.colv != e[i - 1].colv) {
while (top != last_top) Restore();
flag = false;
}
if (flag) continue;
if (Find(now.u) == Find(now.v)) {
ans--;
flag = true;
continue;
}
Union(now.u, now.v + n);
Union(now.v, now.u + n);
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2 * 1e5 + 10;
const double PI = acos(-1.0), EPS = 1e-9;
int N;
int arr[2000];
map<int, int> mpp;
vector<pair<int, int> > best;
int p[2000000 + 2];
bool prime(int n) {
if (n == 2) return 1;
if (n % 2 == 0 || n < 2) return 0;
for (int i = 3; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
int calc() {
int ret = 0;
for (int i = 0; i < best.size(); i++) ret += best[i].second;
return ret;
}
void print() {
int mx = calc();
cout << mx << "\n";
for (int i = 0; i < best.size(); i++)
for (int j = 0; j < best[i].second; j++) cout << best[i].first << " ";
}
int main() {
mpp.clear();
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &arr[i]), mpp[arr[i]]++;
if (mpp.find(1) != mpp.end()) {
best.push_back(make_pair(1, mpp[1]));
for (int i = 0; i < N; i++) {
if (arr[i] == 1) continue;
if (prime(1 + arr[i])) {
best.push_back(make_pair(arr[i], 1));
break;
}
}
}
int maxbest = calc();
if (maxbest > 2) {
print();
return 0;
}
best.clear();
bool ok = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if (i == j) continue;
if (prime(arr[i] + arr[j])) {
best.push_back(make_pair(arr[i], 1));
best.push_back(make_pair(arr[j], 1));
ok = 1;
break;
}
}
if (ok) break;
}
if (best.size() == 0) best.push_back(make_pair(arr[0], 1));
print();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, d, k;
void output(int v, int depth, int limit, int& cnt) {
if (depth == limit || cnt >= n) return;
for (int i = 0; i < k - 1 - (v <= d) && cnt < n; i++) {
printf("%d %d\n", v, ++cnt);
output(cnt, depth + 1, limit, cnt);
}
}
void solve() {
int sum = d + 1;
for (int i = d - 1, coff = 1; i > 0; i -= 2, coff *= (k - 1)) {
sum += i * (k - 2) * coff;
if (sum >= n) break;
}
if (sum < n || n < d + 1) {
puts("NO");
return;
}
puts("YES");
for (int i = 0; i < d; i++) printf("%d %d\n", i + 1, i + 2);
int cnt = d + 1;
for (int i = 2; i <= d && cnt < n; i++) {
output(i, 0, min(i - 1, d + 1 - i), cnt);
}
}
int main() {
cin >> n >> d >> k;
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T qmin(const T a, const T b) {
return a < b ? a : b;
}
template <typename T>
inline T qmax(const T a, const T b) {
return a > b ? a : b;
}
template <typename T>
inline void getmin(T &a, const T b) {
if (a > b) a = b;
}
template <typename T>
inline void getmax(T &a, const T b) {
if (a < b) a = b;
}
inline void fileio(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const int inf = 1e9 + 7;
const long long linf = 1e17 + 7;
const int N = 4e5 + 7;
unsigned int last = 183209, r1 = 37917283, r2 = 591748;
inline unsigned int rnd() { return last = last * r1 + r2; }
unsigned int fix[N];
int val[N], ans[N], dt[N], times[N];
int lch[N], rch[N], node, root;
int n, m;
int c[N], q[N], a[N], p[N];
inline int newnode(int v) {
++node;
val[node] = v;
fix[node] = rnd();
return node;
}
inline void settag(int x, int u, int v) {
if (!x) return;
dt[x] += u, val[x] += u;
times[x] += v, ans[x] += v;
}
inline void psd(int x) {
if (!x || !dt[x] || !times[x]) return;
settag(lch[x], dt[x], times[x]);
settag(rch[x], dt[x], times[x]);
dt[x] = times[x] = 0;
}
inline void debug(int x) {
if (!x) return;
fprintf(stderr, "[%d->%d,%u]", x, val[x], fix[x]);
psd(x);
if (lch[x] + rch[x]) {
fprintf(stderr, "(");
debug(lch[x]);
if (rch[x]) fprintf(stderr, ",");
debug(rch[x]);
fprintf(stderr, ")");
}
}
inline bool cmp2(const int &x, const int &y) { return a[x] < a[y]; }
inline int build(int n) {
static int stk[N], top = 0;
static int p[N];
for (int i = 1; i <= n; ++i) newnode(a[i]), p[i] = i;
sort(p + 1, p + n + 1, cmp2);
for (int k = 1; k <= n; ++k) {
int i = p[k], last = 0;
while (top && fix[stk[top]] > fix[i]) last = stk[top--];
lch[i] = last;
if (top) rch[stk[top]] = i;
stk[++top] = i;
}
return stk[1];
}
inline int merge(int x, int y) {
if (!x || !y) return x + y;
if (fix[x] < fix[y]) {
psd(x);
rch[x] = merge(rch[x], y);
return x;
} else {
psd(y);
lch[y] = merge(x, lch[y]);
return y;
}
}
inline pair<int, int> split(int x, int v) {
if (!x) return make_pair(0, 0);
psd(x);
if (val[x] < v) {
pair<int, int> tmp = split(rch[x], v);
rch[x] = tmp.first;
return make_pair(x, tmp.second);
} else {
pair<int, int> tmp = split(lch[x], v);
lch[x] = tmp.second;
return make_pair(tmp.first, x);
}
}
inline void ins(int &x, int y) {
pair<int, int> p = split(x, val[y]);
x = merge(merge(p.first, y), p.second);
}
inline void insall(int &r, int u) {
if (!u) return;
psd(u), insall(r, lch[u]), insall(r, rch[u]);
lch[u] = rch[u] = 0;
ins(r, u);
}
inline void psdall(int x) {
if (!x) return;
psd(x), psdall(lch[x]), psdall(rch[x]);
}
inline bool cmp(const int &x, const int &y) {
if (q[x] != q[y]) return q[x] > q[y];
return c[x] < c[y];
}
int main() {
scanf("%d", &m);
for (int i = 1; i <= m; ++i) scanf("%d%d", c + i, q + i), p[i] = i;
sort(p + 1, p + m + 1, cmp);
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
root = build(n);
for (int k = 1; k <= m; ++k) {
int i = p[k];
pair<int, int> r = split(root, c[i]);
settag(r.second, -c[i], 1);
pair<int, int> r2 = split(r.second, c[i]);
insall(r.first, r2.first);
root = merge(r.first, r2.second);
}
psdall(root);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
int dx[] = {0, 0, +1, -1, +1, +1, -1, -1};
int dy[] = {+1, -1, 0, 0, +1, -1, +1, -1};
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << endl; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << endl;
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
double b = 0, e = 1000, r;
cin >> n >> r;
while (abs(e - b) > 1e-9) {
double mid = (e + b) / 2.0;
double x = (180.0 / (double)n) * PI / 180;
double R = (mid / (2 * sin(x)));
double Ra = R - (mid / 2.0);
if (Ra < r) {
b = mid;
} else
e = mid;
}
cout.unsetf(ios::floatfield);
cout.precision(10);
cout.setf(ios::fixed, ios::floatfield);
;
cout << (b / 2.0);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
long int ans = n * m;
if (ans % 2 == 0)
cout << ans / 2;
else
cout << (ans / 2) + 1;
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = (long long int)1e18 + 19;
const long long int mod = (long long int)1e9 + 7;
void cazz() {
long long int t = 1, i, j, n;
cin >> t;
while (t--) {
cin >> n;
long long int ans, rem;
ans = n / 4;
rem = n % 4;
if (rem == 0)
cout << ans << "\n";
else if (rem == 1) {
if (ans < 2)
cout << -1 << "\n";
else
cout << ans - 1 << "\n";
} else if (rem == 2) {
if (ans >= 1)
cout << ans << "\n";
else
cout << -1 << "\n";
} else {
if (ans < 3)
cout << -1 << "\n";
else
cout << ans - 1 << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cazz();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
int g, t, i, j, n;
int p, e;
cin >> t;
while (t--) {
v.clear();
cin >> n >> p;
e = 2 * n + p;
g = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j < i; j++) {
if (e == 0) {
for (int k = 0; k < v.size(); k++) {
cout << v[k].first << " " << v[k].second << endl;
}
g = 1;
break;
}
if (v.size() >= (2 * i + p)) {
break;
}
v.push_back(make_pair(i, j));
e--;
}
if (g == 1) {
break;
}
}
if (g == 1) continue;
for (i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, l, s, n, m, x, y, ans, gt;
struct Node {
int x, y, a, b;
} T[55 * 55], da[1000005];
struct node {
int x, y, a, b, v;
} a[55], q[55 * 55], last[55][55];
int v[55][55], b[55][55], bb[55];
inline bool cmp(node x, node y) {
if (x.b != y.b) return abs(x.b - gt) > abs(y.b - gt);
return x.a > y.a;
}
inline void go(int x, int y, int a, int b) { da[++ans] = Node{x, y, a, b}; }
inline void work(int gt, int x, int y) {
while (a[gt].x != x) {
if (a[gt].x > x)
go(a[gt].x, a[gt].y, a[gt].x - 1, a[gt].y), a[gt].x--;
else
go(a[gt].x, a[gt].y, a[gt].x + 1, a[gt].y), a[gt].x++;
}
while (a[gt].y != y) {
if (a[gt].y > y)
go(a[gt].x, a[gt].y, a[gt].x, a[gt].y - 1), a[gt].y--;
else
go(a[gt].x, a[gt].y, a[gt].x, a[gt].y + 1), a[gt].y++;
}
}
inline void bfs(int x, int y) {
int gt = n * 2 + 1, gtw = 0;
for (int i = 1; i <= m; i++) {
if (a[i].v) continue;
if (abs(a[i].x - x) + abs(a[i].y - y) < gt) {
gt = abs(a[i].x - x) + abs(a[i].y - y);
gtw = i;
}
}
a[gtw].v = 1;
work(gtw, x, y);
}
inline void bfs(int x) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) v[i][j] = -1, b[i][j] = 0;
for (int i = 1; i <= m; i++) b[a[i].x][a[i].y] = 1;
v[a[x].x][a[x].y] = 0;
int l = 0, r = 1;
q[1].x = a[x].x, q[1].y = a[x].y;
while (l < r) {
++l;
int X = q[l].x - 1, Y = q[l].y;
if (X && Y && X <= n && Y <= n && !b[X][Y] && v[X][Y] == -1) {
v[X][Y] = 1;
last[X][Y].x = q[l].x;
last[X][Y].y = q[l].y;
q[++r].x = X;
q[r].y = Y;
}
X = q[l].x + 1, Y = q[l].y;
if (X && Y && X <= n && Y <= n && !b[X][Y] && v[X][Y] == -1) {
v[X][Y] = 1;
last[X][Y].x = q[l].x;
last[X][Y].y = q[l].y;
q[++r].x = X;
q[r].y = Y;
}
X = q[l].x, Y = q[l].y - 1;
if (X && Y && X <= n && Y <= n && !b[X][Y] && v[X][Y] == -1) {
v[X][Y] = 1;
last[X][Y].x = q[l].x;
last[X][Y].y = q[l].y;
q[++r].x = X;
q[r].y = Y;
}
X = q[l].x, Y = q[l].y + 1;
if (X && Y && X <= n && Y <= n && !b[X][Y] && v[X][Y] == -1) {
v[X][Y] = 1;
last[X][Y].x = q[l].x;
last[X][Y].y = q[l].y;
q[++r].x = X;
q[r].y = Y;
}
}
int s, X, Y;
for (s = 0, X = a[x].a, Y = a[x].b; X != a[x].x || Y != a[x].y;) {
T[++s] = Node{last[X][Y].x, last[X][Y].y, X, Y};
int xx = X, yy = Y;
X = last[xx][yy].x, Y = last[xx][yy].y;
}
for (; s; s--) da[++ans] = T[s];
a[x].x = a[x].a, a[x].y = a[x].b;
}
inline void work(int x) { bfs(x); }
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) scanf("%d%d", &a[i].x, &a[i].y);
for (i = 1; i <= m; i++) scanf("%d%d", &a[i].a, &a[i].b);
for (i = 1; i <= m; i++) bb[a[i].b] = 1;
gt = 1;
for (i = 1; i <= n; i++)
if (!bb[i]) gt = i;
for (i = 1; i <= m; i++) bfs(i, gt);
sort(a + 1, a + 1 + m, cmp);
for (i = 1; i <= m; i++) work(i);
printf("%d\n", ans);
for (i = 1; i <= ans; i++)
printf("%d %d %d %d\n", da[i].x, da[i].y, da[i].a, da[i].b);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
if (n % 2 == 0) {
cout << -1 << endl;
return 0;
}
for (int _n(n), i(0); i < _n; i++) cout << i << " ";
cout << endl;
for (int _n(n), i(0); i < _n; i++) cout << (i + 1) % n << " ";
cout << endl;
for (int _n(n), i(0); i < _n; i++) cout << (2 * i + 1) % n << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int c[1000];
int main() {
int n, m, i, j, x, maxx = 0, ans = 0;
scanf("%d%d", &n, &m);
int a[m][n], b[100], y;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
}
}
for (i = 0; i < m; i++) {
maxx = a[i][0];
b[i] = 1;
for (j = 0; j < n; j++) {
if (a[i][j] > maxx) {
maxx = a[i][j];
b[i] = j + 1;
}
}
x = b[i];
c[x]++;
}
y = 0;
ans = 1;
for (i = 1; i <= 100; i++) {
if (c[i] > y) {
y = c[i];
ans = i;
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
point() {}
point(int xx, int yy) { x = xx, y = yy; }
bool operator<(const point &other) const {
if (x == other.x) return y < other.y;
return x < other.x;
}
} temp, Q[400011 * 4];
struct Point {
int x, y, z;
Point() {}
Point(int xx, int yy, int zz) { x = xx, y = yy, z = zz; }
};
struct node {
int l, r;
} tree[400011 * 4];
point Stack1[400011];
int top1;
int Stack2[400011];
int top2;
map<point, point> Map;
map<point, point>::iterator it;
vector<Point> V[400011 * 4];
int father[400011], pre[400011], h[400011], n, m, f[31 + 1], q;
int find(int u) {
if (u == father[u]) return u;
return find(father[u]);
}
int ask(int u) {
if (u == father[u]) return 0;
return ask(father[u]) ^ pre[u];
}
void build(int l, int r, int now) {
tree[now].l = l;
tree[now].r = r;
if (l == r) return;
int mid = (l + r) / 2;
build(l, mid, now * 2);
build(mid + 1, r, now * 2 + 1);
}
void Insert(int l, int r, Point x, int now) {
if (l <= tree[now].l && tree[now].r <= r) {
V[now].push_back(x);
return;
}
int mid = (tree[now].l + tree[now].r) / 2;
if (l <= mid) Insert(l, r, x, now * 2);
if (r > mid) Insert(l, r, x, now * 2 + 1);
}
void Add(int p, point x, int now) {
if (tree[now].l == tree[now].r) {
Q[now] = x;
return;
}
int mid = (tree[now].l + tree[now].r) / 2;
if (p <= mid)
Add(p, x, now * 2);
else
Add(p, x, now * 2 + 1);
}
void Query(int now) {
int ttop1 = top1, ttop2 = top2;
int len = V[now].size();
for (int i = 0; i < len; i++) {
int x = V[now][i].x, y = V[now][i].y, z = V[now][i].z;
int fx = find(x), fy = find(y);
if (fx != fy) {
if (h[fx] > h[fy]) swap(fx, fy);
if (h[fx] == h[fy])
h[fy]++, Stack1[++top1] = point(fx, fy);
else
Stack1[++top1] = point(fx, 0);
father[fx] = fy, pre[fx] = (ask(y) ^ z ^ ask(x));
} else {
int Len = ask(x) ^ ask(y) ^ z;
for (int i = 31; i >= 0; i--) {
if ((Len >> i) & 1) {
if (f[i])
Len ^= f[i];
else {
Stack2[++top2] = i;
f[i] = Len;
break;
}
}
if (!Len) break;
}
}
}
if (tree[now].l == tree[now].r) {
if (Q[now].x) {
int x = Q[now].x, y = Q[now].y;
int Len = ask(x) ^ ask(y);
for (int i = 31; i >= 0; i--) {
if ((Len ^ f[i]) < Len) Len ^= f[i];
}
printf("%d\n", Len);
}
while (top1 != ttop1) {
int x = Stack1[top1].x;
int y = Stack1[top2].y;
father[x] = x;
pre[x] = 0;
if (y) h[y]--;
top1--;
}
while (top2 != ttop2) {
int x = Stack2[top2];
f[x] = 0;
top2--;
}
return;
}
Query(now * 2);
Query(now * 2 + 1);
while (top1 != ttop1) {
int x = Stack1[top1].x;
int y = Stack1[top2].y;
father[x] = x;
pre[x] = 0;
if (y) h[y]--;
top1--;
}
while (top2 != ttop2) {
int x = Stack2[top2];
f[x] = 0;
top2--;
}
return;
}
void init() {
for (int i = 1; i <= n; i++) father[i] = i;
}
int main() {
int op, x, y, z;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
if (x > y) swap(x, y);
Map[point(x, y)] = point(1, z);
}
scanf("%d", &q);
build(1, q, 1);
for (int i = 1; i <= q; i++) {
scanf("%d%d%d", &op, &x, &y);
if (x > y) swap(x, y);
if (op == 1) {
scanf("%d", &z);
Map[point(x, y)] = point(i, z);
} else if (op == 2) {
temp = Map[point(x, y)];
z = temp.y;
Insert(temp.x, i, Point(x, y, z), 1);
Map.erase(point(x, y));
} else {
Add(i, point(x, y), 1);
}
}
for (it = Map.begin(); it != Map.end(); it++) {
temp = it->second;
z = temp.y, op = temp.x;
temp = it->first;
x = temp.x, y = temp.y;
Insert(op, q, Point(x, y, z), 1);
}
init();
Query(1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100010;
const int mod = 1e9 + 7;
const int inf = 2147483647;
const double pi = acos(-1.0);
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int Pow(int x, int y) {
if (!y) return 1;
int t = Pow(x, y >> 1);
t = (long long)t * t % mod;
if (y & 1) t = (long long)t * x % mod;
return t;
}
void inc(int& x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void dec(int& x, int y) {
x -= y;
if (x < 0) x += mod;
}
int n, a[Maxn], b[Maxn];
vector<pair<int, int> > G[Maxn];
void dfs(int x, int fa, int v) {
int s = G[x].size();
int inv = Pow(s, mod - 2);
a[x] = 1;
b[x] = (long long)v * inv % mod;
for (int i = 0; i < G[x].size(); i++) {
int y = G[x][i].first, d = G[x][i].second;
if (y == fa) continue;
dfs(y, x, d);
dec(a[x], (long long)a[y] * inv % mod);
inc(b[x], (long long)(b[y] + d) % mod * inv % mod);
}
if (s == 1 && x != 1)
a[x] = b[x] = 0;
else {
a[x] = Pow(a[x], mod - 2);
b[x] = (long long)b[x] * a[x] % mod;
a[x] = (long long)a[x] * inv % mod;
}
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int x = read() + 1, y = read() + 1, d = read();
G[x].push_back(make_pair(y, d)), G[y].push_back(make_pair(x, d));
}
dfs(1, 0, 0);
printf("%d", b[1]);
}
| 8 |
#include <bits/stdc++.h>
namespace solution {
class ISolution {
public:
virtual void init(){};
virtual bool input() { return false; };
virtual void output(){};
virtual int run() = 0;
};
} // namespace solution
namespace solution {}
namespace solution {
using namespace std;
const int SIZE = 1011;
const int MAX_TIME = 1000011;
int n;
int T[SIZE];
int C[SIZE];
long long X[MAX_TIME];
class Solution : public ISolution {
public:
bool input() {
if (!(cin >> n)) return false;
for (int i = 0; i < n; ++i) cin >> T[i] >> C[i];
return true;
}
void solve() {
fill(X, X + MAX_TIME, 0);
for (int i = 0; i < n; ++i) X[T[i]] += C[i];
long long t = 0;
long long res = 0;
long long sum = 0;
for (long long i = 0; i < MAX_TIME; ++i) {
if (sum > 0) {
t = max(t, i);
sum--;
}
sum += X[i];
res = max(res, sum);
}
if (sum) {
t += sum;
}
cout << t << " " << res << endl;
}
int run() {
while (init(), input()) {
solve();
output();
}
return 0;
}
};
} // namespace solution
int main() { return solution::Solution().run(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vv = vector<vector<T>>;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
for (int(i) = 0; (i) < (t.size()); ++(i)) {
os << t[i] << ",";
}
os << "}" << endl;
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class T>
inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
vector<string> s_p_l_i_t(const string &s, char c) {
vector<string> v;
int d = 0, f = 0;
string t;
for (char c : s) {
if (!d && c == ',')
v.push_back(t), t = "";
else
t += c;
if (c == '\"' || c == '\'') f ^= 1;
if (!f && c == '(') ++d;
if (!f && c == ')') --d;
}
v.push_back(t);
return move(v);
}
void e_r_r(vector<string>::iterator it) {}
template <typename T, typename... Args>
void e_r_r(vector<string>::iterator it, T a, Args... args) {
if (*it == " 1" || *it == "1")
cerr << endl;
else
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << ", ";
e_r_r(++it, args...);
}
const long long MOD = 1e9 + 7;
vector<int> primes, prime;
class PRPRPR {
public:
PRPRPR(int PRIME_MAX) {
prime.resize(PRIME_MAX);
for (int i = 2; i < PRIME_MAX; i++)
if (!prime[i]) {
primes.push_back(i);
for (int j = i * 2; j < PRIME_MAX; j += i) prime[j] = 1;
}
}
} prprprpr(312345);
int n, t;
vector<pair<int, int>> ps[112];
struct Edge {
int to, cap, rev;
int cost;
};
vector<int> nums;
void add_edge(vector<vector<Edge>> &g, int from, int to, int cap,
int cost = 0) {
from = lower_bound((nums).begin(), (nums).end(), from) - nums.begin();
to = lower_bound((nums).begin(), (nums).end(), to) - nums.begin();
g[from].push_back((Edge){to, cap, (int)g[to].size(), cost});
g[to].push_back((Edge){from, 0, (int)g[from].size() - 1, -cost});
}
int INF = 3e8;
vector<int> used;
int dfs(vector<vector<Edge>> &g, int v, int t, int f) {
if (v == t) return f;
used[v] = 1;
int re, i, j, k;
for (i = 0; i < g[v].size(); i++) {
Edge &e = g[v][i];
if (e.cap <= 0 || used[e.to]) continue;
int d = dfs(g, e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
return 0;
}
int max_flow(vector<vector<Edge>> &g, int s, int t) {
int sum = 0, f, V = g.size();
while (1) {
used.resize(V);
fill((used).begin(), (used).end(), 0);
sum += f = dfs(g, s, t, INF);
if (!f) return sum;
}
}
int fun(int m) {
vector<int> p(100001);
for (int(i) = 0; (i) < (m + 1); ++(i))
for (pair<int, int> pp : ps[i]) {
if (pp.second == 1) {
MX(p[1], pp.first);
} else {
p[pp.second] += pp.first;
}
}
nums = {0, 1};
for (int(i) = 2; (i) < (100001); ++(i))
if (p[i]) nums.push_back(i);
vector<vector<Edge>> g(nums.size()), h(nums.size());
int rm = 0;
for (int(i) = 2; (i) < (100001); ++(i))
if (p[i]) {
if (i % 2) {
add_edge(g, i, 1, p[i]);
add_edge(h, i, 1, p[i]);
} else {
add_edge(g, 0, i, p[i]);
if (prime[i + 1])
add_edge(h, 0, i, p[i]);
else
rm += p[i];
}
}
for (int i : nums)
if (i % 2 == 0 && i > 1)
for (int j : nums)
if (j % 2 && j > 1) {
if (!prime[i + j]) {
add_edge(g, i, j, INF);
add_edge(h, i, j, INF);
}
}
int sum = accumulate(p.begin() + 2, p.end(), 0);
return max(sum - max_flow(g, 0, 1), sum - rm + p[1] - max_flow(h, 0, 1));
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(0);
cin >> n >> t;
for (int(i) = 0; (i) < (n); ++(i)) {
int a, b, c;
cin >> a >> b >> c;
ps[c].emplace_back(a, b);
}
int l = 0, r = n + 1;
while (r - l > 1) {
int m = (l + r) / 2;
(fun(m) >= t ? r : l) = m;
}
cout << (r == n + 1 ? -1 : r) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool prime(int x) {
int count = 0;
for (int i = 2; i < x; i++) {
if (x % i == 0) count++;
}
if (count > 0)
return false;
else
return true;
}
int main() {
int T;
cin >> T;
for (int t = 0; t < T; t++) {
int N;
cin >> N;
string s;
cin >> s;
bool done = false;
for (int i = 0; i < N; i++)
if (s[i] == '1' || s[i] == '4' || s[i] == '6' || s[i] == '8' ||
s[i] == '9') {
cout << "1"
<< "\n"
<< s[i] << endl;
done = true;
break;
}
if (!done) {
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
int num = (s[i] - '0') * 10 + (s[j] - '0');
if (!prime(num)) {
cout << "2"
<< "\n"
<< num << endl;
done = true;
}
if (done) break;
}
if (done) break;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f3f3f3f3LL;
const long long mod = (long long)1e9 + 7;
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
bool first = true;
os << "[";
for (auto i : v) {
if (!first) os << ", ";
os << i;
first = false;
}
return os << "]";
}
const long long N = (long long)1e5 + 10;
long long n;
vector<long long> v[N];
long double solve(long long s, long long p, long long dep) {
long double exp = 1 / (long double)dep;
for (auto it : v[s]) {
if (it == p) continue;
exp += solve(it, s, dep + 1);
}
return exp;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (long long i = 0; i < n - 1; ++i) {
long long a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
cout << fixed << setprecision(20);
cout << solve(1, -1, 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pi;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef vector<int> vi;
const int N = 1e5;
const int64_t mod = 1LL + N;
template<typename U, typename V>
U getMax(U u, V v){
if (u > v) return u;
return (U)v;
};
vector<vector<pair<int,int>>>E(N, vector<pair<int,int>>());
vector<int64_t> dist(N, 1e9);
vector<bool> vis(N, false);
vector<int> lastVal(N, 101);
void solve(){
int n, m; cin >> n >> m;
for (int i = 0; i < m; i++){
int u,v,w; cin >> u >> v >> w;
u--; v--;
E[u].pb({v,w});
E[v].pb({u,w});
}
auto dijkstra = [&](int src){
dist[src] = 0LL;
set<pair<int64_t,int>>st;
st.insert({0LL,src});
while (st.size()){
auto top = *st.begin(); st.erase(st.begin());
int v = top.second;
if (vis[v]) continue;
vis[v] = true;
for (auto e1 : E[v]){
int mid = e1.first;
if (lastVal[mid]<=e1.second) continue;
lastVal[mid] = e1.second;
for (auto e2 : E[mid]){
if (!vis[e2.first]){
int64_t dd = top.first + 1LL * (e1.second + e2.second) * (e1.second + e2.second);
if (dd < dist[e2.first]){
dist[e2.first] = dd;
st.insert({dd, e2.first});
}
}
}
}
}
};
dijkstra(0);
for (int i = 0;i < n; i++){
cout << (dist[i] == 1e9 ? -1 : dist[i]) << " ";
}
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
ll t = 1;
while(t--){
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using u64 = unsigned long long;
using i64 = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
size_t N;
cin >> N;
i64 arr[N];
for (size_t i = 0; i < N; i++) cin >> arr[i];
for (size_t i = 0; i < N; i++) {
for (size_t j = 0; j < N - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr[j], arr[j + 1]);
cout << j + 1 << " " << j + 2 << endl;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 107;
const int mod = 1e9 + 7;
long long a[maxn], k;
long long f[maxn];
int n, q;
int main() {
scanf("%d%d", &n, &q);
f[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
f[i] = f[i - 1] + a[i];
}
int die = 0;
long long used = 0;
for (int i = 1; i <= q; i++) {
scanf("%lld", &k);
long long x = 0;
x = f[die] + k + used;
int t = lower_bound(f + die, f + 1 + n, x) - f;
if (t < n) {
if (f[t] == x) {
die = t;
used = 0;
} else {
die = t - 1;
used = x - f[t - 1];
}
} else {
if (f[t] > x) {
die = n - 1;
used = a[t] - (f[t] - x);
} else {
die = 0;
used = 0;
}
}
if (used == 0)
printf("%d\n", n - die);
else
printf("%d\n", n - die);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int mod = 1000000007;
const long long INF = 9000000000000000000;
using namespace std;
void solve() {
long long n;
cin >> n;
string s1, hold, s2;
for (int i = 0; i < n; i++) {
cin >> hold;
hold = "<3" + hold;
s1 += hold;
}
s1 += "<3";
cin >> s2;
long long cur = 0;
for (int i = 0; i < s2.length(); i++) {
if (s2[i] == s1[cur]) {
cur++;
if (cur == s1.length()) {
cout << "yes" << endl;
return;
}
}
}
cout << "no" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long q = 1;
while (q--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool volum(char x) {
if (x == 'a' || x == 'o' || x == 'u' || x == 'i' || x == 'e')
return true;
else
return false;
}
int main() {
int x1, y1, x2, y2;
int a, b;
cin >> x1 >> y1 >> x2 >> y2;
cin >> a >> b;
int e = abs(x1 - x2);
e = ceil(e / (a));
int k = abs(y1 - y2);
k = ceil(k / (b));
if (abs(e - k) % 2 == 0 && abs(x1 - x2) % a == 0 && abs(y1 - y2) % b == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ar array
const int MOD = (int)(1e9)+7, INF = 0x3f3f3f3f;
void bayo() {
int n, m;
cin >> n >> m;
int a[n][m], ans[n][m], l[n], r[n];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
sort(a[i], a[i]+m);
l[i] = 0; r[i] = m-1;
}
for (int i = 0; i < m; ++i) {
int mn = INF, p;
for (int j = 0; j < n; ++j) {
if (mn > a[j][l[j]]) {
mn = a[j][l[j]];
p = j;
}
}
for (int j = 0; j < n; ++j) {
if (j == p) ans[j][i] = a[j][l[j]++];
else ans[j][i] = a[j][r[j]--];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << ans[i][j] << ' ';
}
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) bayo();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int to[200020], head[200020], nxt[200020], cost[200020], cap[200020], cnt;
void init() { memset(head, -1, sizeof head); }
void add_Edge(int S, int T, int c, int w) {
nxt[cnt] = head[S], cap[cnt] = c, cost[cnt] = w, to[cnt] = T, head[S] = cnt++;
nxt[cnt] = head[T], cap[cnt] = 0, cost[cnt] = -w, to[cnt] = S,
head[T] = cnt++;
}
const long long INF = 1e14;
long long dist[200020];
int prv[200020];
bool vis[200020];
long long SPFA(int S, int T, int vet) {
queue<int> Q;
fill(prv, prv + vet, -1);
fill(dist, dist + vet, INF);
Q.push(S);
dist[S] = 0, vis[S] = true;
while (!Q.empty()) {
int x = Q.front();
Q.pop(), vis[x] = false;
for (int id = head[x]; ~id; id = nxt[id])
if (cap[id]) {
int y = to[id];
if (dist[y] > dist[x] + cost[id]) {
dist[y] = dist[x] + cost[id];
prv[y] = id;
if (!vis[y]) Q.push(y), vis[y] = true;
}
}
}
if (!~prv[T]) {
return INF;
}
for (int cur = T; cur != S; cur = to[cur ^ 1]) {
cur = prv[cur];
cap[cur]--;
cap[cur ^ 1]++;
}
return dist[T];
}
int a[200020], b[200020], n, k;
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);
int S = 0, T = 2 * n + 1;
init();
for (int i = 1; i <= n; i++) {
add_Edge(S, i, 1, a[i]);
add_Edge(i + n, T, 1, b[i]);
add_Edge(i, i + n, n, 0);
if (i < n) add_Edge(i + n, i + n + 1, n - i, 0);
}
long long ans = 0;
for (int i = 1; i <= k; i++) ans += SPFA(S, T, T + 1);
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 2 * acos(0.0);
const long long prime = 31;
const long long inf = 1e9;
const long long mod = 1e9 + 7;
const long long maxn = 1e2 + 5;
const long long maxm = 1e3 + 5;
long long a, b, ans, cnt;
double x, y, sum;
int main() {
cin >> a >> b;
x = 0;
y = b;
for (int i = 0; i <= b; ++i) {
sum = (x + 1) * (y + 1) * (x / 2 + y / 2);
cnt = sum;
ans = max(ans, cnt);
x += a;
y--;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int T, x, t = 0;
cin >> T;
for (int i = 0; i < T; i++) {
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
if (!v.empty()) {
while (v.back() == 4) {
v.pop_back();
t++;
if (v.empty()) break;
}
}
if (!v.empty()) {
while (v.back() == 3 && v.front() == 1) {
t++;
v.pop_back();
v.erase(v.begin());
if (v.empty()) break;
}
}
if (!v.empty()) {
while (v.back() == 3) {
t++;
v.pop_back();
if (v.empty()) break;
}
}
if (!v.empty()) {
while (v.back() == 2 && v.front() == 1) {
if (v.at(1) == 1) {
t++;
v.pop_back();
v.erase(v.begin(), v.begin() + 2);
if (v.empty()) break;
} else if (v.front() == 1) {
t++;
v.pop_back();
v.erase(v.begin());
if (v.empty()) break;
}
}
}
if (!v.empty()) {
while (v.back() == 2 && v.front() == 2 && (v.size() > 1)) {
t++;
v.pop_back();
v.erase(v.begin());
if (v.empty()) break;
}
}
if (!v.empty()) {
while (v.back() == 2 && v.front() == 2 && v.size() == 1) {
t++;
v.pop_back();
if (v.empty()) break;
}
}
if (!v.empty()) {
while (v.back() == 1 && v.size() > 4) {
v.erase(v.begin(), v.begin() + 4);
t++;
if (v.empty()) break;
}
}
if (!v.empty()) {
if (v.back() == 1 && v.size() <= 4) {
v.clear();
t++;
}
}
cout << t << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[3001][3001];
int main() {
ios::sync_with_stdio(false);
;
long long i, j, k, l, r, m, n, o, t, arr[3001], sor[3001];
cin >> n;
for (i = 1; i <= n; i++) {
cin >> arr[i];
arr[i] -= i;
sor[i] = arr[i];
}
sort(sor + 1, sor + n + 1);
for (j = 1; j <= n; j++) {
if (arr[1] > sor[j])
dp[1][j] = abs(arr[1] - sor[j]);
else
dp[1][j] = 0;
}
for (i = 2; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (j > 1)
k = dp[i][j - 1];
else
k = 9000000000000000000;
o = dp[i - 1][j] + abs(arr[i] - sor[j]);
dp[i][j] = min(o, k);
}
}
long long ans = 9000000000000000000;
for (j = 1; j <= n; j++) {
ans = min(ans, dp[n][j]);
}
cout << ans << endl;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.