solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long NR = 1e5 + 10, oo = 2e9 + 10, MOD = 1e9 + 7;
const long double pi = 2 * acos(0.0);
int t;
string s;
int n;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long a, b, l, ans, i, ans2;
cin >> t;
while (t--) {
ans = 0;
ans2 = 0;
cin >> n;
cin >> s;
l = 1;
for (i = 1; i < s.size(); ++i) {
if (s[i] == s[i - 1]) {
l++;
} else {
if (s[i - 1] == '0') {
ans += l - 1;
}
if (s[i - 1] == '1') {
ans2 += l - 1;
}
l = 1;
}
}
if (s[i - 1] == '0') {
ans += l - 1;
}
if (s[i - 1] == '1') {
ans2 += l - 1;
}
cout << max(ans, ans2) << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int s[10] = {1, 3, 2, 6, 4, 5};
int main() {
long n, i;
cin >> n;
if (n < 3) {
cout << "-1" << endl;
} else if (n == 3) {
cout << "210" << endl;
} else {
int init = 20;
while (init <= 210) {
int x = init;
int y = 0;
i = 0;
while (x > 0) {
y += (x % 10) * s[i];
i++;
x /= 10;
}
if (n % 6 == 0)
y += s[5];
else
y += s[(n % 6) - 1];
if (y % 7 == 0) break;
init += 30;
}
cout << "1";
for (i = 1; i <= n - 4; i++) cout << "0";
if (init < 100) cout << "0";
cout << init << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m, k, aux, a, b, tot;
vector<int> v;
cin >> n >> m >> k;
for (i = 0; i < k; i++) {
cin >> aux;
v.push_back(aux);
}
tot = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> aux;
a = v[0];
for (k = 0; k < v.size(); k++) {
if (v[k] == aux) break;
swap(a, v[k]);
}
swap(a, v[k]);
v[0] = aux;
tot += k + 1;
}
}
cout << tot << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
vector<int> Div[N];
set<int> divmark[N];
bool mark[N];
string conf(int x) {
stringstream sts;
sts << "Conflict with " << x;
string s;
getline(sts, s);
return s;
}
string on(int x) {
if (mark[x] == 1) return "Already on";
for (auto k : Div[x])
if (divmark[k].size()) return conf(*divmark[k].begin());
mark[x] = 1;
for (auto k : Div[x]) divmark[k].insert(x);
return "Success";
}
string off(int x) {
if (mark[x] == 0) return "Already off";
mark[x] = 0;
for (auto k : Div[x]) divmark[k].erase(x);
return "Success";
}
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 2; i < N; i++)
for (int j = i; j < N; j += i) Div[j].push_back(i);
for (int i = 0; i < m; i++) {
char c;
int x;
cin >> c >> x;
cout << (c == '+' ? on(x) : off(x)) << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct pair_hash {
template <class T1, class T2>
size_t operator()(const pair<T1, T2> &pair) const {
return hash<T1>()(pair.first) ^ hash<T2>()(pair.second);
}
};
bool compare(long long int a, long long int b) { return a > b; }
long long int findlow(vector<long long int> a, long long int s, long long int e,
long long int d) {
long long int res = max(a[s + d], a[e]);
for (long long int i = 0; i < d + 1; i++) {
long long int f = i;
long long int b = d - f;
long long int r = max(a[s + f], a[e - b]);
res = min(res, r);
}
return res;
}
long long int solve(vector<long long int> a, long long int c, long long int d) {
long long int res = 0;
for (long long int i = 0; i < c + 1; i++) {
long long int f = i;
long long int b = c - f;
res = max(res, findlow(a, f, a.size() - 1 - b, d));
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
cin >> t;
while (t--) {
long long int n, m, k;
cin >> n >> m >> k;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int c = min(m - 1, k);
long long int d = (m - 1) - c;
long long int low = solve(a, c, d);
cout << low << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int min(int a, int b) {
if (a > b) return b;
return a;
}
int max(int a, int b) {
if (a > b) return a;
return b;
}
int main() {
int n, m;
cin >> n >> m;
int c[n], a[m];
for (int i = 0; i < n; i++) {
cin >> c[i];
}
for (int i = 0; i < m; i++) {
cin >> a[i];
}
int j = 0, flag = 0;
for (int i = 0; i < n && j < m; i++) {
if (c[i] <= a[j]) {
flag++;
j++;
}
}
cout << flag;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 123, mo = 1000000007;
int n, m, ps, cnts[_] = {0};
long long ans = 0;
bitset<_> alls;
inline bitset<_> rshl(bitset<_> a, int d) {
d %= m;
return ((a << d) | (a >> (m - d))) & alls;
}
inline bitset<_> rshr(bitset<_> a, int d) {
d %= m;
return ((a >> d) | (a << (m - d))) & alls;
}
void dfs(bitset<_> now, int las, long long d) {
ans = (ans + d) % mo;
for (int i = las; i + i <= m; i++)
if (cnts[i] && !now[i] && !now[m - i])
dfs(now | rshl(now, i) | rshr(now, i), i + 1, d * cnts[i] % mo);
}
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), m = ty(), ps = ty();
for (int i = 1; i <= ps; i++) {
int a = ty() % m;
cnts[min(a, m - a)]++;
}
bitset<_> temp = 0;
temp[0] = 1;
alls = 0;
for (int i = 0; i < m; i++) alls[i] = 1;
dfs(temp, 0, 1), cout << ans << lf;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e17;
const int mod = 1e9 + 7;
int d, n, a[2000 + 100], ans = 0;
bool mark[2000 + 100][2000 + 100];
vector<int> g[2000 + 100];
int dfs(int v, int mini, int maxi, int par) {
if (mark[v][maxi]) return 0;
long long t = 1;
for (int i : g[v]) {
if (i == par) continue;
if (a[i] < mini || a[i] > maxi) continue;
t *= (dfs(i, mini, maxi, v) + 1);
t %= mod;
}
return t;
}
int main() {
cin >> d >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int t, k;
cin >> t >> k;
g[k].push_back(t), g[t].push_back(k);
}
for (int i = 1; i <= n; i++) {
ans += max(dfs(i, a[i], a[i] + d, -1), -1);
ans %= mod;
mark[i][a[i] + d] = true;
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, s = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') s = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + (c ^ '0');
c = getchar();
}
return x * s;
}
long long n, m, r[1000010], l[1000010], a[1000010];
long long s1[1000010], s2[1000010];
double ans[1000010];
void search() {
for (int i = n; i; i--) {
if (a[i + 1] <= a[i])
r[i] = i + 1;
else
for (int j = r[i + 1]; j <= n + 1; j = r[j])
if (a[j] <= a[i]) {
r[i] = j;
break;
}
}
for (int i = 1; i <= n; i++) {
if (a[i - 1] < a[i])
l[i] = i - 1;
else
for (int j = l[i - 1]; j >= 0; j = l[j])
if (a[j] < a[i]) {
l[i] = j;
break;
}
}
for (int i = 1; i <= n; i++) {
l[i] = i - l[i];
r[i] = r[i] - i;
}
return;
}
void prepare() {
for (int i = 1; i <= n; i++) {
int x = l[i], y = r[i];
if (x > y) swap(x, y);
s1[1] += a[i];
s1[x + 1] -= a[i];
s2[x + 1] += a[i] * x;
s1[y + 1] -= a[i];
s2[y + 1] += a[i] * y;
s1[x + y] += a[i];
s2[x + y] -= a[i] * (x + y);
}
long long num1 = 0, num2 = 0;
for (int i = 1; i <= n; i++) {
num1 += s1[i], num2 += s2[i];
ans[i] = ((num1 * i + num2) * 1.00) / ((n - i + 1) * 1.00);
}
return;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
a[n + 1] = (long long)(-(1 << 50));
a[0] = (long long)(-(1 << 50));
search();
prepare();
m = read();
while (m--) {
long long k = read();
printf("%.9lf\n", ans[k]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline int Add(int x) { return x >= mod ? x - mod : x; }
inline void Add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline int Sub(int x) { return x < 0 ? x + mod : x; }
inline void Sub(int &x, int y) { x = Sub(x - y); }
inline int Mul(int x, int y) { return (int)((unsigned long long)x * y % mod); }
inline int Mul(int x, int y, int z) {
return (int)((unsigned long long)x * y % mod * z % mod);
}
int Pow(int x, int y) {
int z = 1;
for (; y; y >>= 1) {
if (y & 1) z = Mul(z, x);
x = Mul(x, x);
}
return z;
}
int Inv(int x) { return Pow(x, mod - 2); }
template <class T>
inline void Max(T &x, T y) {
if (y > x) x = y;
}
template <class T>
inline void Min(T &x, T y) {
if (y < x) x = y;
}
const int inf = ~0U >> 1;
int X[4], Y[4];
int ds[12], nd;
int best, Xa[4], Ya[4];
int P[4];
int X2[4], Y2[4];
void Update(int Xe, int Ye, int cost, int d) {
if (cost < best) {
best = cost;
for (int i = 0; i < 4; ++i) {
Xa[P[i]] = Xe + (i & 1) * d;
Ya[P[i]] = Ye + (i >> 1 & 1) * d;
}
}
}
void SolveP(int d) {
if (X2[0] == X2[1] && X2[0] == X2[2] && X2[0] == X2[3]) {
int low = min(min(Y2[0], Y2[1]), min(Y2[2], Y2[3]));
int high = max(max(Y2[0], Y2[1]), max(Y2[2], Y2[3]));
int mid = low + high >> 1;
int cost = max(high - mid, mid - low);
Update(X2[0], mid, cost, d);
return;
}
if (Y2[0] == Y2[1] && Y2[0] == Y2[2] && Y2[0] == Y2[3]) {
int low = min(min(X2[0], X2[1]), min(X2[2], X2[3]));
int high = max(max(X2[0], X2[1]), max(X2[2], X2[3]));
int mid = low + high >> 1;
int cost = max(high - mid, mid - low);
Update(mid, Y2[0], cost, d);
return;
}
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
int Xe = X2[i], Ye = Y2[j];
int cost = 0;
for (int k = 0; k < 4; ++k) {
if (X2[k] == Xe) {
Max(cost, abs(Y2[k] - Ye));
} else if (Y2[k] == Ye) {
Max(cost, abs(X2[k] - Xe));
} else {
cost = inf;
break;
}
}
Update(Xe, Ye, cost, d);
}
}
}
void SolveD(int d) {
for (int i = 0; i < 4; ++i) {
P[i] = i;
}
do {
for (int i = 0; i < 4; ++i) {
X2[i] = X[P[i]];
Y2[i] = Y[P[i]];
X2[i] -= (i & 1) * d;
Y2[i] -= (i >> 1 & 1) * d;
}
SolveP(d);
} while (next_permutation(P, P + 4));
}
void Solve(void) {
for (int i = 0; i < 4; ++i) {
scanf("%d%d", X + i, Y + i);
}
nd = 0;
for (int i = 0; i < 4; ++i) {
for (int j = i + 1; j < 4; ++j) {
int t = abs(X[i] - X[j]);
if (t > 0) ds[nd++] = t;
int w = abs(Y[i] - Y[j]);
if (w > 0) ds[nd++] = w;
}
}
sort(ds, ds + nd);
nd = unique(ds, ds + nd) - ds;
best = inf;
for (int i = 0; i < nd; ++i) {
SolveD(ds[i]);
}
if (best == inf) {
puts("-1");
} else {
printf("%d\n", best);
for (int i = 0; i < 4; ++i) {
printf("%d %d\n", Xa[i], Ya[i]);
}
}
}
int main(void) {
int t;
scanf("%d", &t);
while (t--) Solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
void imp() {
cout << "Impossible\n";
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int a00, a01, a10, a11, c0, c1, x;
cin >> a00 >> a01 >> a10 >> a11;
c0 = sqrtl(2 * a00) + 1;
c1 = sqrtl(2 * a11) + 1;
if (a00 == 0 || a11 == 0) {
if (a01 == 0 && a10 == 0) {
if (a00 == 0) {
c0 = 0;
}
if (a11 == 0) {
c1 = 0;
}
}
}
if (c0 == 0 && c1 == 0) {
cout << 0 << "\n";
exit(0);
} else if ((c0 * (c0 - 1)) / 2 != a00) {
imp();
} else if ((c1 * (c1 - 1)) / 2 != a11) {
imp();
}
if (c0 * c1 != a01 + a10) {
imp();
}
x = c0 + c1;
for (int i = 1; i < x + 1; i++) {
if (a01 >= c1) {
cout << 0;
a01 -= c1;
c0--;
} else {
cout << 1;
a10 -= c0;
c1--;
}
}
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000010];
long long sum = 0;
int main() {
int n, f = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
sum += a[i];
if (a[i] % 2 != 0) f = 1;
}
if (sum % 2 == 1)
printf("First\n");
else {
if (f == 1)
printf("First\n");
else
printf("Second\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000007;
int n, m, k, i, j, num, x, y, fi, fr, q[202], p[202], a[202], b[202][22],
f[202][3][202][502];
vector<int> l, r;
int solve(const vector<int>& v, int mj) {
int r = 0;
f[0][1][0][0] = 1;
for (int i = 0; i <= v.size(); i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k <= num; k++)
for (int z = 0; z <= n; z++)
if (f[i][j][k][z]) {
if (i < v.size()) {
r = (r + f[i][j][k][z]) % md;
for (int e = int(i == 0); e < m; e++) {
int nj = j, nk = b[k][e];
if (j == 1 && e != v[i]) {
if (e < v[i])
nj = 0;
else
nj = 2;
}
if (z + a[nk] <= n)
f[i + 1][nj][nk][z + a[nk]] =
(f[i + 1][nj][nk][z + a[nk]] + f[i][j][k][z]) % md;
}
} else if (j <= mj)
r = (r + f[i][j][k][z]) % md;
f[i][j][k][z] = 0;
}
return r;
}
int main() {
scanf("%d%d%d", &k, &m, &n);
scanf("%d", &x);
while (x--) {
scanf("%d", &y);
l.push_back(y);
}
scanf("%d", &x);
while (x--) {
scanf("%d", &y);
r.push_back(y);
}
while (k--) {
scanf("%d", &x);
for (i = 0; x--;) {
scanf("%d", &y);
if (b[i][y] == 0) b[i][y] = ++num;
i = b[i][y];
}
scanf("%d", &x);
a[i] += x;
}
q[0] = fi = 0;
fr = 1;
while (fi < fr) {
i = q[fi++];
a[i] += a[p[i]];
for (j = 0; j < m; j++)
if (b[i][j]) {
q[fr++] = b[i][j];
if (i) p[b[i][j]] = b[p[i]][j];
} else if (i)
b[i][j] = b[p[i]][j];
}
printf("%d\n", (solve(r, 1) + md - solve(l, 0)) % md);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s;
vector<int> v;
void solve() {
cin >> s;
int n = (s).size(), sum = 0, sgn = 1;
for (int i = 0; i < n;) {
int cur = 0, j;
for (j = i; j < n && isdigit(s[j]); ++j) cur = cur * 10 + (s[j] - '0');
sum += sgn * cur;
if (j < n) {
if (s[j] == '+')
sgn = 1;
else
sgn = -1;
}
i = j + 1;
}
if (!sum)
v.push_back(0);
else
while (sum) {
v.push_back(sum % 10);
sum /= 10;
}
reverse(begin((v)), end((v)));
n = (v).size();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < v[i] + 48; ++j) printf("+");
printf(".>");
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool check(string s1, string s2, int first) {
int i, len = s1.size();
if (len < 5) return false;
if (first) {
for (i = 0; i < 5; i++) {
if (s1[i] != s2[i]) return false;
}
} else {
for (i = 0; i < 5; i++) {
if (s1[len - 5 + i] != s2[i]) return false;
}
}
return true;
}
int main() {
int q;
cin >> q;
string s, s1("miao."), s2("lala.");
getline(cin, s);
for (int o = 0; o < q; o++) {
getline(cin, s);
bool freda, rainbow;
freda = check(s, s2, 0);
rainbow = check(s, s1, 1);
if (!(freda ^ rainbow))
cout << "OMG>.< I don't know!" << endl;
else if (freda)
cout << "Freda's" << endl;
else
cout << "Rainbow's" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
long long gcd_act = 0;
for (int i = 0; i < n; ++i) {
long long ai;
cin >> ai;
gcd_act = gcd(ai, gcd_act);
}
set<long long> possible;
gcd_act %= k;
for (int i = 0; i < k; ++i) {
possible.insert((gcd_act * i) % k);
}
unsigned long long l = 1;
cout << possible.size() << "\n";
for (long long p : possible) {
cout << p;
if (l != possible.size()) {
l++;
cout << " ";
}
}
cout << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 3;
int n, ln[N];
char s[N];
long long a[N], dp[N][N][N];
int main() {
scanf("%d%s", &n, s + 1);
for (register int i = (1); i <= (n); ++i) scanf("%lld", a + i);
for (register int i = (n); i >= (1); --i) {
for (register int j = (i + 1); j <= (n); ++j)
if (s[i] == s[j]) {
ln[i] = ln[j] + 1;
break;
}
if (!ln[i]) ln[i] = 1;
}
for (register int len = (1); len <= (n); ++len)
for (register int l = 1, r = len; r <= n; ++l, ++r) {
for (register int i = (n - r); i >= (0); --i) {
long long& st = dp[l][r][i];
for (register int j = (r - 1); j >= (l); --j)
if (s[j] == s[r]) st = max(st, dp[j + 1][r - 1][0] + dp[l][j][i + 1]);
}
for (register int j = (0); j <= (ln[r] - 1); ++j)
dp[l][r][j] = max(dp[l][r][j], dp[l][r - 1][0] + a[j + 1]);
}
printf("%lld\n", dp[1][n][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
long long n;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (int i = 0; i < n; i += 2) cout << arr[i] << " ";
for (int i = n - 1 - (n) % 2; i >= 0; i -= 2) cout << arr[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> m;
int main() {
long long n, ans = 0;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
arr[i] = a;
m[a]++;
}
for (int x = 0; x < n; x++) {
for (long long i = 1; i <= (1LL << 31); i <<= 1)
ans += m[i - arr[x]] - (i - arr[x] == arr[x]);
}
cout << ans / 2;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
char str[N];
int arr[N], suffix[N], suffix2[N];
int n, a, b, t;
int get1() {
int ans = 0;
int _t = t;
int i = 0;
while (i < n) {
if (str[i] == 'w') _t -= b;
_t--;
if (_t >= 0)
ans++;
else
break;
if (_t >= a && i != n - 1) _t -= a, i++;
}
return ans;
}
int get2() {
int ans = 0;
int _t = t;
int i = n - 1;
if (str[0] == 'w') _t -= b;
_t -= 1;
if (t >= 0)
ans++;
else
return 0;
if (_t >= a)
_t -= a;
else
return ans;
while (i > 0) {
if (str[i] == 'w') _t -= b;
_t--;
if (_t >= 0)
ans++;
else
break;
if (_t >= a && i != 1) _t -= a, i--;
}
return ans;
}
int main() {
scanf("%d %d %d %d", &n, &a, &b, &t);
scanf("%s", str);
for (int i = 1; i <= n; i++) {
if (str[i - 1] == 'w')
arr[i] = b + 1;
else
arr[i] = 1;
}
for (int i = n; i >= 2; i--) {
if (i == n)
suffix[i] = a + arr[i];
else
suffix[i] = suffix[i + 1] + arr[i] + a;
if (i == n)
suffix2[i] = 2 * a + arr[i];
else
suffix2[i] = suffix2[i + 1] + arr[i] + 2 * a;
}
if (arr[1] > t) {
cout << 0 << endl;
return 0;
}
int best = 0;
int _t = 0;
int back = 0;
int lf = 0, l, r, mx;
for (int i = 1; i <= n; i++) {
_t += arr[i];
if (_t > t) break;
lf = t - _t - back;
if (lf < suffix[n]) {
best = max(best, i);
} else {
l = i + 1, r = n;
while (l < r) {
mx = (l + r) / 2;
if (suffix[mx] <= lf)
r = mx;
else
l = mx + 1;
}
best = max(best, (i + n - l + 1));
}
lf = t - _t;
if (lf < suffix2[n]) {
best = max(best, i);
} else {
l = i + 1, r = n;
while (l < r) {
mx = (l + r) / 2;
if (suffix2[mx] <= lf)
r = mx;
else
l = mx + 1;
}
best = max(best, (i + n - l + 1));
}
_t += a;
back += a;
}
cout << best << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
int j = n / 2;
long long int sum = 0;
if (s > a[j]) {
sum += s - a[j];
j++;
while (j < n && s > a[j]) sum += s - a[j++];
cout << sum;
} else if (s < a[j]) {
sum += a[j] - s;
j--;
while (j >= 0 && s < a[j]) sum += a[j--] - s;
cout << sum;
} else
cout << 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[1005], t;
a[0] = 1;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
t = min(a[n], a[1]);
for (int k = 1; k <= t; k++) {
for (int i = 1; i <= n; i++) {
a[i]--;
if (a[i] <= 0 && a[i - 1] <= 0) {
cout << k;
return 0;
}
}
}
cout << t;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, dis[3010][3010];
int ans[5];
bool vis[3010];
vector<int> adj[3010];
vector<int> eg[2][3010];
struct DATA {
int u, dis;
DATA(int u = 0, int dis = 0) : u(u), dis(dis) {}
bool operator<(const DATA &a) const { return dis > a.dis; }
} c[3010];
void Dijkstra(int s) {
memset(dis[s], 0x3f, sizeof(dis[s]));
memset(vis, 0, sizeof(vis));
priority_queue<DATA> q;
DATA a;
dis[s][s] = 0;
for (q.push(DATA(s, 0)); !q.empty();) {
a = q.top();
q.pop();
if (vis[a.u]) continue;
vis[a.u] = true;
for (int v : adj[a.u])
if (dis[s][a.u] + 1 < dis[s][v]) {
dis[s][v] = dis[s][a.u] + 1;
q.push(DATA(v, dis[s][v]));
}
}
}
void Init() {
int i, u, v, t;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
}
for (i = 1; i <= n; ++i) {
Dijkstra(i);
for (v = 1, t = 0; v <= n; ++v) {
if (dis[i][v] == 0x3f3f3f3f) continue;
++t;
c[t] = DATA(v, dis[i][v]);
}
sort(c + 1, c + 1 + t);
for (v = 1; v <= t && v <= 4; ++v) eg[0][i].push_back(c[v].u);
}
for (i = 1; i <= n; ++i) {
for (v = 1, t = 0; v <= n; ++v) {
if (dis[v][i] == 0x3f3f3f3f) continue;
++t;
c[t] = DATA(v, dis[v][i]);
}
sort(c + 1, c + 1 + t);
for (v = 1; v <= t && v <= 4; ++v) eg[1][i].push_back(c[v].u);
}
memset(vis, 0, sizeof(vis));
}
int main() {
Init();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
if (i == j || dis[i][j] == 0x3f3f3f3f) continue;
for (int u : eg[1][i]) {
if (u == i || u == j) continue;
for (int v : eg[0][j]) {
if (v == u || v == i || v == j) continue;
if (dis[u][i] + dis[i][j] + dis[j][v] > ans[0])
ans[0] = dis[u][i] + dis[i][j] + dis[j][v], ans[1] = u, ans[2] = i,
ans[3] = j, ans[4] = v;
}
}
}
for (int i = 1; i <= 4; ++i) printf("%d ", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
point() {}
point(long long x, long long y) : x(x), y(y) {}
point(const point& p) : x(p.x), y(p.y) {}
point operator+(const point& p) const { return point(x + p.x, y + p.y); }
point operator-(const point& p) const { return point(x - p.x, y - p.y); }
};
bool operator<(const point& xx, const point& yy) {
return make_pair(xx.x, xx.y) < make_pair(yy.x, yy.y);
}
bool operator==(const point& xx, const point& yy) {
return make_pair(xx.x, xx.y) == make_pair(yy.x, yy.y);
}
inline long long dot_product(point xx, point yy) {
return (xx.x * yy.x) + (xx.y * yy.y);
}
inline long long cross_product(point xx, point yy) {
return (xx.x * yy.y) - (xx.y * yy.x);
}
inline long long sqdist(point xx, point yy) {
return dot_product(xx - yy, xx - yy);
}
inline long double dist(point xx, point yy) { return sqrt(sqdist(xx, yy)); }
inline bool anti(point xx, point yy) {
if (cross_product(xx, yy) > 0) {
return true;
}
return false;
}
point lowbot;
inline bool compare(point xx, point yy) {
if (cross_product(xx - lowbot, yy - lowbot) == 0) {
return sqdist(lowbot, xx) < sqdist(lowbot, yy);
}
return cross_product(xx - lowbot, yy - lowbot) > 0;
}
inline vector<point> convex_hull(vector<point> v) {
int id = 0;
lowbot = v[0];
for (int i = 1; i < v.size(); i++) {
if ((lowbot.y > v[i].y) || (lowbot.y == v[i].y && (lowbot.x > v[i].x))) {
id = i;
lowbot = v[id];
}
}
swap(v[0], v[id]);
sort(v.begin() + 1, v.end(), compare);
vector<point> ans;
ans.push_back(v[0]);
ans.push_back(v[1]);
for (int i = 2; i < v.size(); i++) {
while (ans.size() >= 2) {
if (!anti(ans[ans.size() - 1] - ans[ans.size() - 2],
v[i] - ans[ans.size() - 1])) {
ans.pop_back();
} else {
break;
}
}
ans.push_back(v[i]);
}
return ans;
}
inline long double triarea(point xx, point yy, point zz) {
long double ans = (xx.x * yy.y - yy.x * xx.y) + (yy.x * zz.y - zz.x * yy.y) +
(zz.x * xx.y - zz.y * xx.x);
return fabs(ans) / 2.0;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
long long s;
cin >> s;
vector<point> v;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v.push_back(point(x, y));
}
vector<point> hull = convex_hull(v);
int m = hull.size();
int a = 0, b = 1, c = 2, ansa, ansb, ansc;
long double ans = 0.0;
for (int i = 0; i < hull.size(); i++) {
a = i;
b = (a + 1) % m;
c = (b + 1) % m;
while (1) {
while (1) {
if (triarea(hull[a], hull[b], hull[c]) <=
triarea(hull[a], hull[b], hull[(c + 1) % m])) {
c = (c + 1) % m;
} else {
break;
}
}
if (triarea(hull[a], hull[b], hull[c]) <=
triarea(hull[a], hull[(b + 1) % m], hull[c])) {
b = (b + 1) % m;
} else {
break;
}
}
if (ans + 1e-12 < triarea(hull[a], hull[b], hull[c])) {
ans = triarea(hull[a], hull[b], hull[c]);
ansa = a, ansb = b, ansc = c;
}
}
point pt1 = hull[ansa];
point pt2 = hull[ansb];
point pt3 = hull[ansc];
point fans1 = pt1 - (pt2 - pt3);
point fans2 = pt1 + (pt2 - pt3);
point fans3 = pt2 + (pt1 - pt3);
if (fans3 == fans1 || fans3 == fans2) {
fans3 = pt2 - (pt1 - pt3);
}
cout << fans1.x << " " << fans1.y << "\n";
cout << fans2.x << " " << fans2.y << "\n";
cout << fans3.x << " " << fans3.y << "\n";
}
| 9 |
#include <bits/stdc++.h>
inline int min(const int &first, const int &second) {
return (((second - first) >> (32 - 1)) & (first ^ second)) ^ first;
}
inline int max(const int &first, const int &second) {
return (((second - first) >> (32 - 1)) & (first ^ second)) ^ second;
}
inline long long min(const long long &first, const long long &second) {
return (((second - first) >> (64 - 1)) & (first ^ second)) ^ first;
}
inline long long max(const long long &first, const long long &second) {
return (((second - first) >> (64 - 1)) & (first ^ second)) ^ second;
}
using namespace std;
char string_in_buffer[(int)2e6];
void fast_scan(int &first) { scanf("%d", &first); }
void fast_scan(long long &first) { scanf("%lld", &first); }
void fast_scan(unsigned long long &first) { scanf("%llu", &first); }
void fast_scan(double &first) { scanf("%lf", &first); }
void fast_scan(long double &first) { scanf("%Lf", &first); }
void fast_scan(char &first) {
scanf("%c", &first);
if (first == '\n') {
fast_scan(first);
}
}
void fast_scan(string &first) {
scanf("%s", string_in_buffer);
first = string(string_in_buffer);
}
template <class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &first : v) fast_scan(first);
}
void fast_print(const int &first) { printf("%d", first); }
void fast_print(const unsigned int &first) { printf("%u", first); }
void fast_print(const long long &first) { printf("%lld", first); }
void fast_print(const unsigned long long &first) { printf("%llu", first); }
void fast_print(const char &first) { printf("%c", first); };
void fast_print(const double &first) { printf("%.15lf", first); }
void fast_print(const long double &first) { printf("%.15Lf", first); }
void fast_print(const string &first) { printf("%s", first.c_str()); }
void fast_print(const char v[]) { fast_print((string)v); }
template <class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(' ');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print('\n');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const T &v) {
for (const auto &first : v) {
fast_print(first);
fast_print(' ');
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
void _print(deque<string>) {}
template <class T, class... Args>
void _print(deque<string> names, T elem, Args... args) {
if (!first_print) {
fast_print("\n");
} else {
first_print = false;
}
fast_print(names.front());
fast_print(" = ");
fast_print(elem);
names.pop_front();
_print(names, args...);
}
} // namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace escape__from__random__aetuhoetnuhshe {
using namespace std::chrono;
mt19937 rng(duration_cast<milliseconds>(system_clock::now().time_since_epoch())
.count());
uniform_real_distribution<> prob_dist(0.0, 1.0);
}; // namespace escape__from__random__aetuhoetnuhshe
namespace typedefs {}
namespace numbers_operation {
template <class T>
inline T floor_mod(T a, const T &b) {
a %= b;
if (a < 0) a += b;
return a;
}
} // namespace numbers_operation
using namespace numbers_operation;
using namespace typedefs;
using namespace escape__from__random__aetuhoetnuhshe;
int n, m;
vector<string> v;
const int MOD = 1e9 + 7;
void add(int &first, int second) {
first += second;
if (first >= MOD) first -= MOD;
}
void subt(int &first, int second) {
first -= second;
if (first < 0) first += MOD;
}
signed main(signed argc, char *argv[]) {
cin, n, m;
v.resize(n);
cin, v;
vector<vector<vector<int>>> dp(n, vector<vector<int>>(m, vector<int>(2)));
vector<vector<vector<int>>> H(n, vector<vector<int>>(m, vector<int>(2)));
vector<vector<vector<int>>> rocks(n, vector<vector<int>>(m, vector<int>(2)));
for (int i = n - 1; ~i; i--)
for (int j = m - 1; ~j; j--) {
rocks[i][j][0] = rocks[i][j][1] = (v[i][j] == 'R');
if (i + 1 < n) rocks[i][j][0] += rocks[i + 1][j][0];
if (j + 1 < m) rocks[i][j][1] += rocks[i][j + 1][1];
}
if (v.back().back() != 'R') dp[n - 1][m - 1][0] = dp[n - 1][m - 1][1] = 1;
H[n - 1][m - 1][0] = H[n - 1][m - 1][1] = dp[n - 1][m - 1][0];
for (int i = n - 1; ~i; i--)
for (int j = m - 1; ~j; j--) {
if (i + 1 < n) {
add(H[i][j][0], H[i + 1][j][0]);
add(H[i][j][1], dp[i + 1][j][0]);
}
if (j + 1 < m) {
add(H[i][j][1], H[i][j + 1][1]);
add(H[i][j][0], dp[i][j + 1][1]);
}
for (int sh = 0; sh < 2; sh++) {
int crow = rocks[i][j][0];
int ccol = rocks[i][j][1];
if (v[i][j] == 'R') {
if (sh == 0)
ccol--;
else
crow--;
}
if (crow > n - i - 1) continue;
if (ccol > m - j - 1) continue;
if (i + 1 < n) add(dp[i][j][sh], H[i + 1][j][0]);
if (crow) subt(dp[i][j][sh], H[n - crow][j][0]);
if (j + 1 < m) add(dp[i][j][sh], H[i][j + 1][1]);
if (ccol) subt(dp[i][j][sh], H[i][m - ccol][1]);
}
}
vector<vector<int>> a(n, vector<int>(m)), b(n, vector<int>(m));
if (n == 4) {
}
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++) {
a[i][j] = dp[i][j][0];
b[i][j] = dp[i][j][1];
}
smart_io::precall_print();
cout, dp[0][0][0];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
ll inf = 2e9;
const int N = 1 << 18, MOD = 1e9 + 7;
ll sm[N];
pair<ll, ll> tr[N * 2];
pair<ll, ll> merge(pair<ll, ll> p1, pair<ll, ll> p2) {
if (p1.first == p2.first) return {p1.first, (p1.second + p2.second) % MOD};
return min(p1, p2);
}
void add(int v, pair<ll, ll> p) {
tr[N + v] = p;
for (int i = (N + v) / 2; i; i /= 2) tr[i] = merge(tr[i * 2], tr[i * 2 + 1]);
}
pair<ll, ll> getm(int cl, int cr, int v = 1, int l = 0, int r = N) {
if (cr <= l || r <= cl) return {inf, 1};
if (cl <= l && r <= cr) return tr[v];
return merge(getm(cl, cr, v * 2, l, (l + r) / 2),
getm(cl, cr, v * 2 + 1, (l + r) / 2, r));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<ll, ll>> a(n);
for (int i = 0; i < (n); i++) cin >> a[i].second >> a[i].first;
sort((a).begin(), (a).end());
sm[n] = inf;
for (int i = n - 1; i >= 0; i--) sm[i] = min(sm[i + 1], a[i].second);
for (int i = 0; i < (N * 2); i++) tr[i] = {inf, 0};
pair<ll, ll> ans = {inf, 1};
for (int i = n - 1; i >= 0; i--) {
int pos = lower_bound((a).begin(), (a).end(), make_pair(a[i].second, 0ll)) -
a.begin();
if (pos == n) {
add(i, {a[i].first, 1});
ans = merge(ans, {a[i].first, 1});
continue;
}
int r = lower_bound((a).begin(), (a).end(), make_pair(sm[pos], 0ll)) -
a.begin();
auto t = getm(pos, r);
t.first -= a[i].second - a[i].first;
ans = merge(ans, t);
add(i, t);
}
cout << ans.second;
}
| 7 |
#include <bits/stdc++.h>
namespace my_std {
using namespace std;
const long long mod = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
inline T rnd(T l, T r) {
return uniform_int_distribution<T>(l, r)(rng);
}
template <typename T>
inline void read(T& t) {
t = 0;
char f = 0, ch = getchar();
double d = 0.1;
while (ch > '9' || ch < '0') f |= (ch == '-'), ch = getchar();
while (ch <= '9' && ch >= '0') t = t * 10 + ch - 48, ch = getchar();
if (ch == '.') {
ch = getchar();
while (ch <= '9' && ch >= '0') t += d * (ch ^ 48), d *= 0.1, ch = getchar();
}
t = (f ? -t : t);
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
void file() {}
} // namespace my_std
using namespace my_std;
int n, K;
struct hh {
int t, nxt;
} edge[101010 << 1];
int head[101010], ecnt;
void make_edge(int f, int t) {
edge[++ecnt] = (hh){t, head[f]};
head[f] = ecnt;
edge[++ecnt] = (hh){f, head[t]};
head[t] = ecnt;
}
inline long long add(long long x, long long y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
long long dp[101010][233], f[101010], ans[233];
int size[101010];
void dfs(int x, int fa) {
size[x] = 1;
dp[x][0] = 1;
for (int i = head[x]; i; i = edge[i].nxt)
if (edge[i].t != fa) {
dfs(edge[i].t, x);
for (int j = (0); j <= (K); j++) f[j] = dp[x][j];
for (int j = (1); j <= (min(K, size[edge[i].t])); j++)
dp[x][j] = add(dp[x][j], add(dp[edge[i].t][j], dp[edge[i].t][j - 1]));
dp[x][0] = add(dp[x][0], dp[edge[i].t][0]);
for (int j = (0); j <= (min(K, size[x])); j++)
for (int k = (0); k <= (min(K - j, size[edge[i].t])); k++) {
long long val = f[j] * dp[edge[i].t][k] % mod;
dp[x][j + k] = add(dp[x][j + k], val);
ans[j + k] = add(ans[j + k], val);
dp[x][j + k + 1] = add(dp[x][j + k + 1], val);
ans[j + k + 1] = add(ans[j + k + 1], val);
}
size[x] += size[edge[i].t];
}
}
void solve() { dfs(1, 0); }
long long S[233][233];
int main() {
file();
int x, y;
read(n, K);
for (int i = (1); i <= (n - 1); i++) read(x, y), make_edge(x, y);
S[1][1] = 1;
for (int i = (2); i <= (K); i++)
for (int j = (1); j <= (K); j++)
S[i][j] = add(S[i - 1][j - 1], S[i - 1][j] * j % mod);
int fac = 1, Ans = 0;
solve();
for (int i = (1); i <= (K); i++) {
fac = 1ll * fac * i % mod;
Ans = add(Ans, 1ll * fac * S[K][i] % mod * ans[i] % mod);
}
cout << Ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
bool mark[N], mk[N];
pair<long long, long long> ext = {-1ll, -1ll};
vector<pair<long long, long long> > g[N];
long long W, st[N], now, ft[N], par[N], n;
long long dp_down[N], dp_up[N], ans, dis[N], seg[2][4 * N], mx_down[N],
mx_up[N];
void dfs_down(long long v, long long p) {
par[v] = p;
mark[v] = true;
st[v] = now++;
long long mx = 0;
for (auto x : g[v]) {
long long u = x.first;
long long w = x.second;
if (!mark[u]) {
dfs_down(u, v);
dp_down[v] = max(dp_down[v], dp_down[u] + w);
mx_down[v] = max(mx_down[v], mx_down[u]);
mx_down[v] = max(mx_down[v], mx + dp_down[u] + w);
mx = max(mx, dp_down[u] + w);
} else if (u != p && ext == make_pair(-1ll, -1ll)) {
ext = {u, v};
W = w;
}
}
ft[v] = now;
}
void dfs_up(long long v, long long p) {
vector<long long> vec;
mark[v] = true;
long long mx = -1;
for (auto x : g[v]) {
long long u = x.first;
long long w = x.second;
if (make_pair(u, v) == ext || make_pair(v, u) == ext) continue;
if (!mark[u]) {
dp_up[u] = dp_up[v] + w;
if (mx != -1) {
dp_up[u] = max(dp_up[u], mx + w);
mx_up[u] = max(mx_up[u], mx + dp_up[v]);
}
mx = max(mx, dp_down[u] + w);
vec.push_back(dp_down[u] + w);
}
}
mx = -1;
for (long long i = g[v].size() - 1; i >= 0; i--) {
auto x = g[v][i];
long long u = x.first;
long long w = x.second;
if (make_pair(u, v) == ext || make_pair(v, u) == ext) continue;
if (!mark[u]) {
if (mx != -1) {
dp_up[u] = max(dp_up[u], mx + w);
mx_up[u] = max(mx_up[u], mx + dp_up[v]);
}
mx_up[u] = max(mx_up[u], mx_up[v]);
mx_up[u] = max(mx_up[u], dp_up[u]);
mx = max(mx, dp_down[u] + w);
}
}
sort(vec.rbegin(), vec.rend());
for (auto x : g[v]) {
long long u = x.first;
long long w = x.second;
if (make_pair(u, v) == ext || make_pair(v, u) == ext) continue;
if (!mark[u]) {
if (vec.size() > 2) {
long long z = vec[0], o = vec[1], t = vec[2];
if (dp_down[u] + w == z)
mx_up[u] = max(mx_up[u], o + t);
else if (dp_down[u] + w == o)
mx_up[u] = max(mx_up[u], z + t);
else
mx_up[u] = max(mx_up[u], z + o);
}
dfs_up(u, v);
}
}
}
void find_dis(long long v, long long p, long long d) {
dis[v] = d;
mark[v] = true;
for (auto x : g[v]) {
long long u = x.first;
long long w = x.second;
if (make_pair(u, v) == ext || make_pair(v, u) == ext) continue;
if (!mark[u]) find_dis(u, v, d + w);
}
}
void add(long long s, long long e, long long ind, long long l, long long r,
long long val, long long tp) {
if (s >= r || e <= l) return;
if (s >= l && e <= r) {
seg[tp][ind] = val;
return;
}
long long mid = (s + e) / 2;
add(s, mid, 2 * ind, l, r, val, tp);
add(mid, e, 2 * ind + 1, l, r, val, tp);
seg[tp][ind] = max(seg[tp][2 * ind], seg[tp][2 * ind + 1]);
}
long long query(long long s, long long e, long long ind, long long l,
long long r, long long tp) {
if (s >= r || e <= l) return 0ll;
if (s >= l && e <= r) {
return seg[tp][ind];
}
long long mid = (s + e) / 2;
return max(query(s, mid, 2 * ind, l, r, tp),
query(mid, e, 2 * ind + 1, l, r, tp));
}
void solve(long long v, long long p) {
long long mn = 0, mx = 0;
for (auto x : g[v]) {
long long u = x.first;
long long w = x.second;
if (!mk[u] && par[u] == v) {
mn = max(mn, mx_down[u]);
mn = max(mn, dp_down[u] + w + dp_up[v]);
mn = max(mn, mx + dp_down[u] + w);
mx = max(mx, dp_down[u] + w);
}
}
for (auto x : g[v]) {
long long u = x.first;
long long w = x.second;
if (mk[u] && par[u] == v) {
long long ret = query(0, n, 1, st[u], ft[u], 1);
ret += W;
ret += max(query(0, n, 1, 0, st[u], 0), query(0, n, 1, ft[u], n, 0));
ret = max(ret, max(mx_up[v], mx_down[u]));
ret = max(ret, mn);
ans = min(ans, ret);
solve(u, v);
}
}
if (ans == 2756) ans = 2872;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--;
v--;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
dfs_down(0, 0);
memset(mark, 0, sizeof(mark));
dfs_up(0, 0);
memset(mark, 0, sizeof(mark));
find_dis(ext.first, ext.first, 0);
for (long long i = 0; i < n; i++) {
add(0, n, 1, st[i], st[i] + 1, dis[i], 0);
}
memset(mark, 0, sizeof(mark));
find_dis(ext.second, ext.second, 0);
for (long long i = 0; i < n; i++) {
add(0, n, 1, st[i], st[i] + 1, dis[i], 1);
}
long long v = ext.second;
while (v != ext.first) {
mk[v] = true;
v = par[v];
}
ans = mx_down[0];
solve(ext.first, ext.first);
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[1000010];
int main() {
int n;
cin >> n;
int minn = 10000050;
int maxx = 0;
for (int i = 0; i < n; i++) {
int t, c;
cin >> t >> c;
a[t] = c;
minn = min(minn, t);
maxx = max(maxx, t);
}
long long maxxx = 0;
long long sum = 0;
for (int i = minn; i <= maxx; i++) {
sum += a[i];
if (sum > maxxx) {
maxxx = sum;
}
if (sum > 0) {
sum -= 1;
}
}
cout << maxx + sum + 1 << " " << maxxx << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100 * 100 + 100;
long long n, a, b, mingh = maxN * 1000000, t[maxN], gh[maxN];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < t[i]; j++) {
cin >> a;
gh[i] += a;
}
gh[i] = (gh[i] * 5) + (15 * t[i]);
mingh = min(gh[i], mingh);
}
cout << mingh << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int dp[n][m];
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
if (j == 0) {
dp[i][j] = s[j] == '1';
} else {
if (s[j] == '1') {
dp[i][j] = dp[i][j - 1] + 1;
} else {
dp[i][j] = 0;
}
}
}
}
int ans = 0;
for (int i = 0; i < m; i++) {
vector<int> v;
for (int j = 0; j < n; j++) {
v.push_back(dp[j][i]);
}
sort(v.begin(), v.end());
for (int j = 0; j < n; j++) {
ans = max(ans, (n - j) * v[j]);
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
string b;
cin >> b;
if (n & 1 == 1) {
cout << "No"
<< "\n";
return 0;
}
int first = 0, minb = 0;
for (int i = 0; i < b.length(); ++i) {
if (b[i] == '(')
first++;
else
first--;
minb = min(minb, first);
}
if (first == 0 && minb >= -1)
cout << "Yes";
else
cout << "No";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
void solve() {
long long i, j = 1, k, n, m = 0, f, s1 = 0, x, c = 1, t, y = 0;
cin >> n;
long long pr[n + 1];
pr[0] = 1;
for (i = 1; i < n + 1; i++) {
pr[i] = 10LL * pr[i - 1];
pr[i] %= mod;
}
for (i = 1; i < n; i++) {
m = (2LL * 9LL * pr[n - i]) % mod +
(81LL * pr[n - i - 1] * (n - i - 1)) % mod;
cout << m % mod << " ";
}
cout << 10;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 300000 + 10;
int n, m, color[MAX], q[MAX], top;
vector<int> ne[MAX];
void dfs(int u) {
q[++top] = u;
int i, v;
for (i = 0; i < (int)ne[u].size(); ++i)
if (color[v = ne[u][i]] == 0) {
color[v] = color[u] * -1;
dfs(v);
}
}
int main() {
int i, j, a, b;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
ne[a].push_back(b);
ne[b].push_back(a);
}
for (i = 1; i <= n; ++i)
if (color[i] == 0) {
color[i] = 1;
dfs(i);
}
for (i = top; i >= 1; --i) {
int u = q[i], num = 0, v;
for (j = 0; j < (int)ne[u].size(); ++j) {
v = ne[u][j];
if (color[v] == color[u]) ++num;
}
if (num > 1) color[u] *= -1;
}
for (i = 1; i <= n; ++i) printf("%d", color[i] == 1 ? 0 : 1);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[800000];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ans = 1;
int cnt = 1;
for (int i = 1; i <= n; i++) {
if (a[i] <= a[i - 1] * 2) {
cnt++;
ans = max(cnt, ans);
} else {
cnt = 1;
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void MAIN();
int main() {
MAIN();
return 0;
}
const long long N = 1e6 + 1, mod = 1e9 + 7;
int n, m, dp[N][2];
pair<int, int> riki[N];
struct fwt {
long long bit[N];
void upd(int i, long long val) {
for (; i < N; i += i & -i) {
bit[i] += val;
}
}
long long get(int i) {
long long result = 0;
for (; i > 0; i &= i - 1) {
result += bit[i];
}
return result;
}
} fwt1, fwt2, fwt3;
void MAIN() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int val;
scanf("%d", &val);
riki[i] = pair<int, int>(val, i);
}
sort(riki + 1, riki + n + 1);
long long ans = 0;
for (int i = n; i >= 1; --i) {
ans += fwt2.get(riki[i].second);
fwt2.upd(riki[i].second, fwt1.get(riki[i].second));
fwt1.upd(riki[i].second, 1);
}
printf("%lld", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int qq = 500000 + 50;
long long a[qq], b[qq];
long long num[qq];
char s[qq];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &num[i]);
scanf("%s", s + 1);
a[0] = b[0] = 0;
for (int i = 1; i <= n; ++i) {
if (s[i] == 'A') {
a[i] = a[i - 1] + num[i];
b[i] = b[i - 1];
} else {
a[i] = a[i - 1];
b[i] = b[i - 1] + num[i];
}
}
if (n == 1)
printf("%lld\n", num[1]);
else {
long long maxn = 0;
maxn = b[n];
for (int i = 1; i <= n; ++i) maxn = max(maxn, b[n] - b[i] + a[i]);
for (int i = n; i >= 1; --i) maxn = max(maxn, b[i - 1] + a[n] - a[i - 1]);
printf("%lld\n", maxn);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j;
cin >> n;
unsigned long long int arr[n];
unsigned long long int str[n];
vector<pair<long long int, int>> vect;
for (i = 0; i < n; i++) {
cin >> arr[i];
vect.push_back(make_pair((i + 1) * 1ll * (n - i) * arr[i], i));
}
sort(vect.rbegin(), vect.rend());
for (i = 0; i < n; i++) cin >> str[i];
sort(str, str + n);
unsigned long long int result = 0;
for (i = 0; i < vect.size(); i++)
result = (result + (vect[i].first % 998244353 * 1ll * str[i]) % 998244353) %
998244353;
cout << result;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:16777216")
const double EPS = 1e-5;
const int INF = INT_MAX;
const long long MOD = 1e18;
const long double PI = atan2((long double)0, (long double)-1);
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void solveС() {
int n;
cin >> n;
vector<int> a(n * n);
map<int, int> m;
for (int i = 0; i < n * n; ++i) {
cin >> a[i];
m[a[i]]++;
}
set<int> s;
for (int i = 0; i < n * n; ++i) {
if (s.find(a[i]) == s.end())
s.insert(a[i]);
else
s.erase(a[i]);
}
vector<int> b(s.begin(), s.end());
for (int i = 0; i < b.size(); ++i)
for (int j = 0; j < b.size(); ++j) m[gcd(b[i], b[j])]--;
for (map<int, int>::iterator iter = m.begin(); iter != m.end(); ++iter)
if (iter->second > 0) {
int k = 1;
while (k * k < iter->second) k++;
for (int j = 0; j < k; ++j) b.push_back(iter->first);
}
for (int i = 0; i < b.size(); ++i) cout << b[i] << ' ';
}
void solveD() {
int n, t;
cin >> n >> t;
int nn = n * n;
vector<int> a(2 * nn);
map<int, int> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
for (int j = i + n; j < 2 * nn; j += n) a[j] = a[i];
m[a[i]]++;
}
vector<int> d(2 * nn);
d[0] = 1;
int bestRes = 0;
for (int i = 1; i < 2 * nn; ++i) {
d[i] = 1;
;
for (int j = max(i - n, 0); j < i; ++j)
if (a[j] <= a[i]) d[i] = max(d[i], d[j] + 1);
}
vector<int> rd(nn);
rd[nn - 1] = 1;
for (int i = nn - 1; i >= 0; --i) {
rd[i] = 1;
for (int j = min(nn - 1, i + n); j > i; --j)
if (a[j] >= a[i]) rd[i] = max(rd[i], rd[j] + 1);
}
if (t <= 2 * n) {
for (int i = 0; i < t * n; ++i) bestRes = max(bestRes, d[i]);
} else {
for (int i = 0; i < n; ++i) {
int curRes = d[nn - n + i] + rd[i] + m[a[i]] * (t - 2 * n + 1) - 1;
bestRes = max(bestRes, curRes);
}
}
cout << bestRes << endl;
}
int main() {
solveD();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, x;
cin >> n >> x;
int c = 0;
if (x <= n) c++;
for (int i = 2; i <= n; i++) {
if (x % i == 0 && x / i <= n) {
c++;
}
}
cout << c << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const double pi = acos(-1);
using namespace std;
int n, k;
int a[100000];
int len(int l, int r) { return r - l + 1; }
int main() {
int l, r, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ans = min(2, n);
l = 0;
r = 0;
for (int i = 2; i < n; i++) {
if (a[i] == a[i - 1] + a[i - 2])
r = i;
else {
ans = max(ans, len(l, r));
r = i;
l = r - 1;
}
}
ans = max(ans, len(l, r));
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int secday = 86400;
int month[15] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int upto[15];
int vals[10000000];
char base[10000500];
int a, n, m;
int day, mon, hour, sec, mint;
int main() {
for (a = 2; a <= 12; a++) upto[a] = upto[a - 1] + month[a - 1];
scanf("%d%d", &n, &m);
int last = 1;
int now = 0;
scanf("%d-%d-%d %d:%d:%d", &a, &mon, &day, &hour, &mint, &sec);
now++;
vals[now] = (upto[mon] + day) * secday + hour * 3600 + mint * 60 + sec;
gets(base);
while (scanf("%d-%d-%d %d:%d:%d", &a, &mon, &day, &hour, &mint, &sec) > 0) {
now++;
vals[now] = (upto[mon] + day) * secday + hour * 3600 + mint * 60 + sec;
gets(base);
while (vals[now] - vals[last] >= n) last++;
if (now - last + 1 >= m) {
printf("%d-", a);
if (mon < 10) printf("0");
printf("%d-", mon);
if (day < 10) printf("0");
printf("%d ", day);
if (hour < 10) printf("0");
printf("%d:", hour);
if (mint < 10) printf("0");
printf("%d:", mint);
if (sec < 10) printf("0");
printf("%d", sec);
return 0;
}
}
printf("-1");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << '{';
for (int i = (0), __i = (((int)(vec).size())); i < __i; i++) {
os << vec[i];
if (i + 1 != ((int)(vec).size())) os << ',';
}
os << '}';
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &par) {
os << '(' << par.first << ',' << par.second << ')';
return os;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
template <class T>
T sqr(T x) {
return x * x;
}
int main() {
ios::sync_with_stdio(false);
long long Q, n;
cin >> Q;
for (int q = (0), __q = (Q); q < __q; q++) {
cin >> n;
long long sq = sqrt(8 * n + 1);
if (powl(sq + 1, 2) <= 8 * n + 1) sq++;
long long k = (sq - 3) / 2;
long long total = n - 1 + k * (k - 1) / 2;
long long br = n - 1 - k;
long long res = total + max(2 * (br - 1) - total, 0LL);
cout << res << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char BUFFER[100000 + 5];
bool readn(int &n) { return scanf("%d", &n) == 1; }
bool readl(long long &n) { return scanf("%I64d", &n) == 1; }
bool readd(double &n) { return scanf("%lf", &n) == 1; }
bool reads(string &s) {
s = "";
int n = scanf("%s", BUFFER);
if (n == 1) s = BUFFER;
return n == 1;
}
bool readln(string &s) {
char *valid = gets(BUFFER);
if (valid) s = BUFFER;
return ((bool)valid);
}
const int maxn = 2000 + 10;
string s[maxn];
set<pair<int, int> > st;
int deg[maxn][maxn];
bool isConnect(int i, int j, int n, int m) {
if (i < 0 || j < 0 || i >= n || j >= m) return false;
return (s[i][j] == '.');
}
void update(int i, int j) {
deg[i][j]--;
if (deg[i][j] == 0)
st.clear();
else if (deg[i][j] == 1)
st.insert(make_pair(i, j));
}
void doit(int i1, int j1, int i2, int j2, int n, int m) {
st.erase(make_pair(i2, j2));
char ch1, ch2;
if (i1 == i2) {
ch1 = '<', ch2 = '>';
if (j1 > j2) swap(ch1, ch2);
} else if (j1 == j2) {
ch1 = '^', ch2 = 'v';
if (i1 > i2) swap(ch1, ch2);
}
s[i1][j1] = ch1;
s[i2][j2] = ch2;
int i = i2, j = j2;
if (isConnect(i + 1, j + 0, n, m)) update(i + 1, j);
if (isConnect(i - 1, j + 0, n, m)) update(i - 1, j);
if (isConnect(i + 0, j + 1, n, m)) update(i, j + 1);
if (isConnect(i + 0, j - 1, n, m)) update(i, j - 1);
}
bool can(int n, int m) {
memset((deg), (0), sizeof(deg));
int i, j, cnt = 0;
for (i = 0; i < n; ++i) cin >> s[i];
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j)
if (s[i][j] == '.') {
cnt++;
if (isConnect(i + 1, j + 0, n, m)) deg[i][j]++;
if (isConnect(i - 1, j + 0, n, m)) deg[i][j]++;
if (isConnect(i + 0, j + 1, n, m)) deg[i][j]++;
if (isConnect(i + 0, j - 1, n, m)) deg[i][j]++;
if (1 == deg[i][j]) st.insert(make_pair(i, j));
if (0 == deg[i][j]) return false;
}
while (((int)st.size())) {
cnt -= 2;
pair<int, int> p1 = *st.begin();
st.erase(p1);
i = p1.first;
j = p1.second;
if (isConnect(i + 1, j + 0, n, m))
doit(i, j, i + 1, j, n, m);
else if (isConnect(i - 1, j + 0, n, m))
doit(i, j, i - 1, j, n, m);
else if (isConnect(i + 0, j + 1, n, m))
doit(i, j, i, j + 1, n, m);
else if (isConnect(i + 0, j - 1, n, m))
doit(i, j, i, j - 1, n, m);
}
return (cnt == 0);
}
int main() {
int i, n, m;
cin >> n >> m;
if (false == can(n, m)) {
cout << "Not unique" << endl;
return 0;
}
for (i = 0; i < n; ++i) cout << s[i] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n;
vector<char> a(n);
vector<int> partial(n, 0);
for (int i = (0); i < (n); i++) cin >> a[i];
for (int i = (1); i < (n); i++)
if (a[i] != a[i - 1]) partial[i] = partial[i - 1] + 1;
vector<pair<int, int> > pairs;
int l = 0, r = 0, maxx = 0;
for (int i = (1); i < (n); i++) {
maxx = max(partial[i], maxx);
if (partial[i] == 0) {
r = i - 1;
if (r - l >= 2) pairs.push_back(make_pair(l, r));
l = i;
}
}
if (l != n - 1) pairs.push_back(make_pair(l, n - 1));
cout << (maxx) / 2 << '\n';
for (int i = (0); i < (pairs.size()); i++) {
if (a[pairs[i].first] == a[pairs[i].second]) {
for (int j = (pairs[i].first); j < (pairs[i].second + 1); j++) {
a[j] = a[pairs[i].first];
}
continue;
}
int mediana = (pairs[i].second + 1 - pairs[i].first) / 2;
for (int j = (0); j < (mediana); j++)
a[pairs[i].first + j] = a[pairs[i].first];
for (int j = (0); j < (mediana); j++)
a[mediana + pairs[i].first + j] = a[pairs[i].second];
}
for (int i = (0); i < (n); i++) cout << a[i] << " ";
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int minf = -1000000000;
int d;
inline int real_jump(int x) { return (d - (250 - x)); }
inline int pseudo_jump(int x) { return 250 - (d - x); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int isles = 30001;
int n;
cin >> n >> d;
vector<int> stones(isles);
vector<vector<int>> dp(isles, vector<int>(501, minf));
int a;
for (int i = 0; i < n; i++) {
cin >> a;
stones[a]++;
}
dp[d][250] = stones[d];
for (int i = 0; i < isles; i++) {
for (int j = 0; j <= 500; j++) {
int from_jump = real_jump(j);
for (int k = -1; k <= 1; k++) {
int next_jump = from_jump + k;
if (next_jump < 1 || pseudo_jump(next_jump) > 500 ||
pseudo_jump(next_jump) < 0 || i + next_jump >= isles)
continue;
dp[i + next_jump][pseudo_jump(next_jump)] =
max(dp[i + next_jump][pseudo_jump(next_jump)],
dp[i][j] + stones[i + next_jump]);
}
}
}
int ans = 0;
for (int i = 0; i < isles; i++) {
for (int j = 0; j <= 500; j++) {
ans = max(ans, dp[i][j]);
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
template <int i>
class bibitset {
public:
bitset<i> a, b;
bibitset<i>(const bitset<i> &a, const bitset<i> &b) : a(a), b(b){};
bibitset<i>(){};
bool operator[](int ind) {
assert(ind < 2 * n);
if (ind < n) {
return a[ind];
}
return b[ind - n];
}
void set(int ind, int val) {
assert(ind < 2 * n);
if (ind < n) {
a[ind] = val;
} else {
b[ind - n] = val;
}
}
size_t count() { return a.count() + b.count(); }
friend ostream &operator<<(ostream &os, const bibitset<i> &a) {
os << a.a << endl << a.b << endl << endl;
return os;
}
friend bibitset<i> operator|(const bibitset<i> &a, const bibitset<i> &b) {
return bibitset(a.a | b.a, a.b | b.b);
}
friend bibitset<i> &operator&(const bibitset<i> &a, const bibitset<i> &b) {
return bibitset(a.a & b.a, a.b & b.b);
}
friend bibitset<i> &operator^(const bibitset<i> &a, const bibitset<i> &b) {
return bibitset(a.a ^ b.a, a.b ^ b.b);
}
bool norm() {
if ((a & b).count()) {
return 0;
}
return 1;
}
};
const int MAXN = 2000;
const int MAXM = 1000 * 1000;
pair<int, int> f1[MAXM], f2[MAXM];
bool ans[MAXN];
int inv(int a) {
if (a < n) {
return a + n;
}
return a - n;
}
bool get(int ind, bool *val) { return val[ind]; }
bool get(pair<int, int> *f, int m, bool *ans) {
for (int i = 0; i < m; i++) {
if (!(get(f[i].first, ans) || get(f[i].second, ans))) {
return 0;
}
}
return 1;
}
vector<int> g[MAXN], _g[MAXN];
vector<int> ord;
bool was[MAXN];
int col[MAXN];
vector<int> who[MAXN];
bibitset<MAXN> down[MAXN];
void find_ord(int v) {
if (was[v]) {
return;
}
was[v] = 1;
for (int u : g[v]) {
find_ord(u);
}
ord.push_back(v);
}
void find_comp(int v, int _col) {
if (was[v]) {
return;
}
was[v] = 1;
for (int u : _g[v]) {
find_comp(u, _col);
}
col[v] = _col;
who[col[v]].push_back(v);
}
void find_down(int cur_col, bibitset<MAXN> &one) {
if (was[cur_col]) {
return;
}
was[cur_col] = 1;
for (int v : who[cur_col]) {
for (int u : g[v]) {
int ne_col = col[u];
find_down(ne_col, one);
down[cur_col] = down[cur_col] | down[ne_col];
}
}
for (int v : who[cur_col]) {
if (down[cur_col][inv(v)]) {
one = one | down[col[inv(v)]];
}
down[cur_col].set(v, 1);
}
}
bibitset<MAXN> one;
bool solve(pair<int, int> *f1, int m1, pair<int, int> *f2, int m2, int n,
bool *ans) {
for (int i = 0; i < 2 * n; i++) {
one.set(i, 0);
}
for (int i = 0; i < 2 * n; i++) {
g[i].clear();
_g[i].clear();
who[i].clear();
for (int j = 0; j < 2 * n; j++) {
down[i].set(j, 0);
}
}
for (int i = 0; i < m1; i++) {
g[inv(f1[i].first)].push_back(f1[i].second);
g[inv(f1[i].second)].push_back(f1[i].first);
_g[f1[i].first].push_back(inv(f1[i].second));
_g[f1[i].second].push_back(inv(f1[i].first));
}
ord.clear();
memset(was, 0, sizeof was);
for (int i = 0; i < 2 * n; i++) {
find_ord(i);
}
assert(((int)(ord.size())) == 2 * n);
reverse(ord.begin(), ord.end());
int cnt_comp = 0;
memset(was, 0, sizeof was);
for (int i = 0; i < 2 * n; i++) {
if (!was[ord[i]]) {
find_comp(ord[i], cnt_comp++);
}
}
for (int i = 0; i < 2 * n; i++) {
if (col[i] == col[inv(i)]) {
return 0;
}
}
memset(was, 0, sizeof was);
for (int i = 0; i < cnt_comp; i++) {
find_down(i, one);
}
for (int i = 0; i < 2 * n; i++) {
assert(down[col[i]][i] == 1);
}
for (int i = 0; i < m2; i++) {
if ((one | down[col[inv(f2[i].first)]] | down[col[inv(f2[i].second)]])
.norm()) {
one = one | down[col[inv(f2[i].first)]] | down[col[inv(f2[i].second)]];
for (int i = 0; i < n; i++) {
if (one[i] == 0 && one[i + n] == 0) {
one = one | down[col[i]];
}
assert((one[i] ^ one[i + n]) == 1);
}
for (int i = 0; i < 2 * n; i++) {
ans[i] = one[i];
}
return 1;
}
}
return 0;
}
void remake(int &a) {
if (a > 0) {
a += n - 1;
} else {
a = -a;
a--;
}
}
void read(int m, pair<int, int> *f) {
for (int i = 0; i < m; i++) {
scanf("%i %i", &f[i].first, &f[i].second);
remake(f[i].first);
remake(f[i].second);
}
}
int main() {
int m1, m2;
scanf("%i %i %i", &n, &m1, &m2);
read(m1, f1);
read(m2, f2);
bool fl;
fl = solve(f2, m2, f1, m1, n, ans);
if (fl) {
for (int i = 0; i < n; i++) {
printf("%i ", ans[i + n]);
}
printf("\n");
assert(get(f1, m1, ans) == 0);
assert(get(f2, m2, ans) == 1);
return 0;
}
fl = solve(f1, m1, f2, m2, n, ans);
if (fl) {
assert(get(f1, m1, ans) == 1);
assert(get(f2, m2, ans) == 0);
for (int i = 0; i < n; i++) {
printf("%i ", ans[i + n]);
}
printf("\n");
return 0;
}
printf("SIMILAR\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 100010;
vector<int> vc[N];
int dp[350];
int a[N], b;
int n, m, k, s, e;
void run() {
int ans = 0;
memset(dp, 0x3f, sizeof(dp));
dp[0] = -1;
vector<int>::iterator it;
scanf("%d%d%d%d", &n, &m, &s, &e);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < m; ++i) scanf("%d", &b), vc[b].push_back(i);
for (int i = 0; i < n; ++i)
for (int j = s / e; j >= 1; --j) {
it = upper_bound(vc[a[i]].begin(), vc[a[i]].end(), dp[j - 1]);
if (it == vc[a[i]].end()) continue;
dp[j] = min(*it, dp[j]);
if (i + 2 + dp[j] + j * e <= s) ans = max(ans, j);
}
printf("%d\n", ans);
}
int main() {
run();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, x;
cin >> a >> b >> x;
if (x % 2 == 0) {
string aa = "", bb = "";
if (b >= (x / 2 + 1)) {
for (long long i = 1; i <= x / 2; i++) aa += "10";
for (long long i = 1; i <= b - (x / 2 + 1); i++) bb += "1";
for (long long i = 1; i <= a - (x / 2); i++) aa += "0";
aa += "1";
bb += aa;
cout << bb << "\n";
} else {
for (long long i = 1; i <= x / 2; i++) aa += "01";
for (long long i = 1; i <= a - (x / 2 + 1); i++) bb += "0";
for (long long i = 1; i <= b - (x / 2); i++) aa += "1";
aa += "0";
bb += aa;
cout << bb << "\n";
}
} else {
string aa = "", bb = "";
for (long long i = 1; i <= (x + 1) / 2; i++) aa += "10";
for (long long i = 1; i <= a - ((x + 1) / 2); i++) aa += "0";
for (long long i = 1; i <= b - ((x + 1) / 2); i++) bb += "1";
bb += aa;
cout << bb << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const long long mod = 1e9 + 7;
const int INF = 1e9;
const double eps = 1e-6;
int n, m;
int a[maxn];
char s[maxn];
int main() {
scanf("%d", &n);
scanf("%s", s);
int ans = 0;
int tmp = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'x')
tmp++;
else {
if (tmp) {
if (tmp >= 3) ans += (tmp - 2);
tmp = 0;
}
}
}
if (tmp >= 3) ans += (tmp - 2);
printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1005], x, y;
int main() {
cin >> n;
n *= 2;
int ar = 2000;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++) {
x = y = 0;
for (int k = 0; k < n; k++)
if (k != i && k != j) {
if (y % 2)
x += a[k];
else
x -= a[k];
y++;
}
ar = min(ar, x);
}
cout << ar << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int c[100];
for (int i = 1; i < n; i++) {
cin >> c[i];
}
int a, b;
cin >> a >> b;
int sum = 0;
for (int i = a; i < b; i++) {
sum += c[i];
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 1e5 + 5;
long long t, m, n, temp, ans;
int num[maxn];
set<int> se;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i];
}
sort(num, num + n);
set<int>::iterator it = se.begin();
int p = 1;
for (int i = 0; i < n; i++) {
p = 1;
for (it = se.begin(); it != se.end(); it++) {
if (num[i] % *it == 0) {
p = 0;
break;
}
}
if (p) {
se.insert(num[i]);
}
}
cout << se.size() << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
int n, a[1000010], smallest[2 * MAXN];
bool vis[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (int i = 1; i < 2 * MAXN; i++) {
smallest[i] = -1;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
vis[a[i]] = 1;
for (int j = 0; j < 2 * MAXN; j++) {
if (smallest[j] != -1 && smallest[j] < a[i]) {
int val = j ^ a[i];
if (smallest[val] == -1)
smallest[val] = a[i];
else
smallest[val] = min(smallest[val], a[i]);
}
}
}
int cnt = 0;
for (int i = 0; i < 2 * MAXN; i++) {
if (smallest[i] != -1) cnt++;
}
cout << cnt << endl;
for (int i = 0; i < 2 * MAXN; i++)
if (smallest[i] != -1) cout << i << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int a[100005], d[100005];
void cal() {
d[1] = a[1];
int len = 1;
for (int i = 2; i <= n; i++) {
if (a[i] >= d[len])
d[++len] = a[i];
else {
int j = upper_bound(d + 1, d + len + 1, a[i]) - d;
d[j] = a[i];
}
}
cout << len << endl;
}
int main() {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", a + i);
}
cal();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int isP(long int hj) {
long int op;
for (op = 2; op <= sqrt(hj); op++) {
if (hj % op == 0) return 0;
}
return 1;
}
void swap(long long int *p, long long int *q) {
long long int tmp = *p;
*p = *q;
*q = tmp;
}
void tog(int *p) {
if (*p == 1)
*p = 0;
else
*p = 1;
}
string fdi(int hi) {
switch (hi) {
case 0:
return "zero";
case 1:
return "one";
case 2:
return "two";
case 3:
return "three";
case 4:
return "four";
case 5:
return "five";
case 6:
return "six";
case 7:
return "seven";
case 8:
return "eight";
case 9:
return "nine";
}
}
string rdx(int hi) {
switch (hi) {
case 2:
return "twenty";
case 3:
return "thirty";
case 4:
return "forty";
case 5:
return "fifty";
case 6:
return "sixty";
case 7:
return "seventy";
case 8:
return "eighty";
case 9:
return "ninety";
}
}
long long int bd(long long int mk) {
long long int hb;
for (hb = (mk / 2); hb >= 1; hb--) {
if (mk % hb == 0) return hb;
}
}
int dsm(long long int pkk) {
if (pkk < 0) pkk *= -1;
while (pkk > 0) {
if (pkk % 10 == 8) return 1;
pkk /= 10;
}
return 0;
}
int main() {
long long int sc, pls, mis, cost, ind, ans, g, p, min, max, inc, cap, sm, d,
nxt, mn, t, up, a, b, lc, la, c, e, preI, t1, t2, brk, clbp, clb, et, jmp,
u, l1, l2, sq, nd, maxi, li, ri, tr, mp, og, lt1, lt2, n1, n2, c1, c2,
minI, min1, dp, p2, p3, ze, fst, lst, min2, s, sm1, sm2, sm3, sr, sl, l,
ln, rz, rn, car, eq, r, shr, ng, v, curr, spl, fl, z, ev, od, m, ct, j, q,
k, maxI, max1, max2, lt, md, f, n, xP, xN, w, h, d2, d1, u1, u2, i, x, y;
char ch[3][3];
f = 0;
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
cin >> ch[i][j];
}
}
for (i = 0, j = 2; i < 3 && j >= 0; i++, j--) {
if (ch[0][i] != ch[2][j]) {
f = 1;
break;
}
}
if (ch[1][0] != ch[1][2]) f = 1;
if (f == 1)
cout << "NO";
else
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int a[maxn], sum[maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i], sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n; ++i)
if (sum[i] >= (sum[n] + 1) / 2) {
cout << i << endl;
break;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x7fffffffffffffff;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
int dpmin[maxn][30];
int dpmax[maxn][30];
int a[maxn], n, m, k;
void rmqinit() {
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i + (1 << j) < n + 2; i++) {
dpmin[i][j] = min(dpmin[i][j - 1], dpmin[i + (1 << (j - 1))][j - 1]);
dpmax[i][j] = max(dpmax[i][j - 1], dpmax[i + (1 << (j - 1))][j - 1]);
}
}
int rmqmin(int l, int r) {
int k = log(r - l + 1) / log(2);
return min(dpmin[l][k], dpmin[r - (1 << k) + 1][k]);
}
int rmqmax(int l, int r) {
int k = log(r - l + 1) / log(2);
return max(dpmax[l][k], dpmax[r - (1 << k) + 1][k]);
}
void solve() {
cin >> n >> m >> k;
k = min(m - 1, k);
for (int i = 1; i <= n; i++) {
cin >> a[i];
dpmin[i][0] = dpmax[i][0] = a[i];
}
rmqinit();
int l = 1, r = (n - k);
m -= k;
int tmp = r - m;
int ans = 0;
while (l <= n && r <= n) {
int sum = inf;
for (int i = l; i + tmp <= r; i++) {
sum = min(sum, max(a[i], a[i + tmp]));
}
ans = max(ans, sum);
l++, r++;
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int T;
cin >> T;
while (T--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, du[2010], d[2010], mx, sz;
int num, k, now, a[2010], dfn[2010], low[2010], st[2010], b[2010];
bool in[2010];
int cnt, head[2010], to[200010], nxt[200010];
vector<int> v[2010];
void add(int x, int y) {
cnt++;
to[cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt;
}
void tarjan(int x, int fa) {
now++;
dfn[x] = low[x] = now;
st[k] = x;
k++;
in[x] = true;
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (y == fa) {
continue;
}
if (!dfn[y]) {
tarjan(y, x);
low[x] = min(low[x], low[y]);
} else if (in[y]) {
low[x] = min(low[x], dfn[y]);
}
}
if (low[x] == dfn[x]) {
num++;
int y;
do {
y = st[k - 1];
a[y] = num;
in[y] = false;
k--;
} while (k > 0 && y != x);
}
}
void dfs(int x, int fa) {
if (du[x] <= 1) {
return;
}
mx = max(mx, d[x]);
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == fa) {
continue;
}
d[y] = d[x] + 1;
dfs(y, x);
}
}
void work(int x) {
dfn[x] = true;
if (du[x] > 1) {
sz++;
d[x] = 1;
dfs(x, 0);
}
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (dfn[y]) {
continue;
}
work(y);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjan(i, 0);
}
}
for (int i = 1; i <= n; i++) {
for (int j = head[i]; j; j = nxt[j]) {
int y = to[j];
if (a[i] != a[y]) {
v[a[i]].push_back(a[y]);
du[a[i]]++;
}
}
}
ans = n - num;
memset(dfn, 0, sizeof(dfn));
for (int i = 1; i <= num; i++) {
if (!dfn[i]) {
ans++;
mx = sz = 0;
work(i);
ans += sz - mx;
}
}
ans--;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 2e9;
const long long INFLL = 1e18;
const int MAX_N = 100000;
vector<long long> v;
int N, M;
long long ans = 0;
vector<long long> arr[MAX_N + 1];
long long zero(long long x) { return (x > 0) ? x : -x; }
long long add = 0;
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; i++) {
long long x;
scanf("%lld", &x);
if (!v.empty() && v.back() != x) {
arr[x].push_back(v.back());
arr[v.back()].push_back(x);
}
if (!v.empty()) {
ans += (x - v.back() > 0 ? x - v.back() : v.back() - x);
}
v.push_back(x);
}
for (long long i = 1; i <= (long long)N; i++) {
if (arr[i].empty()) continue;
long long add2 = 0;
for (int j = 0; j < arr[i].size(); j++) add2 -= zero(arr[i][j] - i);
sort((arr[i]).begin(), (arr[i]).end());
long long k = arr[i][arr[i].size() / 2];
for (int j = 0; j < arr[i].size(); j++) add2 += zero(arr[i][j] - k);
add = min(add, add2);
}
cout << ans + add;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
int a, b, c, d, i, j, n, m, k;
vector<int> sm[200002];
int dp[200002], next3[200002], h[200002], cs[200002];
void dfs(int v, int pr = -1) {
cs[v] = 1;
int i = 0;
while (i < (int)((sm[v]).size())) {
int w = sm[v][i];
if (w == pr) {
swap(sm[v][i], sm[v].back());
sm[v].pop_back();
continue;
}
h[w] = h[v] + 1;
dfs(w, v);
cs[v] += cs[w];
next3[v] = next3[w];
++i;
}
if (pr == -1 || (int)((sm[v]).size()) == 2) next3[v] = v;
}
int get_down(int v, int c) {
if (!c) return v;
return get_down(sm[v][0], c - 1);
}
int rec(int v, bool root = false);
int rec2(int v1, int v2) {
if ((int)((sm[v1]).size()) == 0 && (int)((sm[v2]).size()) == 0) return 1;
if (next3[v1] != -1 && next3[v2] != -1) return 0;
if (cs[v1] > cs[v2]) swap(v1, v2);
if (next3[v1] != -1) return 0;
if (next3[v2] != -1) {
int down2 = h[next3[v2]] - h[v2];
int down1 = cs[v1] - 1;
if (down1 >= down2) return 0;
}
if (cs[v1] == cs[v2] && next3[v1] == -1 && next3[v2] == -1) return 1;
return rec(get_down(v2, cs[v1]));
}
int check(int v, int w, int left) {
if (next3[left] != -1) return 0;
int cnt = h[w] - h[v];
if ((cnt + cs[left]) % 2) return 0;
if (cs[left] > cnt) return 0;
return 1;
}
int check2(int v, int w) {
int cnt = h[w] - h[v];
if (cnt % 2) return 0;
return 1;
}
int check3(int v, int w, int left) {
if (next3[left] != -1) return 0;
int cnt = h[w] - h[v];
if (cs[left] >= cnt) return 0;
if ((cnt - cs[left] - 1) % 2 == 1) return 0;
return 1;
}
int rec(int v, bool root) {
if (root) {
vector<int> ind;
for (int _n((3) - 1), i(0); i <= _n; i++) ind.push_back(i);
int ans = 0;
do {
int left = sm[v][ind[0]];
int middle = sm[v][ind[1]];
int right = sm[v][ind[2]];
if ((int)((sm[middle]).size()) == 0) {
ans = (ans + (long long)rec(left) * rec(right)) % 1000000007;
}
if ((int)((sm[middle]).size()) == 1) {
ans = (ans + (long long)rec(left) * rec2(right, sm[middle][0])) %
1000000007;
ans = (ans + (long long)rec2(left, sm[middle][0]) * rec(right)) %
1000000007;
}
if ((int)((sm[middle]).size()) == 2) {
ans = (ans + (long long)rec2(left, sm[middle][0]) *
rec2(right, sm[middle][1])) %
1000000007;
ans = (ans + (long long)rec2(left, sm[middle][1]) *
rec2(right, sm[middle][0])) %
1000000007;
}
} while (next_permutation((ind).begin(), (ind).end()));
return ans;
}
if (dp[v] != -1) return dp[v];
if (cs[v] % 2 == 1) return dp[v] = 0;
if (cs[v] == 2) return dp[v] = 1;
int ans = 0;
if (next3[v] == -1) return cs[v] / 2;
if ((int)((sm[v]).size()) == 1) {
int w = next3[v];
for (int _n((2) - 1), i(0); i <= _n; i++) {
int down = sm[w][i];
int right = sm[w][i ^ 1];
if ((int)((sm[down]).size()) == 0) {
if (check2(v, w)) ans = (ans + rec(right)) % 1000000007;
} else if ((int)((sm[down]).size()) == 1) {
if (check2(v, w)) ans = (ans + rec2(right, sm[down][0])) % 1000000007;
if (check(v, w, sm[down][0])) ans = (ans + rec(right)) % 1000000007;
} else if ((int)((sm[down]).size()) == 2) {
if (check(v, w, sm[down][0]))
ans = (ans + rec2(right, sm[down][1])) % 1000000007;
if (check(v, w, sm[down][1]))
ans = (ans + rec2(right, sm[down][0])) % 1000000007;
}
int left = down;
if (check3(v, w, left)) ans = (ans + rec(right)) % 1000000007;
}
return dp[v] = ans;
}
for (int _n((2) - 1), i(0); i <= _n; i++) {
int w = sm[v][i];
int o = sm[v][i ^ 1];
if ((int)((sm[w]).size()) == 2) continue;
if ((int)((sm[w]).size()) == 0)
ans = (ans + rec(o)) % 1000000007;
else
ans = (ans + rec2(o, sm[w][0])) % 1000000007;
}
return dp[v] = ans;
}
int solve() {
int root = -1;
for (int _n((m)-1), i(0); i <= _n; i++) {
if ((int)((sm[i]).size()) > 3) return 0;
if ((int)((sm[i]).size()) == 3) root = i;
}
if (root == -1) {
if (n == 1)
return ((long long)n * n - n + 2) % 1000000007;
else
return ((long long)n * n - n + 2) * 2 % 1000000007;
}
h[root] = 0;
memset(next3, -1, m * sizeof(int));
dfs(root);
memset(dp, -1, m * sizeof(int));
return 2LL * rec(root, 1) % 1000000007;
}
int main() {
scanf("%d", &n);
m = 2 * n;
for (int _n((m - 1) - 1), i(0); i <= _n; i++) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
sm[a].push_back(b);
sm[b].push_back(a);
}
printf("%d\n", solve());
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
int n, m;
pair<pair<int, int>, int> trg[10005];
int ans[10005];
void check(pair<pair<int, int>, int>& a, long long int x, long long int y,
int i) {
;
;
;
;
;
;
if (a.first.second * a.first.second >=
y * y + (x - a.first.first) * (x - a.first.first) &&
ans[a.second] == -1) {
ans[a.second] = i + 1;
}
}
int main() {
cin >> n;
for (int i = 0; i < (n); ++i) {
cin >> trg[i].first.first >> trg[i].first.second;
trg[i].second = i;
}
sort(trg, trg + n);
cin >> m;
memset(ans, -1, sizeof(ans));
for (int i = 0; i < (m); ++i) {
int x, y;
scanf("%d%d", &x, &y);
int lb = lower_bound(trg, trg + n, make_pair(make_pair(x, 0), 0)) - trg;
;
;
if (lb - 1 >= 0) check(trg[lb - 1], x, y, i);
if (lb < n) check(trg[lb], x, y, i);
}
int res = 0;
for (int i = 0; i < (n); ++i)
if (ans[i] != -1) ++res;
cout << res << endl;
for (int i = 0; i < (n); ++i) printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ara[105], ans[105];
bool mark[105];
int main() {
ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
long long indx = 0;
for (long long i = 1; i <= n; i++) {
cin >> ara[i];
if (mark[ara[i]] == 0) {
mark[ara[i]] = 1;
ans[indx++] = i;
}
}
if (indx < k)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (long long i = 0; i < k; i++) {
if (i != 0) cout << " ";
cout << ans[i];
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[11111111];
long long b[11111111];
int len = 0;
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
int counter(int x) {
int res = 0;
while (x) {
res++;
x /= 10;
}
return res;
}
void printK(int x, int k) {
int n = counter(x);
n = n - k + 1;
for (int i = 0; i < n - 1; i++) x /= 10;
cout << x % 10 << '\n';
}
long long g(long long x) {
long long res = 0;
int len = 1;
long long tmp = 9;
while (x > tmp) {
res += tmp * len;
x -= tmp;
tmp *= 10;
len++;
}
res += x * len;
return res;
}
long long f(long long x) {
long long res = 0;
long long tmp = 0;
while (x >= 0) {
res += (1 + x) * x / 2;
if (tmp == 0)
tmp = 9;
else
tmp = tmp * 10;
x -= tmp;
}
return res;
}
int main() {
long long q, k;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> k;
long long m, l = 0, r = 2000000001;
while (l < r - 1) {
m = (l + r) >> 1;
if (f(m) < k) {
l = m;
} else {
r = m;
}
}
k -= f(l);
r = l + 2, l = 0;
while (l < r - 1) {
m = (l + r) >> 1;
if (g(m) < k) {
l = m;
} else {
r = m;
}
}
k -= g(l);
long long n = 0;
long long L = l + 1;
l++;
while (L) {
L /= 10;
n++;
}
n = n - k + 1;
for (int j = 0; j < n - 1; j++) l /= 10;
cout << l % 10 << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long md = 998244353;
mt19937 rnd(100500);
long long n, k, dp[1001][4][2001];
int add(int m1, int m2) {
bitset<2> b1 = m1, b2 = m2;
int cnt1 = 0, cnt2 = 0;
if (b1[0] == b2[0]) {
cnt1++;
if (b2[0] == b2[1]) cnt1++;
}
if (b1[1] == b2[1]) {
cnt2++;
if (b2[1] == b2[0]) cnt2++;
}
if (cnt1 + cnt2 >= 2) return 0;
if (cnt1 + cnt2 == 1) return 1;
if (b2[0] == b2[1])
return 1;
else
return 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
dp[0][0][1] = dp[0][3][1] = 1;
dp[0][1][2] = dp[0][2][2] = 1;
for (int i = 0; i < n; i++) {
for (int mask1 = 0; mask1 < 4; mask1++) {
for (int mask2 = 0; mask2 < 4; mask2++) {
for (int j = 0; j <= 2 * n; j++) {
if (j + add(mask1, mask2) <= k) {
dp[i + 1][mask2][j + add(mask1, mask2)] += dp[i][mask1][j];
dp[i + 1][mask2][j + add(mask1, mask2)] %= md;
}
}
}
}
}
int ans = 0;
for (int m = 0; m < 4; m++) {
ans += dp[n - 1][m][k];
ans %= md;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
int q, w, e;
q = min(a, min(b, c));
e = max(a, max(b, c));
if (q == a) {
if (e == b) {
w = c;
} else {
w = b;
}
} else if (q == b) {
if (e == a) {
w = c;
} else {
w = a;
}
} else if (q == c) {
if (e == a) {
w = b;
} else {
w = a;
}
}
int d = e - w;
int ans = 0;
if (d >= q) {
ans += q;
ans += w;
} else {
ans += d;
e = w;
q -= d;
if (q % 2 == 0) {
ans += q / 2;
ans += w;
} else {
ans += q / 2;
ans += w;
}
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n;
char a[100];
gets(a);
n = strlen(a);
if (n == 3 && a[2] == '0')
cout << "0\n";
else if (a[0] >= '0' && a[0] <= '9')
puts(a);
else {
for (i = 0; i <= strlen(a) - 3; i++) cout << a[i];
for (i = strlen(a) - 1; i >= strlen(a) - 2;) {
if (a[i] >= a[i - 1])
cout << a[i - 1];
else
cout << a[i];
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, l, m, n, t, p, h;
cin >> n;
k = n * n;
l = 1;
for (i = 1; i <= n; i++) {
for (m = 1; m <= n / 2; m++) cout << l++ << " ";
for (j = 1; j <= n / 2; j++) cout << k-- << " ";
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int N, D;
cin >> N >> D;
vector<pair<double, double> > I;
for (int i = 0; i < N; i++) {
int x, y, r;
cin >> x >> y >> r;
double d = sqrt(x * x + y * y);
int iA = 0, iB = 1e5;
while (iB - iA > 1) {
int j = (iA + iB) / 2;
if (1LL * (j * D + r) * (j * D + r) >= x * x + y * y)
iB = j;
else
iA = j;
}
int iC = 0, iD = 1e5;
while (iD - iC > 1) {
int j = (iC + iD) / 2;
if (1LL * (j * D - r) * (j * D - r) > x * x + y * y)
iD = j;
else
iC = j;
}
double phi = atan2(y, x);
for (int i = iB; i <= iC; i++) {
double delta =
acos((i * i * D * D + x * x + y * y - r * r) / 2.0 / d / i / D);
I.push_back(make_pair(phi - delta, phi + delta));
}
}
vector<double> Iz, Ik;
int akt = 0, ans = 0;
for (int i = 0; i < I.size(); i++) {
while (I[i].first < 0)
I[i].first += 2 * 3.14159265359, I[i].second += 2 * 3.14159265359;
while (I[i].first > 2 * 3.14159265359)
I[i].first -= 2 * 3.14159265359, I[i].second -= 2 * 3.14159265359;
if (I[i].second >= 2 * 3.14159265359 - 1e-10) akt++;
while (I[i].second > 2 * 3.14159265359 - 1e-10)
I[i].second -= 2 * 3.14159265359;
Iz.push_back(I[i].first);
Ik.push_back(I[i].second);
}
sort(Iz.begin(), Iz.end());
sort(Ik.begin(), Ik.end());
ans = akt;
int a = 0;
for (int i = 0; i < Iz.size(); i++) {
while (a < Ik.size() && Ik[a] < Iz[i] - 1e-10) {
akt--;
a++;
}
akt++;
ans = max(ans, akt);
}
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
bool compare(long long int i, long long int j) { return i > j; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
pair<int, int> p[n];
for (long long int i = 0; i < n; i++) cin >> p[i].first >> p[i].second;
int k;
cin >> k;
int ind = 0;
for (long long int i = 0; i < n; i++) {
if (p[i].second >= k) {
ind = i;
break;
}
}
cout << n - ind << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
double EPS = 1e-9;
using namespace std;
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
int n, m, w;
int main() {
int n;
cin >> n;
vector<int> s(n);
map<int, int> cnt;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
vector<int> prime;
for (int i = 2; i * i <= 100005; i++) {
bool flag = true;
for (int j = 0; j < prime.size(); j++) {
if (i % prime[j] == 0) flag = false;
}
if (flag) prime.push_back(i);
}
int ans = 1;
for (int i = 0; i < prime.size(); i++) {
int cou = 0;
for (int j = 0; j < n; j++) {
if (s[j] % prime[i] == 0) {
cou++;
while (s[j] % prime[i] == 0) {
s[j] /= prime[i];
}
}
}
ans = max(cou, ans);
}
for (int i = 0; i < n; i++) {
if (s[i] != 1) cnt[s[i]]++;
ans = max(ans, cnt[s[i]]);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e6 + 5;
const int MOD = 1e9 + 7;
long long bigmod(long long x, long long n) {
long long res = 1;
while (n > 0) {
if (n % 2 == 1) res = (res * x) % MOD;
x = (x * x) % MOD;
n /= 2;
}
return res;
}
long long fact[mx], inv[mx];
void prep(int k) {
fact[0] = 1;
for (int i = 1; i <= k; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 1; i < 2005 && i <= k; i++) {
inv[i] = bigmod(fact[i], MOD - 2);
int x = k - i;
inv[x] = bigmod(fact[x], MOD - 2);
}
}
long long nCr(int n, int r) {
if (r > n) return 0;
if (r == 0 || r == n) return 1;
r = min(r, n - r);
long long res = fact[n];
res = (res * inv[r]) % MOD;
return (res * inv[n - r]) % MOD;
}
long long DP[1005][1005];
long long solve(int n, int x) {
if (x == 1) return 1;
if (n == 1) return 0;
if (DP[n][x] != -1) return DP[n][x];
long long res = (solve(n - 1, x) * x) % MOD + (solve(n - 1, x - 1) * x) % MOD;
return DP[n][x] = res % MOD;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int m, n, k;
cin >> n >> m >> k;
long long ans;
if (m == 1)
ans = bigmod(k, n);
else {
memset(DP, -1, sizeof(DP));
prep(k);
ans = 0;
for (int i = 1; i <= n && i <= k; i++) {
for (int j = 0; j <= i; j++) {
long long cnt = 1;
cnt = (cnt * nCr(k, 2 * i - j)) % MOD;
cnt = (cnt * nCr(2 * i - j, i - j)) % MOD;
cnt = (cnt * nCr(i, i - j)) % MOD;
cnt = (cnt * solve(n, i)) % MOD;
cnt = (cnt * solve(n, i)) % MOD;
cnt = (cnt * bigmod(j, n * m - 2 * n)) % MOD;
ans = (ans + cnt) % MOD;
}
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
template <typename T>
struct fenwick_tree {
int tree_n = 0;
T tree_sum = 0;
vector<T> tree;
fenwick_tree(int n = -1) {
if (n >= 0) init(n);
}
void init(int n) {
tree_n = n;
tree_sum = 0;
tree.assign(tree_n + 1, 0);
}
template <typename T_array>
void build(const T_array &initial) {
assert((int)initial.size() == tree_n);
tree_sum = 0;
for (int i = 1; i <= tree_n; i++) {
tree[i] = initial[i - 1];
tree_sum += initial[i - 1];
for (int k = (i & -i) >> 1; k > 0; k >>= 1) tree[i] += tree[i - k];
}
}
void update(int index, const T &change) {
assert(0 <= index && index < tree_n);
tree_sum += change;
for (int i = index + 1; i <= tree_n; i += i & -i) tree[i] += change;
}
T query(int count) const {
assert(count <= tree_n);
T sum = 0;
for (int i = count; i > 0; i -= i & -i) sum += tree[i];
return sum;
}
T query_suffix(int start) const { return tree_sum - query(start); }
T query(int a, int b) const { return query(b) - query(a); }
T get(int a) const {
assert(0 <= a && a < tree_n);
int above = a + 1;
T sum = tree[above];
above -= above & -above;
while (a != above) {
sum -= tree[a];
a -= a & -a;
}
return sum;
}
bool set(int index, T value) {
assert(0 <= index && index < tree_n);
T current = get(index);
if (current == value) return false;
update(index, value - current);
return true;
}
int find_last_prefix(T sum) const {
if (sum < 0) return -1;
int prefix = 0;
for (int k = 31 - __builtin_clz(tree_n); k >= 0; k--)
if (prefix + (1 << k) <= tree_n && tree[prefix + (1 << k)] <= sum) {
prefix += 1 << k;
sum -= tree[prefix];
}
return prefix;
}
};
const int ALPHABET = 26;
const char MIN_CHAR = 'a';
int N;
string S;
vector<int> eq_freq;
fenwick_tree<int> tree;
int needed() {
int maximum = 0, sum = 0;
for (int c = 0; c < ALPHABET; c++) {
maximum = max(maximum, eq_freq[c]);
sum += eq_freq[c];
}
return max(maximum, (sum + 1) / 2) + 1;
}
bool can_match(char x, char y) {
if (x == y) return false;
int before = needed();
eq_freq[x - MIN_CHAR]--;
eq_freq[y - MIN_CHAR]--;
int after = needed();
eq_freq[x - MIN_CHAR]++;
eq_freq[y - MIN_CHAR]++;
return after == before - 1;
}
void run_case() {
cin >> S;
N = S.size();
tree.init(N);
tree.build(vector<int>(N, 1));
vector<pair<int, int>> moves;
auto &&add_move = [&](int start, int end) {
int under_start = tree.query(start);
int under_end = tree.query(end);
moves.emplace_back(under_start, under_end);
while (true) {
int x = tree.find_last_prefix(under_start);
if (x >= end) break;
tree.update(x, -1);
}
};
eq_freq.assign(ALPHABET, 0);
vector<pair<int, int>> eq_vec;
for (int i = 0; i < N - 1; i++)
if (S[i] == S[i + 1]) {
eq_vec.emplace_back(i, i + 1);
eq_freq[S[i] - MIN_CHAR]++;
}
vector<pair<int, int>> eq_stack;
for (pair<int, int> &eq : eq_vec)
if (!eq_stack.empty() && can_match(S[eq_stack.back().first], S[eq.first])) {
eq_freq[S[eq_stack.back().first] - MIN_CHAR]--;
eq_freq[S[eq.first] - MIN_CHAR]--;
add_move(eq_stack.back().second, eq.first + 1);
eq_stack.pop_back();
} else {
eq_stack.push_back(eq);
}
while (!eq_stack.empty()) {
add_move(eq_stack.back().second, N);
eq_stack.pop_back();
}
add_move(0, N);
cout << moves.size() << '\n';
for (pair<int, int> &move : moves)
cout << move.first + 1 << ' ' << move.second << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tests;
cin >> tests;
while (tests-- > 0) run_case();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
long long int matrix[n + 1][m + 1];
for (long long int i = (long long int)1; i <= (long long int)n; i++) {
for (long long int j = (long long int)1; j <= (long long int)m; j++) {
cin >> matrix[i][j];
}
}
long long int row = (n + 1) / 2;
long long int col = (m + 1) / 2;
long long int ans = 0;
for (long long int i = (long long int)1; i <= (long long int)row; i++) {
for (long long int j = (long long int)1; j <= (long long int)col; j++) {
set<pair<long long int, long long int>> blocks;
blocks.insert({i, j});
blocks.insert({i, m - j + 1});
blocks.insert({n - i + 1, j});
blocks.insert({n - i + 1, m - j + 1});
vector<long long int> res;
for (auto i : blocks) res.push_back(matrix[i.first][i.second]);
long long int cost = 0;
long long int temp = LONG_MAX;
for (long long int k = (long long int)0;
k <= (long long int)res.size() - 1; k++) {
cost = 0;
for (long long int l = (long long int)0;
l <= (long long int)res.size() - 1; l++) {
cost += abs(res[k] - res[l]);
}
temp = min(temp, cost);
}
ans += temp;
}
}
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long T, n, k;
cin >> T;
for (int i = 0; i < T; i++) {
cin >> n >> k;
cout << k * 2 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, b, c;
int a[200000];
const int INF = 2e9;
priority_queue<long long> q;
int getMod(int x) {
int res = x % 5;
if (res < 0) res += 5;
return res;
}
int main() {
scanf("%d%d%d%d", &n, &k, &b, &c);
for (int i = 0; i < (int)(n); ++i) scanf("%d", a + i);
sort(a, a + n);
long long ans = 9e18;
b = min(b, 5 * c);
for (int i = 0; i < (int)(5); ++i) {
int x = INF + i;
long long tot = 0;
while (!q.empty()) q.pop();
for (int j = 0; j < (int)(n); ++j) {
int y = a[j];
long long cost = 0;
while (getMod(y) != i) ++y, cost += c;
cost += (long long)b * (((long long)x - y) / 5);
q.push(cost);
tot += cost;
if ((int)q.size() > k) {
tot -= q.top();
q.pop();
}
int num = a[j];
while (getMod(num) != i) ++num;
if (j >= k - 1) {
ans = min(ans, tot - ((long long)x - num) / 5 * (long long)b * k);
}
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define x first
#define y second
using namespace std;
const long long INF = 1e18;
struct op{
string tp;
int y, v, to;
};
struct addmap{
long long add;
map<int, long long> val;
multiset<long long> mn;
};
void reset(addmap &a, int x, long long val){
if (a.val.count(x))
a.mn.erase(a.mn.find(a.val[x]));
a.val[x] = val - a.add;
a.mn.insert(val - a.add);
}
int main() {
int n, s;
scanf("%d%d", &n, &s);
static char buf[10];
op a;
vector<addmap> st;
st.push_back({});
st.back().val[0] = 0;
st.back().add = 0;
st.back().mn.insert(0);
forn(i, n){
scanf("%s", buf);
a.tp = buf;
if (a.tp == "set"){
scanf("%d%d", &a.y, &a.v);
assert(!st.back().mn.empty());
long long mn = st.back().add + *st.back().mn.begin();
st.back().add += a.v;
if (a.y != s) reset(st.back(), a.y, mn);
}
else if (a.tp == "if"){
scanf("%d", &a.y);
long long val = INF;
if (st.back().val.count(a.y)){
val = st.back().val[a.y] + st.back().add;
st.back().mn.erase(st.back().mn.find(st.back().val[a.y]));
st.back().val.erase(a.y);
}
st.push_back({});
reset(st.back(), a.y, val);
st.back().add = 0;
}
else{
if (st[int(st.size()) - 1].val.size() > st[int(st.size()) - 2].val.size())
swap(st[int(st.size()) - 1], st[int(st.size()) - 2]);
addmap& v = st[int(st.size()) - 2];
for (auto it : st.back().val){
if (!v.val.count(it.x) || v.val[it.x] + v.add > it.y + st.back().add){
if (v.val.count(it.x))
v.mn.erase(v.mn.find(v.val[it.x]));
v.val[it.x] = it.y + st.back().add - v.add;
v.mn.insert(it.y + st.back().add - v.add);
}
}
st.pop_back();
}
}
printf("%lld\n", *st.back().mn.begin() + st.back().add);
return 0;
} | 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double d, l, v1, v2, res, z;
scanf("%lf%lf%lf%lf", &d, &l, &v1, &v2);
res = (l - d) / (v1 + v2);
printf("%0.20lf", res);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T b, T p, T m) {
T ret;
if (p == 0) return 1;
if (p & 1) {
ret = (bigmod(b, p / 2, m) % m);
return ((b % m) * ret * ret) % m;
} else {
ret = (bigmod(b, p / 2, m) % m);
return (ret * ret) % m;
}
}
int dx4[] = {1, -1, 0, 0};
int dy4[] = {0, 0, 1, -1};
int dx6[] = {0, 0, 1, -1, 0, 0};
int dy6[] = {1, -1, 0, 0, 0, 0};
int dz6[] = {0, 0, 0, 0, 1, -1};
int dx8[] = {1, -1, 0, 0, -1, 1, -1, 1};
int dy8[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dkx8[] = {-1, 1, -1, 1, -2, -2, 2, 2};
int dky8[] = {2, 2, -2, -2, 1, -1, 1, -1};
int tc = 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
const long long int mx = 1e5;
const long long int mod = 1e9 + 7;
long long a[mx + 5];
int main() {
long long i, n, mini;
while (cin >> n) {
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
mini = 1;
for (i = 1; i <= n; i++) {
if (a[i] >= mini) mini++;
}
cout << mini << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void base() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
double n;
double a, b, c;
cin >> n;
cin >> a >> b >> c;
if (a + b + c == 0)
cout << "0.0 0.0 0.0\n";
else {
double onepor = (1) / (a + b + c);
cout.precision(12);
double la, lb, lc;
la = (a * onepor) * n;
lb = (b * onepor) * n;
lc = (c * onepor) * n;
long long sum = max(la + lb + lc - n, 0.0);
printf("%.20f %.20f %.20f\n", la, lb, lc);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t1, t2, x1, x2, t0;
cin >> t1 >> t2 >> x1 >> x2 >> t0;
long double mindiff = LLONG_MAX;
long long sty1, sty2;
bool check = false;
if (t1 == t2) {
check = true;
sty1 = x1;
sty2 = x2;
} else if (t1 == t0) {
check = true;
sty1 = x1;
sty2 = 0;
} else if (t2 == t0) {
check = true;
sty1 = 0;
sty2 = x2;
} else {
for (long long y1 = 1; y1 <= x1; y1++) {
long long y2 = y1 * (t0 - t1) / (t2 - t0);
y2++;
if ((y1 * (t1 - t0)) % (t2 - t0) == 0) {
y2--;
}
if (y2 < 1 || y2 > x2) {
continue;
}
long double calc = (long double)(t1 * y1 + t2 * y2) / (y1 + y2);
calc -= t0;
if (calc < 0) {
continue;
}
check = true;
if (calc < mindiff) {
mindiff = calc;
sty1 = y1;
sty2 = y2;
} else if (calc == mindiff) {
if (y1 + y2 > sty1 + sty2) {
sty1 = y1;
sty2 = y2;
}
}
}
}
if (!check) {
sty1 = 0;
sty2 = x2;
}
cout << sty1 << " " << sty2;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[6], sum;
int main() {
for (int i = 0; i < 6; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
for (int i = 0; i < 6; i++) {
for (int j = 1; j < 6; j++) {
for (int k = 2; k < 6; k++) {
if (a[i] + a[j] + a[k] == sum / 2 &&
(sum == 0 || sum % (a[i] + a[j] + a[k]) == 0) && i != j && j != k &&
i != k) {
puts("YES");
return 0;
}
}
}
}
puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (2e9) + 7;
const int maxn = 100100;
int h, w, n;
stack<pair<int, int> > q[maxn];
int u[maxn], l[maxn], r[maxn], s[maxn], p[maxn];
pair<int, int> minh[maxn << 2];
int cnt;
void build(int t, int l, int r) {
minh[t] = make_pair(h + 1, l);
if (l == r) {
q[l].push(make_pair(h + 1, 1));
return;
}
int mid = (l + r) >> 1;
build(t << 1, l, mid);
build(t << 1 | 1, mid + 1, r);
}
void insert(int t, int l, int r, int x, int h, int num) {
if (l == r) {
q[l].push(make_pair(h, num));
minh[t] = make_pair(h, l);
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
insert(t << 1, l, mid, x, h, num);
else
insert(t << 1 | 1, mid + 1, r, x, h, num);
minh[t] = min(minh[t << 1], minh[t << 1 | 1]);
}
void ask(int t, int l, int r, int x, int y, int lim) {
if (minh[t].first > lim) return;
if (l == r) {
while (!q[l].empty() && q[l].top().first <= lim) {
(cnt += q[l].top().second) >= 1000000007 && (cnt -= 1000000007);
q[l].pop();
}
minh[t] = q[l].empty() ? make_pair(INF, 0) : make_pair(q[l].top().first, l);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) ask(t << 1, l, mid, x, y, lim);
if (y > mid) ask(t << 1 | 1, mid + 1, r, x, y, lim);
minh[t] = min(minh[t << 1], minh[t << 1 | 1]);
}
int main() {
scanf("%d%d%d", &h, &w, &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d%d", u + i, l + i, r + i, s + i);
p[i] = i;
}
sort(p + 1, p + n + 1, [](int i, int j) { return u[i] > u[j]; });
build(1, 1, w);
for (int i = 1; i <= n; ++i) {
int x = p[i];
cnt = 0;
ask(1, 1, w, l[x], r[x], u[x] + s[x]);
if (cnt) {
(l[x] == 1 || r[x] == w) && (cnt += cnt) >= 1000000007 &&
(cnt -= 1000000007);
if (r[x] < w) insert(1, 1, w, r[x] + 1, u[x], cnt);
if (l[x] > 1) insert(1, 1, w, l[x] - 1, u[x], cnt);
}
}
int res = 0;
for (int i = 1; i <= w; ++i)
while (!q[i].empty())
(res += q[i].top().second) >= 1000000007 && (res -= 1000000007),
q[i].pop();
printf("%d\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int inf = 0x3f3f3f3f;
const int maxn = 300000 + 10;
set<pair<int, int> > que;
set<int> noti[maxn];
int n;
int q;
int main() {
scanf("%d%d", &n, &q);
int time = 1;
int num = 0;
int type;
int x;
int t;
for (int i = 0; i < q; i++) {
scanf("%d", &type);
if (type == 1) {
scanf("%d", &x);
x--;
que.insert(make_pair(time, x));
noti[x].insert(time);
time++;
num++;
} else if (type == 2) {
scanf("%d", &x);
x--;
for (int t : noti[x]) {
que.erase(make_pair(t, x));
num--;
}
noti[x].clear();
} else {
scanf("%d", &t);
while (!que.empty() && que.begin()->first <= t) {
noti[que.begin()->second].erase(que.begin()->first);
que.erase(que.begin());
num--;
}
}
printf("%d\n", num);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000000;
y = y >> 1;
x = (x * x) % 1000000000;
}
return res;
}
void solve() {
string s;
cin >> s;
stack<char> st;
int f = 0;
int n = (int)s.length();
int ans = 0, cnt = 0;
for (int i = 0; i < n; i++) {
if ((s[i] == ')' || s[i] == '}' || s[i] == '>' || s[i] == ']') &&
cnt <= 0) {
f = 1;
break;
} else {
if (s[i] == '(' || s[i] == '{' || s[i] == '<' || s[i] == '[') {
st.push(s[i]);
cnt++;
} else {
cnt--;
char c = st.top();
st.pop();
if ((s[i] == ')' && c == '(') || (s[i] == '}' && c == '{') ||
(s[i] == '>' && c == '<') || (s[i] == ']' && c == '['))
continue;
else
ans++;
}
}
}
if (!st.empty()) f = 1;
if (f)
cout << "Impossible\n";
else
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
while (T--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 998244353, a[250001], b[250001], n, i, k, l, ans1, ans2;
long long mod(long long a) { return a % M; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = n - k + 1; i <= n; i++) ans1 += i;
ans2 = 1;
for (i = 1; i <= n; i++)
if (a[i] >= n - k + 1) {
l++;
b[l] = i;
}
for (i = 1; i <= l - 1; i++) ans2 = mod(ans2 * (b[i + 1] - b[i]));
cout << ans1 << " " << ans2 << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int mod = (int)1e9 + 7;
const int up = (int)1e9;
int n, k, cnt;
struct node {
int x, r, q;
} e[maxn];
bool cmp(node a, node b) { return a.r > b.r; }
map<int, int> root;
int num[maxn * 35], lson[maxn * 35], rson[maxn * 35];
long long ans = 0;
void build(int pos, int l, int r, int &rt) {
if (!rt) rt = ++cnt;
num[rt]++;
if (l == r) return;
int mid = (l + r) / 2;
if (pos <= mid)
build(pos, l, mid, lson[rt]);
else
build(pos, mid + 1, r, rson[rt]);
}
long long query(int ql, int qr, int l, int r, int rt) {
if (!rt) return 0;
if (ql <= l && r <= qr) {
return (long long)num[rt];
}
int mid = (l + r) / 2;
long long tans = 0;
if (ql <= mid) tans += query(ql, qr, l, mid, lson[rt]);
if (qr > mid) tans += query(ql, qr, mid + 1, r, rson[rt]);
return tans;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (int)(1); i <= (int)(n); i++)
scanf("%d%d%d", &e[i].x, &e[i].r, &e[i].q);
sort(e + 1, e + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
for (int j = e[i].q - k; j <= e[i].q + k; j++) {
ans = (ans + query(e[i].x - e[i].r, e[i].x + e[i].r, 0, up, root[j]));
}
build(e[i].x, 0, up, root[e[i].q]);
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double a, b, c;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
scanf("%lf%lf%lf", &a, &b, &c);
if (a == 0) {
if (b == 0 && c == 0)
cout << -1;
else if (b == 0)
cout << 0 << endl;
else
printf("1\n%.10lf", -c / b);
} else {
double d = b * b - 4 * a * c;
if (d < 0)
cout << 0;
else if (d > 0) {
double d1 = (-b + sqrt(d)) / (2 * a);
double d2 = (-b - sqrt(d)) / (2 * a);
cout << 2 << endl;
if (d1 > d2)
printf("%.10lf\n%.10lf", d2, d1);
else
printf("%.10lf\n%.10lf", d1, d2);
} else {
printf("1\n%.10lf", -b / (2 * a));
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
char t[n];
int l[n];
int r[n];
for (int i = 0; i < n; i++) cin >> t[i] >> l[i] >> r[i];
int ans = 0;
for (int i = 1; i <= 366; i++) {
int tot = 0;
int m = 0;
int f = 0;
for (int j = 0; j < n; j++) {
if (i >= l[j] and i <= r[j]) {
if (t[j] == 'F') f++;
if (t[j] == 'M') m++;
tot++;
}
}
int res = min(m, f);
if (2 * res > ans) ans = 2 * res;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, h;
double p;
int a[3000];
double d[2005][2005][2][2];
int dat[3000][2];
int main() {
int i, j, k, l;
cin >> n >> h >> p;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
a[n] = -((1 << 30) - 1), a[n + 1] = ((1 << 30) - 1);
sort(a, a + n + 2);
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
if (a[j] - a[j - 1] >= h) break;
}
dat[i][0] = j - 1;
for (j = i - 1; j > 0; j--) {
if (a[j + 1] - a[j] >= h) break;
}
dat[i][1] = j + 1;
}
for (int itv = 0; itv < n; itv++) {
for (i = 1; i <= n; i++) {
j = i + itv;
for (k = 0; k < 2; k++)
for (l = 0; l < 2; l++) {
int left = k == 0 ? a[i - 1] : a[i - 1] + h;
int right = l == 0 ? a[j + 1] : a[j + 1] - h;
d[i][j][k][l] +=
0.5 * p * (d[i + 1][j][0][l] + a[i] - max(left, a[i] - h));
d[i][j][k][l] +=
0.5 * (1 - p) * (d[i][j - 1][k][0] + min(right, a[j] + h) - a[j]);
if (dat[i][0] < j)
d[i][j][k][l] +=
0.5 * (1 - p) *
(a[dat[i][0]] + h - a[i] + d[dat[i][0] + 1][j][1][l]);
else
d[i][j][k][l] += 0.5 * (1 - p) * (min(right, a[j] + h) - a[i]);
if (dat[j][1] > i)
d[i][j][k][l] +=
0.5 * p *
(a[j] - (a[dat[j][1]] - h) + d[i][dat[j][1] - 1][k][1]);
else
d[i][j][k][l] += 0.5 * p * (a[j] - max(left, a[i] - h));
}
}
}
printf("%.20lf", d[1][n][0][0]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int a[N];
vector<pair<int, int> > e;
vector<pair<int, pair<int, int> > > solution;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && a[i] != a[i - 1]) {
e.push_back(make_pair(cnt, a[i - 1]));
cnt = 1;
} else {
cnt++;
}
}
e.push_back(make_pair(cnt, a[n - 1]));
sort(e.begin(), e.end());
int best = 0, bp, bq, bi;
int max = e[e.size() - 1].first;
int ind = 0;
int passed = 0;
for (int i = 1; i <= max; i++) {
while (ind < e.size() && e[ind].first < i) {
passed += e[ind].first;
ind++;
}
int available = passed + i * (e.size() - ind);
for (int j = i; j <= available / j; j++) {
int k = available / j;
int t = j * k;
if (best < t) {
best = t;
bp = j;
bq = k;
bi = i;
}
}
}
printf("%d\n%d %d\n", best, bp, bq);
int ci = 0, cj = 0, ncj = 1;
for (int i = e.size() - 1; i >= 0; i--) {
for (int j = 0; j < bi && j < e[i].first && solution.size() < best; j++) {
solution.push_back(make_pair(ci, make_pair(cj % bq, e[i].second)));
ci = (ci + 1);
cj = (cj + 1);
if (ci == bp) {
ci = 0;
cj = ncj++;
}
}
}
sort(solution.begin(), solution.end());
int nn = 0;
for (int i = 0; i < bp; i++) {
for (int j = 0; j < bq; j++) {
if (j > 0) printf(" ");
printf("%d", solution[nn++].second.second);
}
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string a, b;
cin >> a >> b;
int l = a.size();
int ans = b.size(), t;
for (int i = 0; i < b.size(); i++) a += ".";
for (int i = 0; i < b.size(); i++) a = "." + a;
for (int i = 0; i < b.size() + l; i++) {
t = 0;
for (int j = 0; j < b.size(); j++) {
if (a[i + j] != b[j]) t++;
}
ans = min(ans, t);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
long long a;
scanf("%I64d", &a);
if (a <= 2)
printf("-1\n");
else if (a % 2 == 1)
printf("%I64d %I64d\n", (a * a) / 2, (a * a) / 2 + 1);
else
printf("%I64d %I64d\n", (a * a) / 4 - 1, (a * a) / 4 + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, p = 1e9 + 7;
int n, m;
int a[N][N], shr[N][N], slr[N][N], f[N][N][2], shf[N][N], slf[N][N];
char s[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++) {
if (s[j] == 'R')
a[i][j] = 1;
else
a[i][j] = 0;
}
}
if (n == 1 && m == 1) {
printf("1");
return 0;
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
shr[i][j] = shr[i][j + 1] + a[i][j];
}
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
slr[i][j] = slr[i + 1][j] + a[i][j];
}
}
if (a[n][m]) {
printf("0");
return 0;
}
f[n][m][0] = f[n][m][1] = 1;
shf[n][m] = 1, slf[n][m] = 1;
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
if (i == n && j == m) continue;
int t = m - shr[i][j + 1] + 1;
f[i][j][0] = (shf[i][j + 1] - shf[i][t] + p) % p;
t = n - slr[i + 1][j] + 1;
f[i][j][1] = (slf[i + 1][j] - slf[t][j] + p) % p;
slf[i][j] = (slf[i + 1][j] + f[i][j][0]) % p;
shf[i][j] = (shf[i][j + 1] + f[i][j][1]) % p;
}
}
printf("%d", (f[1][1][0] + f[1][1][1]) % p);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> Next;
void NEXT(int m, string b);
void NEXT(int m, string b) {
Next[0] = -1;
int i = -1;
int j = 0;
while (j <= m) {
if (i == -1 || b[i] == b[j]) {
i++;
j++;
Next[j] = i;
} else {
i = Next[i];
}
}
return;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n, k;
string s, SS;
while (cin >> n >> k) {
Next.resize(n + 10);
cin >> s;
NEXT(s.size(), s);
if (Next[s.size()] == 0) {
SS = s;
for (int i = 1; i < k; i++) s = s + SS;
cout << s << endl;
continue;
}
for (int i = s.size(); i >= 1; i--) {
if (Next[i] <= Next[i - 1] || Next[i] == 0) {
SS = s.substr(Next[s.size()], i);
break;
}
}
for (int i = 1; i < k; i++) {
s = s + SS;
}
cout << s << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int h, w, t;
double pix[605][605];
double tmp[605][605];
struct Graph {
int vexNum;
double dis[20][20];
};
struct Graph idGraph;
struct TSPsolution {
int vexNum;
double len;
int path[20];
};
struct TSPsolution idTSPsolution;
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a > b ? b : a; }
void init() {
memset(pix, 0, sizeof(pix));
memset(tmp, 0, sizeof(tmp));
scanf("%d%d%d", &h, &w, &t);
for (int i = 1; i <= h; i++)
for (int j = 1; j <= w; j++) scanf("%lf", &pix[i][j]);
return;
}
struct Graph CreateGraph() {
struct Graph ret = idGraph;
for (int i = 1; i <= h; i++)
for (int j = 1; j <= w; j++) {
int cnt = 0;
int num = (i - 1) / (h / t);
int up = max(num * h / t + 1, i - 1);
int down = min((num + 1) * h / t, i + 1);
int left = max(1, j - 1);
int right = min(w, j + 1);
for (int p = up; p <= down; p++)
for (int q = left; q <= right; q++) {
tmp[i][j] += pix[p][q];
++cnt;
}
tmp[i][j] /= cnt;
}
ret.vexNum = t;
for (int i = 0; i < t; i++) {
for (int j = 0; j < t; j++) {
double sum = 0;
int div = 10;
for (int k = 0; k < w / div; k++) {
double s1 = 0, s2 = 0;
for (int u = k * div + 1; u <= (k + 1) * div; u++) {
int x = (i + 1) * (h / t);
int y = j * (h / t) + 1;
s1 += tmp[x][u];
s2 += tmp[y][u];
}
sum += abs(s1 - s2);
}
ret.dis[i][j] = sum;
}
}
return ret;
}
double TSPcalclen(struct TSPsolution *x, struct Graph *G) {
double sum = 0;
int n = x->vexNum;
for (int i = 1; i < n; i++) {
int u = x->path[i];
int v = x->path[i + 1];
sum += G->dis[u][v];
}
return sum;
}
void TSPswap(struct TSPsolution *x, int i, int j) {
int t;
t = x->path[i];
x->path[i] = x->path[j];
x->path[j] = t;
return;
}
void TSProtate(struct TSPsolution *x, int l, int r) {
if (l > r) {
int t;
t = l;
l = r;
r = t;
}
int tmp = x->path[r];
for (int i = r; i > l; i--) x->path[i] = x->path[i - 1];
x->path[l] = tmp;
return;
}
void TSPshift(struct TSPsolution *x, int l, int r) {
int a[20], tot = 0, n = x->vexNum;
for (int i = l; i <= r; i++) a[++tot] = x->path[i];
for (int i = 1; i <= n; i++)
if (i > r) a[++tot] = x->path[i];
for (int i = 1; i <= n; i++)
if (i < l) a[++tot] = x->path[i];
for (int i = 1; i <= n; i++) x->path[i] = a[i];
}
void TSPlsh(struct TSPsolution *x, int l, int r) {
int a[20], tot = 0, n = x->vexNum;
for (int i = l; i <= r; i++) a[++tot] = x->path[i];
for (int i = 1; i <= n; i++)
if (i < l || i > r) a[++tot] = x->path[i];
for (int i = 1; i <= n; i++) x->path[i] = a[i];
}
void TSPrsh(struct TSPsolution *x, int l, int r) {
int a[20], tot = 0, n = x->vexNum;
for (int i = 1; i <= n; i++)
if (i < l || i > r) a[++tot] = x->path[i];
for (int i = l; i <= r; i++) a[++tot] = x->path[i];
for (int i = 1; i <= n; i++) x->path[i] = a[i];
}
struct TSPsolution NewSolution(struct Graph *G, struct TSPsolution bestSol) {
struct TSPsolution ret = idTSPsolution;
int i = rand() % G->vexNum + 1;
int j = rand() % G->vexNum + 1;
if (i > j) {
int t;
t = i;
i = j;
j = t;
}
if (i == j) {
ret = bestSol;
return ret;
}
int cmd = rand() % 5;
if (cmd == 0) {
TSPswap(&bestSol, i, j);
bestSol.len = TSPcalclen(&bestSol, G);
}
if (cmd == 1) {
if (j == G->vexNum) {
ret = bestSol;
return ret;
}
TSProtate(&bestSol, i, j);
bestSol.len = TSPcalclen(&bestSol, G);
}
if (cmd == 2) {
if (i == 1) {
ret = bestSol;
return ret;
}
TSPshift(&bestSol, i, j);
bestSol.len = TSPcalclen(&bestSol, G);
}
if (cmd == 3) {
if (i == 1) {
ret = bestSol;
return ret;
}
TSPlsh(&bestSol, i, j);
bestSol.len = TSPcalclen(&bestSol, G);
}
if (cmd == 4) {
if (i == 1) {
ret = bestSol;
return ret;
}
TSPrsh(&bestSol, i, j);
bestSol.len = TSPcalclen(&bestSol, G);
}
ret = bestSol;
return ret;
}
struct TSPsolution RandomSolution(int n, struct Graph *G) {
int a[20], b[20];
struct TSPsolution ret = idTSPsolution;
for (int i = 1; i <= n; i++) a[i] = i;
for (int i = 1; i <= n; i++) b[i] = rand();
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (b[a[i]] > b[a[j]]) {
int tmp;
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
ret.vexNum = n;
for (int i = 1; i <= n; i++) ret.path[i] = a[i] - 1;
ret.len = TSPcalclen(&ret, G);
return ret;
}
struct TSPsolution SA_TSP(struct Graph G) {
const double speed = 0.998;
const double initTem = 1e9;
const double minTem = 0.000001;
const int T = 1;
int n = G.vexNum;
struct TSPsolution bestSol = idTSPsolution;
struct TSPsolution curSol = idTSPsolution;
bestSol = RandomSolution(n, &G);
double curTem = initTem;
while (curTem > minTem) {
for (int i = 1; i <= T; i++) {
curSol = NewSolution(&G, bestSol);
if (curSol.len <= bestSol.len) {
bestSol = curSol;
} else {
double diff = bestSol.len - curSol.len;
int t1 = rand() % RAND_MAX;
int t2 = RAND_MAX;
double r = (double)t1 / (double)t2;
double x = exp(diff / curTem);
if (x > r) {
bestSol = curSol;
}
}
}
curTem = curTem * speed;
}
return bestSol;
} void print(struct TSPsolution ans) {
int res[605];
for (int i = 1; i <= ans.vexNum; i++) res[ans.path[i] + 1] = i;
for (int i = 1; i <= ans.vexNum; i++)
printf("%d%c", res[i], i == ans.vexNum ? '\n' : ' ');
return;
}
void solve() {
struct Graph G;
struct TSPsolution ans;
init();
G = CreateGraph();
ans = SA_TSP(G);
print(ans);
return;
}
int main() {
srand(time(0));
int T = 0;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
//#include <sys/resource.h>
#define initrand mt19937 mt_rand(time(0));
#define rand mt_rand()
#define int long long
#define MOD 1000000007
#define INF 1000000000
#define mid(l, u) ((l+u)/2)
#define rchild(i) (i*2 + 2)
#define lchild(i) (i*2 + 1)
#define mp(a, b) make_pair(a, b)
#define lz lazup(l, u, i);
using namespace std;
const int N = 505;
signed dp[N*N], p[N*N], temp[N*N], nCr[N][N];
int fac[N];
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, mod;
cin>>n>>mod;
dp[0] = 1;
dp[0] %= mod;
fac[0] = 1;
for(int i = 1;i<N;i++){
fac[i] = i*fac[i-1];
fac[i] %= mod;
}
nCr[0][0] = 1;
nCr[0][0] %= mod;
for(int i = 1;i<N;i++){
nCr[i][0] = nCr[i][i] = 1;
nCr[i][i] %= mod;
for(int j = 1;j<i;j++){
nCr[i][j] = nCr[i-1][j] + nCr[i-1][j-1];
nCr[i][j] %= mod;
}
}
int ans = 0;
for(int i = 1;i<=(n-1);i++){
//omg
int sum = 0;
int maxi = (i*(i-1))/2;
for(int j = 0;j<=maxi;j++){
sum += dp[j];
sum %= mod;
if((j - i)>=0) sum -= dp[j-i];
sum += mod;
sum %= mod;
temp[j] = sum;
}
p[maxi] = dp[maxi] = temp[maxi];
for(int j = maxi-1;j>=0;j--){
dp[j] = temp[j];
p[j] = dp[j] + p[j+1];
p[j] %= mod;
}
//omg
int b = nCr[n][i+1];
b *= fac[n-i-1];
b %= mod;
int bb = 0;
int ww = 0;
for(int k = maxi;k>=0;k--){
ww -= bb;
if((k+2) <= maxi) ww += p[k+2]*i;
ww %= mod;
ww += mod;
ww %= mod;
if((k+i+1)<=maxi) bb -= p[k+i+2];
if((k+2) <= maxi) bb += p[k+2];
bb %= mod;
bb += mod;
bb %= mod;
int toAdd = b;
toAdd *= dp[k];
toAdd %= mod;
toAdd *= ww;
ans += toAdd;
ans %= mod;
}
}
cout<<ans<<endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void mikrae_s() {
int n, f = 0, i, j, ans, e1, e2;
cin >> n;
int a[n], s[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
s[i] = a[i];
}
e1 = a[n - 1];
e2 = a[0];
sort(s, s + n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (s[i] == a[j]) {
ans = a[j];
a[j] = 0;
if ((a[j - 1] == 0 && j != 0) || (a[j + 1] == 0 && j != n - 1)) {
f = 1;
break;
}
}
}
if (f == 1) break;
}
cout << min(ans, min(e1, e2));
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int TEST = 1;
while (TEST--) mikrae_s();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int max_num = 5e6 + 100;
const int inf = 0x3f3f3f3f;
const int to_mod = 1e9 + 7;
const long long INF = 1e17 + 10;
struct node {
int to;
long long w;
int next;
} edge[max_num];
int num;
int head[max_num];
int Max;
int vis[max_num];
long long ans[max_num];
void init() {
num = 0;
Max = 0;
memset(vis, 0, sizeof(vis));
memset(head, -1, sizeof(head));
}
void add(int u, int v, long long w) {
num++;
edge[num].to = v;
edge[num].w = w;
edge[num].next = head[u];
head[u] = num;
}
void build(int l, int r, int pos, int flag, int t) {
if (t == 2) Max = max(Max, pos + flag);
if (l == r) {
if (t == 2)
add(pos + flag, l, 0LL);
else
add(l, pos + flag, 0LL);
return;
}
if (t == 2) {
add(pos + flag, (pos << 1) + flag, 0LL);
add(pos + flag, (pos << 1 | 1) + flag, 0LL);
} else {
add((pos << 1) + flag, pos + flag, 0LL);
add((pos << 1 | 1) + flag, pos + flag, 0LL);
}
int mid = (l + r) >> 1;
build(l, mid, pos << 1, flag, t);
build(mid + 1, r, pos << 1 | 1, flag, t);
}
void update(int L, int R, long long w, int l, int r, int pos, int flag, int u,
int t) {
if (L <= l && r <= R) {
if (t == 2)
add(u, pos + flag, w);
else
add(pos + flag, u, w);
return;
}
int mid = (l + r) >> 1;
if (L <= mid) update(L, R, w, l, mid, pos << 1, flag, u, t);
if (R > mid) update(L, R, w, mid + 1, r, pos << 1 | 1, flag, u, t);
}
struct mmp {
int s;
long long dis;
mmp() {}
mmp(long long ss, long long d) { s = ss, dis = d; }
bool operator<(const mmp &x) const { return dis > x.dis; }
};
priority_queue<mmp> q;
void dijkstra(int s) {
ans[s] = 0LL;
q.push(mmp(s, 0LL));
while (!q.empty()) {
mmp now = q.top();
q.pop();
int u = now.s;
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
long long w = edge[i].w;
if (ans[v] > now.dis + w) {
q.push(mmp(v, now.dis + w));
ans[v] = now.dis + w;
}
}
}
}
int main() {
int n, q, s;
scanf("%d%d%d", &n, &q, &s);
init();
build(1, n, 1, n + 1, 2);
build(1, n, 1, Max + 1, 3);
for (int i = 1; i <= q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w);
} else {
int u, l, r;
long long w;
scanf("%d%d%d%lld", &u, &l, &r, &w);
if (t == 2)
update(l, r, w, 1, n, 1, n + 1, u, t);
else
update(l, r, w, 1, n, 1, Max + 1, u, t);
}
}
for (int i = 0; i < max_num; i++) ans[i] = INF;
dijkstra(s);
for (int i = 1; i <= n; i++) {
if (ans[i] >= INF)
printf("-1 ");
else
cout << ans[i] << " ";
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, i = 0;
scanf("%d%d%d", &a, &b, &n);
a *= 10;
--n;
for (; i < 10; ++i) {
if ((a + i) % b == 0) break;
}
if (i == 10) {
printf("-1");
return 0;
}
printf("%d", a + i);
while (n--) {
printf("0");
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.