solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
const int N = 400005;
using namespace std;
int a[N], b[N];
vector<int> v[N];
bool ex[N];
set<pair<int, int> > s;
int main() {
int n, k;
scanf("%d%d", &n, &k);
int i, j;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
v[a[i]].push_back(i);
}
for (i = 1; i <= n; i++) v[i].push_back(n + 2);
memset(ex, false, sizeof(ex));
int ans = 0, sz = 0;
for (i = 0; i < n; i++) {
s.erase(make_pair(-v[a[i]][b[a[i]]], a[i]));
b[a[i]]++;
if (ex[a[i]]) {
s.insert(make_pair(-v[a[i]][b[a[i]]], a[i]));
continue;
}
if (sz == k) {
j = s.begin()->second;
s.erase(s.begin());
ex[j] = false;
} else
sz++;
ex[a[i]] = true;
s.insert(make_pair(-v[a[i]][b[a[i]]], a[i]));
ans++;
}
printf("%d", ans);
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6;
const int INF = 1e9 + 9;
const int B = 1e9 + 7;
const double PI = 3.1415926535897932384626433832795;
pair<double, double> operator+(const pair<double, double> &a,
const pair<double, double> &b) {
return pair<double, double>(a.first + b.first, a.second + b.second);
}
pair<double, double> operator*(const pair<double, double> &a, double len) {
return pair<double, double>(a.first * len, a.second * len);
}
double len(const pair<double, double> &a) {
return sqrt(a.first * a.first + a.second * a.second);
}
double _cos[360], _sin[360];
pair<double, double> turn(const pair<double, double> &a, int ang) {
return pair<double, double>(a.first * _cos[ang] + a.second * _sin[ang],
-a.first * _sin[ang] + a.second * _cos[ang]);
}
ostream &operator<<(ostream &out, pair<double, double> p) {
out << p.first << " " << p.second;
return out;
}
struct SegTree {
int n;
pair<double, double> t[N];
int u_ang[N];
void recalc(int first) { t[first] = t[(first << 1)] + t[((first << 1) | 1)]; }
void push(int first, int tl, int tr) {
if (!u_ang[first]) return;
t[first] = turn(t[first], u_ang[first] % 360);
if (tl < tr - 1) {
u_ang[(first << 1)] += u_ang[first];
u_ang[((first << 1) | 1)] += u_ang[first];
}
u_ang[first] = 0;
}
void build(int first, int tl, int tr) {
if (tl == tr - 1) {
t[first] = pair<double, double>(1, 0);
return;
}
int mid = (tl + tr) >> 1;
build((first << 1), tl, mid);
build(((first << 1) | 1), mid, tr);
recalc(first);
}
void init(int _n) {
n = _n;
build(1, 1, n + 1);
}
pair<double, double> get(int ql, int qr, int first, int tl, int tr) {
push(first, tl, tr);
if (qr <= tl || tr <= ql) return pair<double, double>(0, 0);
if (ql <= tl && tr <= qr) return t[first];
int mid = (tl + tr) >> 1;
pair<double, double> ans = get(ql, qr, (first << 1), tl, mid) +
get(ql, qr, ((first << 1) | 1), mid, tr);
recalc(first);
return ans;
}
pair<double, double> get(int ql, int qr) { return get(ql, qr, 1, 1, n + 1); }
void upd_vec(int qx, pair<double, double> delta, int first, int tl, int tr) {
push(first, tl, tr);
if (qx < tl || tr <= qx) return;
if (tl == tr - 1) {
t[first] = t[first] + delta;
return;
}
int mid = (tl + tr) >> 1;
upd_vec(qx, delta, (first << 1), tl, mid);
upd_vec(qx, delta, ((first << 1) | 1), mid, tr);
recalc(first);
}
void upd_vec(int qx, pair<double, double> delta) {
upd_vec(qx, delta, 1, 1, n + 1);
}
void upd_ang(int ql, int qr, int delta, int first, int tl, int tr) {
push(first, tl, tr);
if (qr <= tl || tr <= ql) return;
if (ql <= tl && tr <= qr) {
u_ang[first] += delta;
push(first, tl, tr);
return;
}
int mid = (tl + tr) >> 1;
upd_ang(ql, qr, delta, (first << 1), tl, mid);
upd_ang(ql, qr, delta, ((first << 1) | 1), mid, tr);
recalc(first);
}
void upd_ang(int ql, int qr, int delta) {
upd_ang(ql, qr, delta, 1, 1, n + 1);
}
} tree;
int n, q;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
for (int i = int(0); i <= int(359); ++i)
_cos[i] = cos(i / 180.0 * PI), _sin[i] = sin(i / 180.0 * PI);
cin >> n >> q;
cout << fixed << setprecision(6);
cerr << fixed << setprecision(6);
tree.init(n);
for (int i = int(1); i <= int(q); ++i) {
int tp, pos, delta;
cin >> tp >> pos >> delta;
if (tp == 1) {
pair<double, double> cur_vec = tree.get(pos, pos + 1);
pair<double, double> new_vec = cur_vec * (delta / len(cur_vec));
tree.upd_vec(pos, new_vec);
} else
tree.upd_ang(pos, n + 1, delta);
cout << tree.get(1, n + 1) << "\n";
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
string S;
int main() {
bool State = true;
cin >> S;
for (int i = 1; i < S.length(); i++) {
if (S[i] >= 'a' && S[i] <= 'z') {
State = false;
}
}
if (State) {
for (int i = 1; i < S.length(); i++) {
S[i] = tolower(S[i]);
}
if (S[0] >= 'a' && S[0] <= 'z') {
S[0] = toupper(S[0]);
} else if (S[0] >= 'A' && S[0] <= 'Z') {
S[0] = tolower(S[0]);
}
}
cout << S;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
bool r, f;
string s;
cin >> n;
getchar();
while (n--) {
getline(cin, s);
r = f = 0;
if (s.rfind("lala.") == s.size() - 5) f = 1;
if (s.find("miao.") == 0) r = 1;
if ((f && r) || (!f && !r))
cout << "OMG>.< I don't know!\n";
else if (f)
cout << "Freda's\n";
else if (r)
cout << "Rainbow's\n";
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
void Sort(int *BS, int idx2) {
int i = 1, j = 0, k = 0;
int tmp;
for (i = 1; i < idx2; i++) {
for (j = 0; j < idx2 - i; j++) {
if (*(BS + j) > *(BS + (j + 1))) {
tmp = *(BS + j);
*(BS + j) = *(BS + (j + 1));
*(BS + (j + 1)) = tmp;
}
}
}
}
int main() {
int n, pen = 0, temp = 0;
int list[100] = {0}, a[100] = {0};
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &list[i]);
}
Sort(list, n);
for (int i = 0; i < n; i++) {
temp = temp + list[i];
if (temp > 710) break;
if (temp > 350) {
a[i] = 1;
pen = pen + temp - 350;
}
if (temp <= 350) {
a[i] = 1;
}
}
int count = 0;
for (int j = 0; j < n; j++) {
if (a[j] == 1) count++;
}
printf("%d %d", count, pen);
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
unordered_map<string, string> dns;
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
while (n--) {
string x, y;
cin >> x >> y;
dns[y] = x;
}
while (m--) {
string x, y;
cin >> x >> y;
cout << x << " " << y << " #" << dns[y.substr(0, y.length() - 1)] << "\n";
}
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
char a[120][120];
int main() {
int n, m, x, y, count = 0, flag = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'B') {
flag = 1;
x = i;
y = j;
count = 1;
break;
}
}
if (flag == 1) break;
}
for (int i = y; i < m; i++) {
if (a[x][i] == 'B') count++;
}
cout << x + count / 2 << " " << y + count / 2 << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
string s;
int l, r, u, d;
int main() {
cin >> s;
for (int i = 0; i < s.size(); ++i)
if (s[i] == 'L')
l++;
else if (s[i] == 'R')
r++;
else if (s[i] == 'U')
u++;
else
d++;
d = fabs(d - u);
l = fabs(r - l);
if (d != l) {
int val = min(d, l), s = max(d, l) - min(d, l);
if (s % 2 == 1)
cout << -1;
else
cout << val + s / 2;
} else
cout << d;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1 << 17;
struct Fenw {
vector<int> A;
vector<int> F;
Fenw() { A = F = vector<int>(maxN, 0); }
void upd(int i, int x) {
int d = x - A[i];
A[i] += d;
for (; i < maxN; i |= i + 1) {
F[i] += d;
}
}
int get(int l, int r) {
int ans = 0;
for (l--; l >= 0; l = (l & (l + 1)) - 1) {
ans -= F[l];
}
for (; r >= 0; r = (r & (r + 1)) - 1) {
ans += F[r];
}
return ans;
}
};
vector<int> wait[maxN];
vector<int> in[maxN];
Fenw waitsum;
Fenw insum;
int s[maxN];
int f[maxN];
long long ans[maxN];
set<pair<int, int> > q;
set<int> pos;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int t;
cin >> t >> s[i] >> f[i];
q.insert({t, i});
}
pos.insert(0);
pos.insert(m + 1);
long long t = 0;
int h = 1;
int out = 0;
while (out < n) {
while ((*q.begin()).first == t) {
int id = (*q.begin()).second;
wait[s[id]].push_back(id);
waitsum.upd(s[id], wait[s[id]].size());
pos.insert(s[id]);
q.erase(q.begin());
}
while (wait[h].size()) {
int id = wait[h].back();
in[f[id]].push_back(id);
insum.upd(f[id], in[f[id]].size());
pos.insert(f[id]);
wait[h].pop_back();
}
while (in[h].size()) {
int id = in[h].back();
ans[id] = t;
out++;
in[h].pop_back();
}
waitsum.upd(h, 0);
insum.upd(h, 0);
pos.erase(h);
long long t2;
if (!q.empty()) {
t2 = (*q.begin()).first;
} else {
t2 = t + 1e5;
}
if (insum.get(1, m) + waitsum.get(1, m) == 0) {
t = t2;
} else {
int p = 0;
p += insum.get(h + 1, m + 1) - insum.get(0, h - 1);
p += waitsum.get(h + 1, m + 1) - waitsum.get(0, h - 1);
int dh = (p >= 0) ? 1 : -1;
if (dh == 1) {
auto it = pos.upper_bound(h);
t2 = min(*it - h + t, t2);
} else {
auto it = pos.lower_bound(h);
it--;
t2 = min(h - *it + t, t2);
}
h += dh * (t2 - t);
t = t2;
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
char a[5505];
int main() {
cin >> a;
int n = strlen(a);
int dp[5505];
dp[0] = 1;
int MAX = 1;
int anumber = 0;
int bnumber = 0;
int beforeb = 0;
if (a[0] == 'b')
bnumber++;
else
anumber++;
for (int i = 1; i < n; i++) {
if (a[i] == a[i - 1]) {
dp[i] = dp[i - 1] + 1;
} else if (a[i] == 'a') {
dp[i] = MAX + 1;
} else {
dp[i] = max(bnumber + 1, anumber + 1);
dp[i] = max(dp[i], beforeb + 1);
}
if (a[i] == 'a')
anumber++;
else {
beforeb = max(dp[i], beforeb);
bnumber++;
}
MAX = max(MAX, dp[i]);
}
cout << MAX;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
const int M = 200010;
const long long inf = 1e15;
const int mod = 1000000007;
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b /= 2;
}
return ans;
}
long long qpow(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
a = a * a % c;
b /= 2;
}
return ans;
}
const double eps = 1e-10, pi = acos(-1);
char s[1100][1100];
int n, m;
int dist[1100][1100];
int nex[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
bool did[1100][1100];
void bfs(int x1, int y1) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) dist[i][j] = 1e9;
dist[x1][y1] = 0;
queue<pair<int, int> > q;
q.push({x1, y1});
did[x1][y1] = true;
while (!q.empty()) {
pair<int, int> x = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int tx = nex[i][0] + x.first, ty = nex[i][1] + x.second;
if (tx >= 0 && tx < n && ty >= 0 && ty < m && s[tx][ty] != 'T' &&
!did[tx][ty]) {
dist[tx][ty] = dist[x.first][x.second] + 1;
did[tx][ty] = true;
q.push({tx, ty});
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (s[i][j] == 'E') bfs(i, j);
}
int ans = 0, dd = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'S') dd = dist[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] >= '1' && s[i][j] <= '9') {
if (dist[i][j] <= dd) ans += s[i][j] - '0';
}
}
}
printf("%d\n", ans);
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
inline int read();
const int N = 5e5 + 5;
int n;
int v[N], he[N], ne[N], to[N], id[N], f[20][N];
long long sum, w;
void Link(int x, int y) { v[x] > v[y] ? f[0][x] = y : f[0][y] = x; }
void Chkmin(long long& x, long long y) {
if (y < x) x = y;
}
bool Cmp(int x, int y) { return v[x] < v[y]; }
void Work() {
n = read();
for (int i = 1; i <= n; ++i) v[i] = read(), id[i] = i;
for (int i = 1; i < n; ++i) Link(read(), read());
sort(id + 1, id + n + 1, Cmp);
for (int i = 0; i <= 19; ++i) f[i][id[1]] = id[1];
for (int i = 2; i <= n; ++i) {
int p = id[i];
w = v[f[0][p]];
for (int j = 1; j <= 19; ++j) {
f[j][p] = f[j - 1][f[j - 1][p]];
Chkmin(w, 1ll * (j + 1) * v[f[j][p]]);
}
w += v[p];
sum += w;
}
printf("%I64d", sum);
}
int main() {
Work();
return 0;
}
inline int read() {
char c;
bool type = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') type = 0;
int ans = c ^ 48;
while ((c = getchar()) >= '0' && c <= '9')
ans = (ans << 3) + (ans << 1) + (c ^ 48);
return type ? ans : -ans;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i;
char c[101];
for (i = 0;; i++) {
cin >> c[i];
if (c[i] == '?') {
break;
}
}
if (c[i - 1] == 'A' || c[i - 1] == 'a' || c[i - 1] == 'u' ||
c[i - 1] == 'U' || c[i - 1] == 'y' || c[i - 1] == 'Y' ||
c[i - 1] == 'i' || c[i - 1] == 'I' || c[i - 1] == 'E' ||
c[i - 1] == 'e' || c[i - 1] == 'O' || c[i - 1] == 'o') {
cout << "YES";
} else
cout << "NO";
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 123;
int N, val[maxn];
vector<int> v[2];
int main() {
scanf("%d", &N);
for (int i = 1, a; i <= N; i++) {
scanf("%d%d", &a, &val[i]);
v[a].push_back(i);
}
for (int i = 0, j = 0, k = 1; k < N; k++) {
int a = v[0][i], b = v[1][j];
int x = min(val[a], val[b]);
printf("%d %d %d\n", a, b, x);
val[a] -= x;
val[b] -= x;
if (!val[a] and i + 1 < (int)v[0].size())
i++;
else
j++;
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
const double eps = 0.0000000001, pi = 3.14159265358979323;
const int maxn = int(2e5 + 100);
vector<vector<int> > g;
bool visited[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int a[5], o = -1, I = -1, sum = 0;
for (int i = 1; i <= 4; ++i) cin >> a[i];
for (int i = -1; i <= int(1e6); ++i) {
if (i * (i + 1) / 2 == a[1]) o = i + 1, sum += o;
if (i * (i + 1) / 2 == a[4]) I = i + 1, sum += I;
}
if (I == -1 || o == -1) {
cout << "Impossible";
return 0;
}
long long all = o + I - 1;
all = 1LL * all * (all + 1) / 2;
if (a[1] && a[4] && all - a[1] - a[4] != a[2] + a[3]) {
cout << "Impossible";
return 0;
}
if (!a[2] && !a[3] && !a[4]) I = 0;
if (!a[1] && !a[2] && !a[3]) o = 0;
if (!o && !I) {
cout << 0;
return 0;
}
all = o + I - 1;
all = 1LL * all * (all + 1) / 2;
if (all - a[1] - a[4] != a[2] + a[3]) {
cout << "Impossible";
return 0;
}
int val1 = 0, val2 = 0;
for (int i = 1; i <= sum; ++i) {
if (val1 + I <= a[2] && o > 0) {
cout << "0";
val1 += I;
o--;
} else if (I > 0 && val2 + o <= a[3]) {
cout << "1";
val2 += o;
I--;
}
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char grid[50][50];
bool is_valid(int x, int y) {
vector<bool> exist(7, false);
exist[grid[x][y] - 'a'] = true;
exist[grid[x + 1][y] - 'a'] = true;
exist[grid[x][y + 1] - 'a'] = true;
exist[grid[x + 1][y + 1] - 'a'] = true;
if (exist['f' - 'a'] && exist['a' - 'a'] && exist['c' - 'a'] &&
exist['e' - 'a']) {
return true;
} else {
return false;
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
}
}
if (n == 1 || m == 1) {
cout << 0 << endl;
return 0;
}
int res = 0;
for (int i = 0; i <= n - 2; i++) {
for (int j = 0; j <= m - 2; j++) {
if (is_valid(i, j)) {
res++;
}
}
}
cout << res << endl;
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 1303;
long long k;
long long ans = 0;
vector<long long> adj[N];
long long uni[N];
long long dfs(long long x, long long par) {
long long sub_uni = uni[x];
for (auto &ch : adj[x])
if (par != ch) sub_uni += dfs(ch, x);
ans += min(2 * k - sub_uni, sub_uni);
return sub_uni;
}
long long solve() {
long long n;
cin >> n >> k;
for (long long i = 0; i < 2 * k; ++i) {
long long x;
cin >> x;
uni[x] = 1;
}
for (long long i = 0; i < n - 1; ++i) {
long long x;
long long y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, 0);
cout << ans;
return 0;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve(), cout << endl;
cerr << (float)clock() / CLOCKS_PER_SEC << " secs\n";
return 0;
}
| 10
|
#include <bits/stdc++.h>
const int INF = 2147483647;
const long long LLINF = 2e18;
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 5;
const int MOD = 1e9 + 7;
inline int read() {
int x = 0, f = 1; char ch = getchar();
while (!isdigit(ch)) { if (ch == '-') f = -1; ch = getchar(); }
while (isdigit(ch)) { x = x * 10 + ch - 48; ch = getchar(); }
return x * f;
}
inline void write(int X)
{
if (X < 0) { X = ~(X - 1); putchar('-'); }
if (X > 9) write(X / 10);
putchar(X % 10 + '0');
}
int a[maxn];
int modulo = 998244353;
ll qpow(ll x, ll n, ll p)
{
ll temp;
x = x % p;
if (n == 0)
{
return 1;
}
temp = qpow((x * x) % p, n >> 1, p);
if (n & 1)
{
temp = temp * x % p;
}
return temp % p;
}
ll com(ll a, ll b) {
ll ans = 1;
for (ll i = 0; i < b; i++) {
ans = (ans * (a - i)) % modulo;
}
for (ll i = 2; i <= b; i++) {
ans = (ans * qpow(i, modulo - 2, modulo)) % modulo;
}
return ans;
}
int main()
{
int t = read();
while (t--) {
int n = read();
memset(a, 0, sizeof a);
for (int i = 1; i <= n; i++) {
a[i] = getchar() - '0';
}
int cna = 0, cnb = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 0) {
cna++;
}
else {
if (a[i + 1] == 1) {
cna++;
cnb++;
i++;
}
}
}
printf("%lld\n", com(cna, cnb));
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2, s3, s4, s5, s6;
bool check(string s) {
if (s1 == s || s2 == s || s3 == s || s4 == s || s5 == s || s6 == s) {
return 1;
} else {
return 0;
}
}
string process(string s) {
string out;
for (int i = 0; i < s.length(); i++) {
if (s[i] == ';' || s[i] == '_' || s[i] == '-') {
} else if ((int)s[i] < 97) {
out += (char)((int)s[i] + 32);
} else {
out += s[i];
}
}
return out;
}
int main() {
string s, t1, t2, t3;
cin >> s;
t1 = process(s);
cin >> s;
t2 = process(s);
cin >> s;
t3 = process(s);
s1 = t1 + t2 + t3;
s2 = t1 + t3 + t2;
s3 = t2 + t1 + t3;
s4 = t2 + t3 + t1;
s5 = t3 + t1 + t2;
s6 = t3 + t2 + t1;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
s = process(s);
if (check(s)) {
cout << "ACC" << endl;
} else {
cout << "WA" << endl;
}
}
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, f[400050];
int F(int x) { return f[x] == x ? x : f[x] = F(f[x]); }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n + m; i++) f[i] = i;
for (int i = 1, x, y; i <= q; i++) {
scanf("%d%d", &x, &y);
y += n;
x = F(x), y = F(y);
if (x != y) f[x] = y;
}
int ans = 0;
for (int i = 1; i <= n + m; i++)
if (f[i] == i) ans++;
printf("%d\n", ans - 1);
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
string tobin(int x, int len) {
string c;
while (x > 0) {
c.push_back(x % 2 + '0');
x >>= 1;
}
while (int((c).size()) < len) c.push_back('0');
reverse((c).begin(), (c).end());
return c;
}
const int MXN = 100000;
int n, ar[MXN + 5];
int pls[MXN + 5], ma;
long long ans;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &ar[i]);
ma = ar[0];
for (int i = 0; i < n; ++i) {
if (ar[i] > ma) {
ma = ar[i];
pls[i] = 0;
} else
pls[i] = ma - ar[i];
}
ans = 0LL;
for (int i = 0; i < n - 1; ++i)
if (pls[i] < pls[i + 1]) ans += pls[i + 1] - pls[i];
cout << ans << endl;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
int m, n, a, b;
cin >> t;
while (t--) {
cin >> m >> n >> a >> b;
cout << ((n - m) % (a + b) == 0 ? (n - m) / (a + b) : -1) << endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int sum[2555][2555];
map<pair<pair<int, int>, pair<int, int> >, int> mp;
void add(int x, int y, int val) {
for (int i = x; i <= n; i += (i & (-i))) {
for (int j = y; j <= m; j += (j & (-j))) {
sum[i][j] += val;
}
}
}
int query(int x, int y) {
int ans = 0;
for (int i = x; i > 0; i -= (i & (-i))) {
for (int j = y; j > 0; j -= (j & (-j))) {
ans += sum[i][j];
}
}
return ans;
}
int main() {
srand(time(NULL));
scanf("%d %d %d", &n, &m, &q);
while (q--) {
int t;
scanf("%d", &t);
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
if (t == 1) {
int u = rand() * rand();
mp[pair<pair<int, int>, pair<int, int> >(pair<int, int>(a, b),
pair<int, int>(c, d))] = u;
add(a, b, u);
add(c + 1, b, -u);
add(a, d + 1, -u);
add(c + 1, d + 1, u);
} else if (t == 2) {
int u = mp[pair<pair<int, int>, pair<int, int> >(pair<int, int>(a, b),
pair<int, int>(c, d))];
add(a, b, -u);
add(c + 1, b, u);
add(a, d + 1, u);
add(c + 1, d + 1, -u);
} else {
if (query(a, b) == query(c, d)) {
printf("Yes\n");
} else {
printf("No\n");
}
}
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll dist(const pii& a, const pii& b) {
ll dx = a.first - b.first;
ll dy = a.second - b.second;
return dx * dx + dy * dy;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pii> pts(n);
vector<tuple<int, int, ll>> dists;
ll g = 0;
for (int i = 0; i < n; ++i) {
cin >> pts[i].first >> pts[i].second;
for (int j = 0; j < i; ++j) {
ll d = dist(pts[j], pts[i]);
g = gcd(d, g);
dists.emplace_back(j, i, d);
}
}
ll k = 1;
while (g % 2 == 0) {
g /= 2;
k *= 2;
}
vector<vector<pii>> graph(n);
for (auto& t : dists) {
int u, v;
ll w;
tie(u, v, w) = t;
w /= k;
graph[u].emplace_back(v, w % 2);
graph[v].emplace_back(u, w % 2);
}
vi color(n, -1);
function<pii(int, int)> dfs = [&](int u, int c) -> pii {
color[u] = c;
pii res = pii{0, 0};
if (c == 0) {
++res.first;
} else {
++res.second;
}
for (auto& e : graph[u]) {
int v, w;
tie(v, w) = e;
if (color[v] == -1) {
auto p = dfs(v, c ^ w);
res.first += p.first;
res.second += p.second;
}
assert(color[v] == (color[u] ^ w));
}
return res;
};
vi ans;
for (int i = 0; i < n; ++i) {
if (color[i] == -1) {
dfs(i, 0);
}
if (color[i] == 0) {
ans.push_back(i);
}
}
cout << ans.size() << '\n';
for (int x : ans) {
cout << x + 1 << ' ';
}
cout << '\n';
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[2 * n];
for (long long int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
sort(a, a + 2 * n);
cout << a[n] - a[n - 1] << endl;
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
long long modPow(long long b, long long e, long long mod) {
long long result = 1;
b %= mod;
while (e) {
if (e & 1) result = ((long long)result * b) % mod;
b = (b * b) % mod;
e >>= 1;
}
return result;
}
int main(int argc, char const* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(0);
int p;
cin >> p;
long long sol = 0;
for (int i = 1; i <= p; ++i)
for (int j = 1; j <= p - 1; ++j)
if ((modPow(i, j, p) - 1) % p == 0 && j != p - 1)
break;
else if (j == p - 1 && (modPow(i, j, p) - 1) % p == 0)
++sol;
cout << sol << '\n';
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = 0;
int x = 0, flag = 1;
while (!isdigit(ch)) {
ch = getchar();
if (ch == '-') flag = -1;
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * flag;
}
int n, m, k, f[110][110];
char s1[110], s2[110], ch[110];
bool dp1[110][110][30], dp2[110][110][30];
struct node {
int x, y;
};
vector<node> v[110];
int dfs(int x, int y) {
if (x == n + 1 && y == m + 1) f[x][y] = 0;
if (f[x][y] != -1) return f[x][y];
f[x][y] = 1e9 + 7;
for (int i = x; i <= n; i++)
for (int j = y; j <= m; j++)
if ((i != n && j != m) || (i == n && j == m))
for (int t = 1; t <= 26; t++)
if (dp1[x][i][t] && dp2[y][j][t])
f[x][y] = min(f[x][y], dfs(i + 1, j + 1) + 1);
return f[x][y];
}
int main() {
scanf("%s", s1 + 1);
scanf("%s", s2 + 1);
n = strlen(s1 + 1), m = strlen(s2 + 1), k = read();
for (int i = 1; i <= k; i++) {
scanf("%s", ch);
int x = ch[0] - 'a' + 1;
int t1 = ch[3] - 'a' + 1;
int t2 = ch[4] - 'a' + 1;
v[x].push_back((node){t1, t2});
}
for (int i = 1; i <= n; i++) dp1[i][i][s1[i] - 'a' + 1] = true;
for (int i = n; i >= 1; i--)
for (int j = i + 1; j <= n; j++)
for (int t = 1; t <= 26; t++)
for (int d = i; d < j; d++) {
int len = v[t].size();
for (int o = 0; o < len; o++) {
int t1 = v[t][o].x, t2 = v[t][o].y;
dp1[i][j][t] = dp1[i][d][t1] && dp1[d + 1][j][t2];
if (dp1[i][j][t]) break;
}
if (dp1[i][j][t]) break;
}
for (int i = 1; i <= m; i++) dp2[i][i][s2[i] - 'a' + 1] = true;
for (int i = m; i >= 1; i--)
for (int j = i + 1; j <= m; j++)
for (int t = 1; t <= 26; t++)
for (int d = i; d < j; d++) {
int len = v[t].size();
for (int o = 0; o < len; o++) {
int t1 = v[t][o].x, t2 = v[t][o].y;
dp2[i][j][t] = dp2[i][d][t1] && dp2[d + 1][j][t2];
if (dp2[i][j][t]) break;
}
if (dp2[i][j][t]) break;
}
memset(f, -1, sizeof(f));
int ans = dfs(1, 1);
printf("%d\n", ans < 1e9 + 7 ? ans : -1);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000000];
long long s, i, j, d;
int main() {
d = 1;
j = 1;
cin >> s;
for (i = 0; i < s; i++) {
cin >> a[i];
}
for (i = 0; i < (s - 1); i++) {
if (a[i] < a[i + 1])
d++;
else
d = 1;
j = max(j, d);
}
cout << j << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
const long long maxn = 110;
const long long maxpfn = 10010;
const long long mo = 1000000007;
long long f[2][maxpfn], C[maxn + 1][maxn + 1], ci[maxn + 1],
yh[maxn + 1][maxn + 1];
long long n, m, K;
long long result;
long long mi(long long a, long long p) {
long long b;
bool first = true;
b = a;
while (p) {
if (p & 1) {
if (first) {
first = false;
a = b;
} else {
a = (a * b) % mo;
}
}
b = (b * b) % mo;
p /= 2;
}
return a;
}
void calc_C() {
long long i, j;
C[0][0] = 1;
for (i = 1; i <= n; ++i) {
C[i][0] = C[i][i] = 1;
for (j = 1; j < i; ++j) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= mo) C[i][j] -= mo;
}
}
}
void init() {
long long i, j, k;
scanf("%I64d%I64d%I64d", &n, &m, &K);
for (i = 1; i <= n; ++i) {
ci[i] = m / n;
if (m % n >= i) ++ci[i];
}
calc_C();
for (i = 1; i <= n; ++i)
for (k = 0; k <= n; ++k) {
yh[i][k] = mi(C[n][k], ci[i]);
}
}
void work() {
long long old, now, i, j, k;
now = 0;
for (i = 0; i <= K; ++i) f[now][i] = 0;
f[now][0] = 1;
for (i = 1; i <= n; ++i) {
old = now;
now = 1 - now;
for (j = 0; j <= K; ++j) f[now][j] = 0;
for (k = 0; k <= n; ++k)
for (j = K - k; j >= 0; --j)
if (f[old][j]) {
f[now][j + k] += f[old][j] * yh[i][k];
f[now][j + k] = f[now][j + k] % mo;
}
}
result = f[now][K];
}
void output() { printf("%I64d\n", result); }
int main() {
init();
work();
output();
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e6 + 3;
const int N = 1e6 + 5;
long long fac[2 * N];
long long binPow(long long x, long long p) {
if (p == 0) return 1LL;
long long r = binPow(x, p / 2LL);
r = (r * r) % MOD;
r *= (p % 2LL ? x : 1LL);
return r % MOD;
}
long long getCnk(int k, int n) {
return fac[n] * binPow((fac[k] * fac[n - k]) % MOD, MOD - 2LL);
}
int main() {
int n, c;
cin >> n >> c;
fac[0] = 1;
for (int i = 1; i < n + c; ++i) fac[i] = (fac[i - 1] * (long long)i) % MOD;
long long ans = 0;
for (int i = 1; i <= n; ++i) ans = (ans + getCnk(i, i + c - 1)) % MOD;
cout << ans;
return 0;
}
| 10
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
bool z = false;
for (int i = 0; i < n; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if ((b == c) && (!(m % 2))) z = true;
}
if (z)
cout << "Yes" << '\n';
else
cout << "No" << '\n';
}
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int len;
cin >> len;
vector<pair<int, int>> join;
int arr[len];
for (int i = 0; i < len; i++) cin >> arr[i];
for (int i = 1; i < len; i++) {
int mi = min(arr[i - 1], arr[i]);
int ma = max(arr[i - 1], arr[i]);
join.push_back(make_pair(mi, ma));
}
int flag = 0;
for (auto i : join) {
for (auto j : join) {
if (j.first < i.first && j.second > i.first && j.second < i.second) {
cout << "yes" << endl;
flag++;
break;
} else if (j.first < i.second && j.second > i.second &&
j.first > i.first) {
cout << "yes" << endl;
flag++;
break;
}
}
if (flag) break;
}
if (!flag) cout << "no" << endl;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
char St[100007];
stack<pair<char, int> > S1;
stack<pair<int, int> > S2;
vector<pair<int, int> > V;
int Pre[100007];
int main() {
int i, j, k, l, m, n, x, y, z, a, b, r, ans;
scanf("%s", St);
n = strlen(St);
for (i = 0; i < n; i++) {
if ((S1.empty()) || (St[i] == '(' || St[i] == '[')) {
S1.push(make_pair(St[i], i + 1));
} else {
if ((S1.top().first == '(' && St[i] == ')') ||
(S1.top().first == '[' && St[i] == ']')) {
x = S1.top().second;
y = i + 1;
S1.pop();
while (!S2.empty() && x <= S2.top().first && S2.top().second <= y)
S2.pop();
S2.push(make_pair(x, y));
} else {
S1.push(make_pair(St[i], i + 1));
}
}
}
for (i = 1; i <= n; i++) {
if (St[i - 1] == '[') Pre[i] = 1;
Pre[i] += Pre[i - 1];
}
ans = 0;
while (!S2.empty()) {
V.push_back(S2.top());
S2.pop();
}
reverse(V.begin(), V.end());
for (i = 0; i < (int)V.size(); i++) {
if (S2.empty())
S2.push(V[i]);
else {
if (S2.top().second + 1 == V[i].first) {
x = S2.top().first;
y = V[i].second;
S2.pop();
S2.push(make_pair(x, y));
} else {
S2.push(V[i]);
}
}
}
x = y = 0;
while (!S2.empty()) {
if (ans < Pre[S2.top().second] - Pre[S2.top().first - 1]) {
ans = Pre[S2.top().second] - Pre[S2.top().first - 1];
x = S2.top().first;
y = S2.top().second;
}
S2.pop();
}
printf("%d\n", ans);
St[y] = '\0';
if (ans != 0) printf("%s\n", St + x - 1);
return 0;
}
| 9
|
#include <bits/stdc++.h>
int main() {
int n;
while (scanf("%d", &n) == 1) {
int a = n - n % 10;
int b = n + 10 - n % 10;
if (n - a > b - n)
printf("%d\n", b);
else
printf("%d\n", a);
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9 + 10;
const int N = 300000 + 10;
int a[N];
vector<int> e[N];
multiset<int> s;
int main() {
int n, u, v;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s.insert(a[i]);
}
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
int ans = inf;
for (int i = 1; i <= n; i++) {
int maxx = a[i];
s.erase(s.find(a[i]));
for (auto v : e[i]) {
maxx = max(maxx, a[v] + 1);
s.erase(s.find(a[v]));
}
if (s.size()) maxx = max(maxx, *s.rbegin() + 2);
s.insert(a[i]);
for (auto v : e[i]) s.insert(a[v]);
ans = min(ans, maxx);
}
printf("%d\n", ans);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x[5005];
struct hole {
int p, c;
bool operator<(const hole& other) const { return p < other.p; }
} h[5005];
long long d[2][5005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
for (int i = 1; i <= m; i++) {
cin >> h[i].p >> h[i].c;
h[i].c = min(h[i].c, n);
}
sort(x + 1, x + n + 1);
sort(h + 1, h + m + 1);
memset(d, 63, sizeof(d));
d[0][0] = 0;
for (int i = 1; i <= m; i++) {
auto nu = d[i % 2];
auto ol = d[1 - i % 2];
nu[0] = 0;
int k = 0;
for (int j = 1; j <= n; j++) {
nu[j] = nu[j - 1] + abs(x[j] - h[i].p);
while (k < j) {
long long delta = ol[k + 1] - ol[k] - abs(x[k + 1] - h[i].p);
if (delta < 0 || j - k > h[i].c) {
nu[j] += delta;
k++;
} else {
break;
}
}
}
}
long long sol = d[m % 2][n];
if (sol > 1e16) {
sol = -1;
}
cout << sol;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
vector<int> l, r;
vector<vector<int>> dp;
vector<vector<int>> rg;
int fun(int l, int r) {
if (l > r) return (0);
if (dp[l][r] != -1) return (dp[l][r]);
bool num = count(rg[l].begin(), rg[l].end(), r);
dp[l][r] = num;
if (l + 1 <= r) dp[l][r] = num + fun(l + 1, r);
for (auto x : rg[l]) {
if (x >= r) continue;
int p;
if ((x + 1) > r)
p = 0;
else
p = fun(x + 1, r);
dp[l][r] = max(dp[l][r], num + fun(l, x) + p);
}
return (dp[l][r]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v;
l = vector<int>(n);
r = vector<int>(n);
for (int i = 0; i < (int)(n); ++i) {
cin >> l[i] >> r[i];
v.push_back(l[i]);
v.push_back(r[i]);
}
sort(v.begin(), v.end());
auto it = unique(v.begin(), v.end());
v.resize(distance(v.begin(), it));
for (int i = 0; i < (int)(n); ++i) {
l[i] = lower_bound(v.begin(), v.end(), l[i]) - v.begin();
r[i] = lower_bound(v.begin(), v.end(), r[i]) - v.begin();
}
int nn = v.size();
dp = vector<vector<int>>(nn, vector<int>(nn, -1));
rg = vector<vector<int>>(nn);
for (int i = 0; i < (int)(n); ++i) {
rg[l[i]].push_back(r[i]);
}
cout << fun(0, nn - 1) << "\n";
}
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
int main() {
int n;
cin >> n;
int R1[n];
for (int i = 0; i < n; i++) {
cin >> R1[i];
}
sort(R1, R1 + n);
int m;
cin >> m;
int P1[m];
for (int i = 0; i < m; i++) {
cin >> P1[i];
}
sort(P1, P1 + m);
int k;
cin >> k;
int P2[k];
for (int i = 0; i < k; i++) {
cin >> P2[i];
}
sort(P2, P2 + k);
double a, b;
cin >> a >> b;
double ans = (R1[n - 1] * R1[n - 1]) /
(((double)a / b) * ((double)P2[0] / P1[m - 1]) + 1);
cout << setprecision(12) << sqrt(ans);
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, vis[N], in[N], d[N];
vector<int> e[N], g[N], s;
int ask(int u, int v) {
printf("? %d %d\n", u, v);
fflush(stdout);
int x;
scanf("%d", &x);
return x;
}
void dfs(int u) {
vis[u] = in[u] = 1;
for (auto v : e[u]) {
if (!in[v]) g[u].push_back(v), d[v]++;
if (!vis[v]) dfs(v);
}
in[u] = 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (int i = 1; i <= n; i++)
if (!d[i]) s.push_back(i);
while (s.size() > 1) {
int u = s.back();
s.pop_back();
int v = s.back();
s.pop_back();
if (!ask(u, v)) swap(u, v);
s.push_back(u);
for (auto w : g[v])
if (!--d[w]) s.push_back(w);
}
printf("! %d\n", s[0]);
return 0;
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, md = 1e9 + 7;
int n, m, ans, fac[N], iv[N], pn[N], pm[N], k;
inline int pow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = (unsigned long long)a * a % md)
if (b & 1) res = (unsigned long long)res * a % md;
return res;
}
inline int C(int n, int m) {
return (n >= m) ? (unsigned long long)fac[n] * iv[m] % md * iv[n - m] % md
: 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m, k = max(n, m);
for (int i = *fac = *pn = *pm = 1; i <= k; ++i)
fac[i] = (unsigned long long)fac[i - 1] * i % md,
pn[i] = (unsigned long long)pn[i - 1] * n % md,
pm[i] = (unsigned long long)pm[i - 1] * m % md;
iv[k] = pow(fac[k], md - 2);
for (int i = k - 1; ~i; --i) iv[i] = (i + 1uLL) * iv[i + 1] % md;
ans = (unsigned long long)C(m - 1, n - 2) % md * fac[n - 2] % md;
for (int i = 0; i < n - 2; ++i)
ans = (ans + (i + 2uLL) * C(n - 2, i) % md * C(m - 1, i) % md * fac[i] %
md * pn[n - i - 3] % md * pm[n - i - 2]) %
md;
cout << ans << '\n';
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, k;
cin >> n >> k;
while (n > 0) {
for (int i = 0; i < k; i++) {
cout << char(97 + i);
n--;
if (n == 0) break;
}
}
cout << endl;
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long ans, m, p, h[100005], a[100005], now[100005];
struct node {
long long v;
int x;
friend bool operator<(node a, node b) { return a.v > b.v; }
};
priority_queue<node> q;
bool check(long long mid) {
for (int i = 1; i <= n; i++) {
now[i] = mid;
if (now[i] - m * a[i] < 0) q.push((node){now[i] / a[i], i});
}
int cnt = 0;
for (; cnt <= m * k; cnt++) {
if (q.empty()) break;
node tmp = q.top();
q.pop();
if (tmp.v <= cnt / k) return 0;
now[tmp.x] += p;
if (now[tmp.x] - m * a[tmp.x] < 0)
q.push((node){now[tmp.x] / a[tmp.x], tmp.x});
}
if (cnt > k * m) return 0;
for (int i = 1; i <= n; i++) {
long long tmp = m * a[i] + h[i] - now[i];
if (tmp > 0) cnt += (tmp / p) + (long long)(tmp % p != 0);
if (cnt > k * m) return 0;
}
return 1;
}
int main() {
scanf("%d%lld%d%lld", &n, &m, &k, &p);
for (int i = 1; i <= n; i++) scanf("%lld%lld", &h[i], &a[i]);
long long l = 1, r = 1e15, ans = r;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
while (!q.empty()) q.pop();
}
printf("%lld\n", ans);
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
struct treenode {
int rev, sum, max, maxl, maxr, min, minl, minr;
int maxposl, maxposr, maxlpos, maxrpos, minposl, minposr, minlpos, minrpos;
};
treenode tree[400000];
treenode tmp;
int g[120000];
int u[30], v[30];
int i, j, m, n, s, t, w, x, y, z;
inline int fastscanf() {
int t = 0, p = 1;
char c = getchar();
while (!(((c > 47) && (c < 58)) || (c == '-'))) c = getchar();
if (c == '-') p = -1, c = getchar();
while ((c > 47) && (c < 58)) t = t * 10 + c - 48, c = getchar();
return t * p;
}
inline treenode merge(const treenode &l, const treenode &r) {
treenode t;
t.rev = 0;
t.sum = l.sum + r.sum;
if (l.maxl > l.sum + r.maxl)
t.maxl = l.maxl, t.maxlpos = l.maxlpos;
else
t.maxl = l.sum + r.maxl, t.maxlpos = r.maxlpos;
if (r.maxr > r.sum + l.maxr)
t.maxr = r.maxr, t.maxrpos = r.maxrpos;
else
t.maxr = r.sum + l.maxr, t.maxrpos = l.maxrpos;
if (l.max > r.max)
t.max = l.max, t.maxposl = l.maxposl, t.maxposr = l.maxposr;
else
t.max = r.max, t.maxposl = r.maxposl, t.maxposr = r.maxposr;
if (l.maxr + r.maxl > t.max)
t.max = l.maxr + r.maxl, t.maxposl = l.maxrpos, t.maxposr = r.maxlpos;
if (l.minl < l.sum + r.minl)
t.minl = l.minl, t.minlpos = l.minlpos;
else
t.minl = l.sum + r.minl, t.minlpos = r.minlpos;
if (r.minr < r.sum + l.minr)
t.minr = r.minr, t.minrpos = r.minrpos;
else
t.minr = r.sum + l.minr, t.minrpos = l.minrpos;
if (l.min < r.min)
t.min = l.min, t.minposl = l.minposl, t.minposr = l.minposr;
else
t.min = r.min, t.minposl = r.minposl, t.minposr = r.minposr;
if (l.minr + r.minl < t.min)
t.min = l.minr + r.minl, t.minposl = l.minrpos, t.minposr = r.minlpos;
return t;
}
inline void pushdown(int l, int r, int node) {
if (tree[node].rev) {
tree[node] = (treenode){0,
-tree[node].sum,
-tree[node].min,
-tree[node].minl,
-tree[node].minr,
-tree[node].max,
-tree[node].maxl,
-tree[node].maxr,
tree[node].minposl,
tree[node].minposr,
tree[node].minlpos,
tree[node].minrpos,
tree[node].maxposl,
tree[node].maxposr,
tree[node].maxlpos,
tree[node].maxrpos};
if (l != r) {
tree[node << 1].rev = tree[node << 1].rev ^ 1;
tree[node << 1 | 1].rev = tree[node << 1 | 1].rev ^ 1;
}
}
return;
}
inline void pushup(int l, int r, int node) {
int mid = (l + r) >> 1;
pushdown(l, mid, node << 1);
pushdown(mid + 1, r, node << 1 | 1);
tree[node] = merge(tree[node << 1], tree[node << 1 | 1]);
return;
}
inline void buildtree(int l, int r, int node) {
if (l == r)
tree[node] = (treenode){0, g[l], g[l], g[l], g[l], g[l], g[l], g[l],
l, l, l, l, l, l, l, l};
else {
int mid = (l + r) >> 1;
buildtree(l, mid, node << 1);
buildtree(mid + 1, r, node << 1 | 1);
pushup(l, r, node);
}
return;
}
inline void inserttree(int l, int r, int x, int y, int node) {
pushdown(l, r, node);
if (l == r)
tree[node] = (treenode){0, y, y, y, y, y, y, y, l, l, l, l, l, l, l, l};
else {
int mid = (l + r) >> 1;
if (x <= mid)
inserttree(l, mid, x, y, node << 1);
else
inserttree(mid + 1, r, x, y, node << 1 | 1);
pushup(l, r, node);
}
return;
}
inline void reversetree(int l, int r, int x, int y, int node) {
pushdown(l, r, node);
if ((l == x) && (r == y))
tree[node].rev = tree[node].rev ^ 1;
else {
int mid = (l + r) >> 1;
if (y <= mid)
reversetree(l, mid, x, y, node << 1);
else if (x > mid)
reversetree(mid + 1, r, x, y, node << 1 | 1);
else {
reversetree(l, mid, x, mid, node << 1);
reversetree(mid + 1, r, mid + 1, y, node << 1 | 1);
}
pushup(l, r, node);
}
return;
}
inline treenode asktree(int l, int r, int x, int y, int node) {
pushdown(l, r, node);
if ((l == x) && (r == y)) return tree[node];
int mid = (l + r) >> 1;
if (y <= mid) return asktree(l, mid, x, y, node << 1);
if (x > mid) return asktree(mid + 1, r, x, y, node << 1 | 1);
treenode t1 = asktree(l, mid, x, mid, node << 1);
treenode t2 = asktree(mid + 1, r, mid + 1, y, node << 1 | 1);
return merge(t1, t2);
}
int main() {
n = fastscanf();
for (i = 1; i <= n; i++) g[i] = fastscanf();
buildtree(1, n, 1);
m = fastscanf();
for (i = 1; i <= m; i++) {
t = fastscanf();
if (t == 0) {
x = fastscanf(), y = fastscanf();
inserttree(1, n, x, y, 1);
} else {
x = fastscanf(), y = fastscanf(), z = fastscanf();
w = 0, s = 0;
for (j = 1; j <= z; j++) {
tmp = asktree(1, n, x, y, 1);
if (tmp.max <= 0) break;
s = s + tmp.max;
reversetree(1, n, tmp.maxposl, tmp.maxposr, 1);
w++, u[w] = tmp.maxposl, v[w] = tmp.maxposr;
}
printf("%d\n", s);
for (j = w; j > 0; j--) reversetree(1, n, u[j], v[j], 1);
}
}
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
auto match = [](string s, string t) -> int {
assert(s.size() == t.size() && s.size() == 2);
return (s[0] == '_' || s[0] == t[0]) && (s[1] == '_' || s[1] == t[1]);
};
auto solve = [&](string s) -> int {
if (s.size() == 1) {
if (s[0] == '_' || s[0] == '0') return 1;
return 0;
}
if (s[0] == '0') return 0;
if (s.size() == 2) {
int ret = 0;
ret += match(s, "25");
ret += match(s, "50");
ret += match(s, "75");
return ret;
}
int n = s.size();
string p2 = s.substr(s.size() - 2);
int ret = 0;
ret += match(p2, "00");
ret += match(p2, "25");
ret += match(p2, "50");
ret += match(p2, "75");
int cnt = 1;
for (int i = 0; i < s.size() - 2; ++i) {
if (s[i] == '_') {
int tmp = 0;
if (s[i] == '_') tmp += (!!i) + 9;
cnt *= tmp;
}
}
return ret * cnt;
};
if (count(s.begin(), s.end(), 'X')) {
int ans = 0;
for (int x = 0; x <= 9; ++x) {
string t = s;
for (char &c : t)
if (c == 'X') c = '0' + x;
ans += solve(t);
}
cout << ans << '\n';
} else {
cout << solve(s) << '\n';
}
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int A[100010], B[100010], f[1000];
bool cmp(int aa, int bb) { return aa > bb; }
bool vis[1000];
int n, m, an = 0, dn = 0;
int solve(int def) {
int i = 1, top = 1;
if (def == 1) top = an;
int kill = 0, sum = 0;
int ret = 0;
for (; top <= an; top++) {
i = top;
sum = 0;
for (int j = m; j >= 1; j--)
if (!vis[j]) {
if (def) sum += f[j];
if (i > 0 && f[j] >= A[i]) {
sum += f[j] - A[i];
if (def) sum -= f[j];
kill++;
}
i--;
}
if (!def) ret = max(ret, sum);
}
if (def && kill == an) return sum;
if (def) return -100000;
if (!def) return ret;
}
int main() {
cin >> n >> m;
string s;
int t;
for (int i = 1; i <= n; i++) {
cin >> s >> t;
if (s[0] == 'D')
B[++dn] = t;
else
A[++an] = t;
}
for (int i = 1; i <= m; i++) cin >> f[i];
int ans = 0;
sort(A + 1, A + 1 + an);
sort(B + 1, B + 1 + dn);
sort(f + 1, f + 1 + m);
int temp = 0, j = 1, cnt = 0;
for (int i = 1; i <= dn; i++) {
while (j <= m && f[j] <= B[i]) j++;
if (j <= m && f[j] > B[i]) {
cnt++;
vis[j] = true;
j++;
}
}
if (cnt == dn) ans += solve(1);
memset(vis, false, sizeof(vis));
ans = max(ans, solve(0));
cout << max(ans, 0) << endl;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
struct BIT {
long long n;
vector<long long> bit;
BIT(long long sz) {
bit.resize(sz + 1);
n = sz;
}
long long sum(long long i) {
long long s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(long long i, long long x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n, t;
cin >> n >> t;
vector<long long> a(n);
for (long long i = 0, i_len = (n); i < i_len; ++i) {
cin >> a[i];
}
vector<long long> sum(n + 1, 0);
for (long long i = 0, i_len = (n); i < i_len; ++i) {
sum[i + 1] = sum[i] + a[i];
}
auto usum = sum;
sort(usum.begin(), usum.end());
usum.erase(unique(usum.begin(), usum.end()), usum.end());
map<long long, long long> cmap;
for (long long i = 0, i_len = (usum.size()); i < i_len; ++i)
cmap[usum[i]] = i + 1;
BIT bit(n + 1);
long long ans = 0;
for (long long r = (0), r_len = (n); r <= r_len; ++r) {
long long i =
upper_bound(usum.begin(), usum.end(), sum[r] - t) - usum.begin();
ans += r - (i > 0 ? bit.sum(i) : 0);
bit.add(cmap[sum[r]], 1);
}
cout << ans << endl;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
vector<int> name, pseu;
vector<pair<int, int>> vet;
long long sum = 0;
struct Trie {
vector<int> N, P;
map<char, Trie> children;
int h;
void insert(string &str, bool is_name, int x, int pos) {
if (pos < (int)str.size()) {
if (children.find(str[pos]) == children.end())
children[str[pos]].h = h + 1;
children[str[pos]].insert(str, is_name, x, pos + 1);
} else if (is_name)
N.push_back(x);
else
P.push_back(x);
}
pair<int, int> dfs() {
int x = 0, y = 0;
for (int i : N) name.push_back(i), x++;
N.clear();
for (int i : P) pseu.push_back(i), y++;
P.clear();
for (auto i = children.begin(); i != children.end(); i++) {
auto aux = i->second.dfs();
x += aux.first;
y += aux.second;
}
while (x and y) {
vet.push_back({name.back(), pseu.back()});
x--;
y--;
name.pop_back();
pseu.pop_back();
sum += h;
}
return {x, y};
}
};
int main() {
int n;
cin >> n;
Trie trie;
trie.h = 0;
for (int i = 1; i <= n; i++) {
string str;
cin >> str;
trie.insert(str, true, i, 0);
}
for (int i = 1; i <= n; i++) {
string str;
cin >> str;
trie.insert(str, false, i, 0);
}
trie.dfs();
printf("%lld\n", sum);
for (auto i : vet) printf("%d %d\n", i.first, i.second);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool Up(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool Down(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
inline int getus() {
int tmp, c;
while (tmp = fgetc(stdin), tmp < '0' || tmp > '9')
;
tmp -= '0';
while (c = fgetc(stdin), '0' <= c && c <= '9') tmp = tmp * 10 + c - '0';
return tmp;
}
inline int getint() {
int tmp, c, flag;
while (flag = fgetc(stdin), flag != '-' && (flag < '0' || flag > '9'))
;
if (flag == '-')
tmp = 0;
else
tmp = flag - '0';
while (c = fgetc(stdin), '0' <= c && c <= '9') tmp = tmp * 10 + c - '0';
return flag == '-' ? -tmp : tmp;
}
int R, C, N, vis[400023], done[400023], ansR[400023], ansC[400023];
int s[400023], d1[400023], d2[400023];
vector<vector<int> > cycles_1, cycles_2;
int lex_smallest_head(string s) {
int n = s.size(), i = 0, j = 1, k = 0;
s += s;
while (j < n && k < n) {
if (s[i + k] == s[j + k])
k++;
else {
if (s[i + k] < s[j + k])
j += k + 1;
else
i += k + 1;
k = 0;
}
if (i == j) ++j;
}
return i;
}
inline int encode(char c, int x) {
if (c == 'L') return x;
if (c == 'T') return x + R;
if (c == 'R') return x + N;
if (c == 'B') return x + N + R;
assert(0);
return -1;
}
inline pair<char, int> decode(int x) {
if (x < R) return pair<char, int>('L', x);
if (x < N) return pair<char, int>('T', x - R);
if (x < N + R) return pair<char, int>('R', x - N);
if (x < N + N) return pair<char, int>('B', x - N - R);
assert(0);
return pair<char, int>('_', -1);
}
inline int opposite(int x) {
if (x < N) return x + N;
return x - N;
}
inline string getProfile(const vector<int> &cycle) {
string res(cycle.size(), '\0');
int size = cycle.size();
for (int i = (0); i < (size); ++i) res[i] = decode(cycle[i]).first;
return res;
}
inline int getType(const vector<int> &cycle) {
if (cycle.size() != 8) return 0;
string s = getProfile(cycle);
if (s == "LTBLRBTR") return 1;
if (s == "LBTLRTBR") return 2;
return 0;
}
void DFS(int x, int *next, vector<int> &to) {
if (vis[x]) return;
vis[x] = true;
to.push_back(x);
DFS(next[x], next, to);
DFS(opposite(x), next, to);
}
void shift(vector<int> &s, int shift) {
vector<int> tmp(s);
int size = s.size();
for (int i = (0); i < (size); ++i) s[i] = tmp[(i + shift) % size];
}
bool match(int *next) {
vector<vector<int> > S, T;
for (int i = 0, size = cycles_2.size(); i < size; ++i) {
vector<int> &c = cycles_2[i];
string tmp = getProfile(c);
shift(c, lex_smallest_head(tmp));
S.push_back(c);
}
memcpy(vis, done, sizeof(vis));
for (int i = (0); i < (N); ++i)
if (!vis[i]) {
vector<int> c;
DFS(i, next, c);
string tmp = getProfile(c);
shift(c, lex_smallest_head(tmp));
T.push_back(c);
}
int n = S.size();
if (n != (int)T.size()) return false;
if (n == 0) return true;
int m = S[0].size();
for (int i = (0); i < (n); ++i)
if (m != (int)T[i].size()) return false;
sort(S.begin(), S.end());
sort(T.begin(), T.end());
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
int s = S[i][j], t = T[i][j];
pair<char, int> ss(decode(s)), tt(decode(t));
if (ss.first != tt.first) return false;
if (ss.first == 'L' || ss.first == 'R')
ansR[tt.second] = ss.second;
else
ansC[tt.second] = ss.second;
}
return true;
}
int main() {
memset(vis, 0, sizeof(vis));
memset(done, 0, sizeof(done));
scanf("%d %d\n", &R, &C);
N = R + C;
for (int i = (0); i < (N); ++i) {
char c1, c2;
int x1, x2, p1, p2;
scanf("%c %c %d %d\n", &c1, &c2, &x1, &x2);
p1 = encode(c1, --x1);
p2 = encode(c2, --x2);
s[p1] = p2;
s[p2] = p1;
}
for (int i = (0); i < (N); ++i)
if (!vis[i]) {
vector<int> cycle;
DFS(i, s, cycle);
if (getType(cycle))
cycles_1.push_back(cycle);
else
cycles_2.push_back(cycle);
}
int cnt = 0;
for (int size = cycles_1.size(), i = 0; i < size; ++i) {
const vector<int> &cycle = cycles_1[i];
int type = getType(cycle), a, b, c, d;
if (type == 1) {
ansR[i] = a = decode(cycle[0]).second;
ansR[R - 1 - i] = b = decode(cycle[3]).second;
ansC[i] = c = decode(cycle[1]).second;
ansC[C - 1 - i] = d = decode(cycle[6]).second;
} else {
ansR[i] = a = decode(cycle[3]).second;
ansR[R - 1 - i] = b = decode(cycle[0]).second;
ansC[i] = c = decode(cycle[2]).second;
ansC[C - 1 - i] = d = decode(cycle[5]).second;
}
done[encode('L', i)] = done[encode('L', R - 1 - i)] = 1;
done[encode('R', i)] = done[encode('R', R - 1 - i)] = 1;
done[encode('T', i)] = done[encode('T', C - 1 - i)] = 1;
done[encode('B', i)] = done[encode('B', C - 1 - i)] = 1;
}
vector<int> o(N + N, 0);
cnt = 0;
for (int i = (R - 1); i >= (0); --i)
if (!done[i]) o[cnt++] = i;
for (int i = (0); i < (C); ++i)
if (!done[i + R]) o[cnt++] = i + R;
for (int i = (0); i < (R); ++i)
if (!done[i + N]) o[cnt++] = i + N;
for (int i = (C - 1); i >= (0); --i)
if (!done[i + N + R]) o[cnt++] = i + N + R;
for (int i = (0); i < (cnt); ++i) d1[o[i]] = o[cnt - 1 - i];
cnt = 0;
for (int i = (0); i < (R); ++i)
if (!done[i]) o[cnt++] = i;
for (int i = (0); i < (C); ++i)
if (!done[i + N + R]) o[cnt++] = i + N + R;
for (int i = (R - 1); i >= (0); --i)
if (!done[i + N]) o[cnt++] = i + N;
for (int i = (C - 1); i >= (0); --i)
if (!done[i + R]) o[cnt++] = i + R;
for (int i = (0); i < (cnt); ++i) d2[o[i]] = o[cnt - 1 - i];
if (match(d1) || match(d2)) {
for (int i = (0); i < (R); ++i)
printf("%d%c", ansR[i] + 1, (i == R - 1) ? '\n' : ' ');
for (int i = (0); i < (C); ++i)
printf("%d%c", ansC[i] + 1, (i == C - 1) ? '\n' : ' ');
} else
puts("No solution");
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
int fx[] = {1, -1, 0, 0};
int fy[] = {0, 0, 1, -1};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int tc = 1; tc <= t; tc++) {
int n;
cin >> n;
cout << fixed << setprecision(10)
<< cos(acos(-1.0) / (4 * n)) / sin(acos(-1.0) / (2 * n)) << '\n';
}
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647, MOD = 1000 * 1000 * 1000 + 7;
const double eps = 1e-8;
const int sz = 2200;
int n, m, orig[sz], base;
bool les(int a[sz], int b[sz]) {
for (int i = 0; i < (m + 1); i++) {
if (a[i] < b[i]) return true;
if (a[i] > b[i]) return false;
}
return false;
}
int arr[sz], arr_yes = -1;
int nw[sz];
bool edge[110][110];
void f(int cur, int cnt, bool good_orig, bool good_arr) {
nw[cnt] = cur;
if (!good_orig) {
if (nw[cnt] < orig[cnt]) return;
if (nw[cnt] > orig[cnt]) good_orig = true;
}
if (!good_arr && arr_yes != -1) {
if (nw[cnt] < arr[cnt]) good_arr = true;
if (nw[cnt] > arr[cnt]) return;
}
if (cnt == m) {
if (!les(orig, nw)) return;
bool good = (arr_yes == -1);
if (!good) good = les(nw, arr);
if (good) {
arr_yes = 1;
for (int i = 0; i < (m + 1); i++) arr[i] = nw[i];
}
return;
}
for (int i = 1; i <= (n); i++) {
if (edge[cur][i]) {
edge[cur][i] = edge[i][cur] = false;
f(i, cnt + 1, good_orig, good_arr);
edge[cur][i] = edge[i][cur] = true;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < (m + 1); i++) {
cin >> orig[i];
if (i > 0) {
int a = orig[i - 1], b = orig[i];
edge[a][b] = edge[b][a] = true;
} else
base = arr[0] = nw[0] = orig[i];
}
for (int i = 1; i <= (n); i++) {
if (edge[base][i]) {
edge[base][i] = edge[i][base] = false;
f(i, 1, false, false);
edge[base][i] = edge[i][base] = true;
}
}
if (arr_yes != -1) {
for (int i = 0; i < (m + 1); i++) cout << arr[i] << ' ';
cout << endl;
} else
cout << "No solution\n";
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> ws >> s2;
int t;
cin >> t;
vector<pair<string, string> > v;
for (int i = 0; i < t; i++) {
string a, b;
cin >> a >> ws >> b;
v.push_back(make_pair(a, b));
}
cout << s1 << " " << s2 << endl;
for (int i = 0; i < t; i++) {
if (s1 == v[i].first) {
s1 = v[i].second;
cout << s1 << " " << s2 << endl;
} else if (s2 == v[i].first) {
s2 = v[i].second;
cout << s1 << " " << s2 << endl;
}
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct point {
long long x, y;
} p[100010], o;
inline long long cross(point a, point b, point c) {
return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
}
inline bool cmp(point x, point y) { return cross(o, x, y) > 0; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d%I64d", &p[i].x, &p[i].y);
p[n] = p[0];
for (scanf("%d", &m); m; m--) {
scanf("%I64d%I64d", &o.x, &o.y);
bool flag = true;
for (int i = 0; i < n; i++)
if (cross(p[i], p[i + 1], o) > 0) {
cout << 0 << endl;
flag = false;
break;
}
if (!flag) continue;
int i = 0, j = 0;
long long ans = (long long)n * (n - 1) * (n - 2) / 6;
for (; i < n; i++) {
while (j - i < n && cross(p[i], o, p[j % n]) >= 0) j++;
ans -= (long long)(j - i - 2) * (j - i - 1) / 2;
}
cout << ans << endl;
}
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
char in[1011], in1[1000011];
int main() {
int i, j, k;
scanf("%s%s", in, in1);
for (i = j = 0; in[i] && in1[j]; j++) {
if (in[i] == in1[j]) {
i++;
}
}
k = j;
while (in[i]) {
i++;
}
while (in1[k]) {
k++;
}
for (i--, k--; ~i && ~k; k--) {
if (in[i] == in1[k]) {
i--;
}
}
if (k < j - 1) {
cout << 0 << endl;
} else {
cout << k - j + 2 << endl;
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
int cnt = 1, a[n], l, r;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int cur_sec = 1, cur = i;
l = i - 1, r = i + 1;
while (l >= 0) {
if (a[l] <= a[cur]) cur_sec++;
if (a[l - 1] > a[l] || (l - 1) < 0) break;
l--;
}
while (r < n) {
if (a[r] <= a[cur]) cur_sec++;
if (a[r + 1] > a[r] || (r + 1) > n) break;
r++;
}
cnt = max(cnt, cur_sec);
}
cout << cnt;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxN = 1E5 + 10;
const long long int mod = 1E9 + 7;
const long long int INF = 1E9;
int32_t main() {
long long int n;
cin >> n;
long long int turn = 1, ind = 1;
vector<long long int> otp;
while (turn < n) {
ind += turn;
ind %= n;
if (ind == 0) ind = n;
turn++;
otp.push_back(ind);
}
for (long long int i = 0; i < otp.size(); ++i) cout << otp[i] << ' ';
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int n, _2[200010];
struct sa {
char s[200010];
int rk[200010], sa[200010], id[200010], b[200010];
int mn[200010][23];
bool opt;
void sa_sort(int m) {
for (int i = 1; i <= m; i++) b[i] = 0;
for (int i = 1; i <= n; i++) b[rk[i]]++;
for (int i = 1; i <= m; i++) b[i] += b[i - 1];
for (int i = n; i; i--) sa[b[rk[id[i]]]--] = id[i];
}
void init(bool op) {
int m = 26;
opt = op;
for (int i = 1; i <= n; i++) rk[i] = s[i] - 'A' + 1, id[i] = i;
sa_sort(m);
for (int p = 1, t = 0; p < n; p <<= 1, m = t, t = 0) {
for (int i = 1; i <= p; i++) id[++t] = n - p + i;
for (int i = 1; i <= n; i++)
if (sa[i] > p) id[++t] = sa[i] - p;
sa_sort(m);
swap(rk, id);
rk[sa[1]] = t = 1;
for (int i = 2; i <= n; i++)
rk[sa[i]] = (t += id[sa[i]] != id[sa[i - 1]] ||
id[sa[i] + p] != id[sa[i - 1] + p]);
}
if (op) {
for (int i = 1; i <= n; i++) mn[i][0] = sa[i];
for (int k = 1; k <= _2[n]; k++)
for (int i = 1; i + (1 << k) - 1 <= n; i++)
mn[i][k] = min(mn[i][k - 1], mn[i + (1 << (k - 1))][k - 1]);
} else {
for (int i = 1; i <= n; i++) mn[i][0] = n - sa[i] + 1;
for (int k = 1; k <= _2[n]; k++)
for (int i = 1; i + (1 << k) <= n; i++)
mn[i][k] = max(mn[i][k - 1], mn[i + (1 << (k - 1))][k - 1]);
}
}
int get(int l, int r) {
int k = _2[r - l + 1];
return opt ? min(mn[l][k], mn[r - (1 << k) + 1][k])
: max(mn[l][k], mn[r - (1 << k) + 1][k]);
}
int lower_bound(int l, int r, int len, char c) {
int res = r + 1;
while (l <= r) {
int mid = (l + r) >> 1, p = sa[mid] + len - 1;
if (p <= n && s[p] >= c)
r = mid - 1, res = mid;
else
l = mid + 1;
}
return res;
}
} s1, s2;
int pre[200010], suf[200010];
char s[200010], rs[200010];
int main() {
scanf("%s", s1.s + 1);
n = strlen(s1.s + 1);
for (int i = 2; i <= n; i++) _2[i] = _2[i >> 1] + 1;
for (int i = 1; i <= n; i++) s2.s[n - i + 1] = s1.s[i];
s1.init(1);
s2.init(0);
int q, ans = 0;
scanf("%d", &q);
while (q-- > 0) {
scanf("%s", s + 1);
int m = strlen(s + 1);
for (int i = 1; i <= m; i++) pre[i] = suf[i] = -1;
for (int i = 1; i <= m; i++) rs[m - i + 1] = s[i];
int l = 1, r = n;
for (int i = 1; i <= m; i++) {
r = s1.lower_bound(l, r, i, s[i] + 1) - 1;
l = s1.lower_bound(l, r, i, s[i]);
if (l > r || l < 0) break;
pre[i] = s1.get(l, r);
}
l = 1, r = n;
for (int i = 1; i <= m; i++) {
r = s2.lower_bound(l, r, i, rs[i] + 1) - 1;
l = s2.lower_bound(l, r, i, rs[i]);
if (l > r) break;
suf[i] = s2.get(l, r);
}
for (int i = 1; i <= m; i++)
if (suf[m - i] != -1 && pre[i] != -1)
if (suf[m - i] - pre[i] + 1 >= m) {
ans++;
break;
}
}
printf("%d\n", ans);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b;
scanf("%d%d%d", &r, &g, &b);
int time = 0;
while (1) {
if (time % 3 == 0) r -= 2;
if (time % 3 == 1) g -= 2;
if (time % 3 == 2) b -= 2;
if (r <= 0 && g <= 0 && b <= 0) break;
time++;
}
time += 30;
printf("%d\n", time);
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 2e9;
const long long INFLL = 1e18;
const int MAX_N = 1000;
vector<int> vt;
vector<pair<int, int> > v;
int ans[MAX_N + 10][MAX_N + 10];
int N;
int idx[MAX_N + 1];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
int x;
scanf("%d", &x);
vt.push_back(x);
v.push_back({x, i});
}
sort(v.begin(), v.end());
for (int i = 0; i < N; i++) {
idx[v[i].second] = i + 1;
}
sort(vt.begin(), vt.end());
for (int i = 1; i <= N; i++) {
int n = vt[i - 1];
if (n >= i) {
int now = 1, cnt = n;
while (cnt > 0) {
if (now == i + 1) {
now++;
continue;
}
ans[now][i] = 1;
cnt--;
now++;
}
} else {
int now = i;
while (n > 0) {
ans[now][i] = 1;
n--;
now--;
}
}
}
int num = 0;
for (int i = 1; i <= N + 1; i++) {
for (int j = 1; j <= N; j++) {
if (ans[i][j] == 1) {
num++;
break;
}
}
}
printf("%d\n", num);
for (int i = 1; i <= num; i++) {
for (int j = 1; j <= N; j++) {
printf("%d", ans[i][idx[j]]);
}
printf("\n");
}
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
vector<vector<pair<int, int>>> x(10005);
cin >> n >> m;
for (int i = 1; i <= n; i++) x[i].push_back(make_pair(i, i));
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
if (a == b) continue;
if (a > b) swap(a, b);
x[a].push_back(make_pair(a, 1000 * a + b));
x[b].push_back(make_pair(b, 1000 * a + b));
}
for (int i = 1; i <= n; i++) {
cout << x[i].size() << endl;
for (int j = 0; j < x[i].size(); j++)
cout << x[i][j].first << " " << x[i][j].second << endl;
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
int num = 1;
cin >> n;
for (int i = 1; i < n; i++) {
if ((num + i) <= n) {
num = num + i;
cout << num << " ";
} else {
num = num + i - n;
cout << num << " ";
}
}
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cout << fixed << setprecision(15);
solve();
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int X, Y;
char grid[9][9];
bool all_filled(int x, int y) {
for (int i = 3 * x; i <= 3 * x + 2; i++)
for (int j = 3 * y; j <= 3 * y + 2; j++)
if (grid[i][j] == '.') return false;
return true;
}
int main() {
ios::sync_with_stdio(0);
for (int i = 0; i < 9; i++) {
string s1, s2, s3;
cin >> s1 >> s2 >> s3;
string s = s1 + s2 + s3;
for (int j = 0; j < 9; j++) grid[i][j] = s[j];
}
cin >> X >> Y;
X--, Y--;
X %= 3, Y %= 3;
if (all_filled(X, Y)) {
for (int i = 0; i < 9; i++)
for (int j = 0; j < 9; j++)
if (grid[i][j] == '.') grid[i][j] = '!';
} else {
for (int i = 3 * X; i <= 3 * X + 2; i++)
for (int j = 3 * Y; j <= 3 * Y + 2; j++)
if (grid[i][j] == '.') grid[i][j] = '!';
}
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
cout << grid[i][j];
if (j % 3 == 2) cout << " ";
}
cout << "\n";
if (i % 3 == 2) cout << "\n";
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
#pragma comment(linker, "/Stack:256000000")
using namespace std;
int main() {
string R = "RIGHT\n", L = "LEFT\n", P = "PRINT ";
int n, k;
char s[150];
scanf("%d%d\n%s", &n, &k, &s);
int id = (k > n / 2) ? 1 : 0;
if (id) {
for (int i = 0; i < n - k; ++i) printf("%s", R.data());
int i = n;
while (i != 1) {
printf("%s %c\n%s", P.data(), s[i - 1], L.data());
--i;
}
printf("%s %c", P.data(), s[0]);
} else {
for (int i = k; i > 1; --i) printf("%s", L.data());
int i = 0;
while (i != n - 1) {
printf("%s %c\n%s", P.data(), s[i], R.data());
++i;
}
printf("%s %c", P.data(), s[n - 1]);
}
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
char mp[2005][2005];
int dp[2005][2005];
int main() {
int n, m;
int sum = 0;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
getchar();
for (int j = 1; j <= m; j++) {
scanf("%c", &mp[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j] = 1;
if (i >= 3 && j >= 2 && mp[i][j] == mp[i - 2][j] &&
mp[i][j] == mp[i - 1][j - 1] && mp[i][j] == mp[i - 1][j + 1] &&
mp[i][j] == mp[i - 1][j]) {
dp[i][j] =
min(dp[i - 2][j], min(dp[i - 1][j - 1], dp[i - 1][j + 1])) + 1;
}
sum += dp[i][j];
}
}
cout << sum << endl;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int lmx[1600005], rmx[1600005], lmn[1600005], rmn[1600005], sum[1600005],
lans[1600005], rans[1600005], whans[1600005], mans[1600005];
void upd(int now) {
sum[now] = sum[now << 1] + sum[now << 1 | 1];
lmx[now] = max(lmx[now << 1], sum[now << 1] + lmx[now << 1 | 1]);
rmx[now] = max(rmx[now << 1 | 1], sum[now << 1 | 1] + rmx[now << 1]);
lmn[now] = min(lmn[now << 1], sum[now << 1] + lmn[now << 1 | 1]);
rmn[now] = min(rmn[now << 1 | 1], sum[now << 1 | 1] + rmn[now << 1]);
whans[now] = rmx[now] - lmn[now];
lans[now] = max(lans[now << 1], max(lans[now << 1 | 1] - sum[now << 1],
whans[now << 1] + lmx[now << 1 | 1]));
rans[now] = max(rans[now << 1 | 1], max(rans[now << 1] + sum[now << 1 | 1],
whans[now << 1 | 1] - rmn[now << 1]));
mans[now] = max(max(lans[now << 1 | 1] - rmn[now << 1],
rans[now << 1] + lmx[now << 1 | 1]),
max(mans[now << 1], mans[now << 1 | 1]));
}
void Insert(int now, int l, int r, int pos, int v) {
if (l == r) {
sum[now] = lmx[now] = rmx[now] = lmn[now] = rmn[now] = v;
lmx[now] = max(lmx[now], 0);
rmx[now] = max(rmx[now], 0);
lmn[now] = min(lmn[now], 0);
rmn[now] = min(rmn[now], 0);
lans[now] = rans[now] = whans[now] = mans[now] = 1;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
Insert(now << 1, l, mid, pos, v);
else
Insert(now << 1 | 1, mid + 1, r, pos, v);
upd(now);
}
int a[1600005];
void Build(int now, int l, int r) {
if (l == r) {
sum[now] = lmx[now] = rmx[now] = lmn[now] = rmn[now] = a[l];
lmx[now] = max(lmx[now], 0);
rmx[now] = max(rmx[now], 0);
lmn[now] = min(lmn[now], 0);
rmn[now] = min(rmn[now], 0);
lans[now] = rans[now] = whans[now] = mans[now] = 1;
return;
}
int mid = (l + r) >> 1;
Build(now << 1, l, mid), Build(now << 1 | 1, mid + 1, r);
upd(now);
}
int n, q;
char s[1600005];
int main() {
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = 1; i <= 2 * n - 2; i++)
if (s[i] == '(')
a[i] = 1;
else
a[i] = -1;
Build(1, 1, 2 * n - 2);
printf("%d\n", mans[1]);
for (int u, v; q--;) {
scanf("%d%d", &u, &v);
swap(a[u], a[v]);
Insert(1, 1, 2 * n - 2, u, a[u]);
Insert(1, 1, 2 * n - 2, v, a[v]);
printf("%d\n", mans[1]);
}
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int n, x, y, counter;
vector<int> nod[200005];
int dist[200005], parent[200005];
bool ap[200005];
void go_visit(int pos, int last) {
for (int i = 0; i < nod[pos].size(); i++) {
if (nod[pos][i] == last) continue;
parent[nod[pos][i]] = pos;
dist[nod[pos][i]] = dist[pos] + 1;
go_visit(nod[pos][i], pos);
if (dist[nod[pos][i]] > 2) {
ap[pos] = 1;
dist[pos] = 1;
dist[nod[pos][i]] = 2;
dist[parent[pos]] = min(2, dist[parent[pos]]);
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n - 1; i++) {
cin >> x >> y;
nod[x].push_back(y);
nod[y].push_back(x);
}
go_visit(1, 0);
for (int i = 1; i <= n; i++) counter += ap[i];
cout << counter;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
char a[110][110];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] != 'W' && a[i][j] != 'B' && a[i][j] != 'G') {
cout << "#Color" << endl;
return 0;
}
}
}
cout << "#Black&White" << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
} a[100010];
const double pi = acos(-1.0);
double d[100010], p[100010];
int n, m, tt;
inline int rd() {
int x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
int fa[400010][20], mx[400010];
pair<double, double> h[100010];
double num[200010];
inline double calc(double x) {
if (x < 0) x += pi * 2;
if (x >= pi * 2) x -= pi * 2;
return x;
}
inline bool check(double mid) {
for (int i = 1; i <= n; i++)
if (mid > d[i]) return false;
tt = 0;
for (int i = 1; i <= n; i++) {
double now = acos(mid / d[i]);
double h1 = calc(p[i] - now), h2 = calc(p[i] + now);
num[++tt] = h1;
num[++tt] = h2;
h[i] = pair<double, double>(h1, h2);
}
sort(num + 1, num + tt + 1);
tt = unique(num + 1, num + tt + 1) - num - 1;
for (int i = 0; i <= 18; i++) fa[tt * 2 + 1][i] = tt * 2 + 1;
for (int i = 1; i <= tt * 2; i++) mx[i] = tt * 2 + 1;
for (int i = 1; i <= n; i++) {
int l = lower_bound(num + 1, num + tt + 1, h[i].first) - num;
int r = lower_bound(num + 1, num + tt + 1, h[i].second) - num;
if (l <= r) {
mx[l - 1] = min(mx[l - 1], r);
mx[l - 1 + tt] = min(mx[l - 1 + tt], r + tt);
} else
mx[l - 1] = min(mx[l - 1], r + tt);
}
for (int i = tt * 2 - 1; i; i--) mx[i] = min(mx[i], mx[i + 1]);
for (int i = 1; i <= tt * 2; i++) fa[i][0] = mx[i];
for (int i = tt * 2; i; i--)
for (int j = 1; j <= 18; j++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
bool flag = false;
for (int i = 1; i <= tt; i++) {
int now = i;
for (int j = 18; ~j; j--)
if ((m >> j) & 1) now = fa[now][j];
if (now >= i + tt) flag = true;
}
return flag;
}
int main() {
n = rd();
m = rd();
for (int i = 1; i <= n; i++) {
a[i].x = rd();
a[i].y = rd();
d[i] = sqrt((double)a[i].x * a[i].x + (double)a[i].y * a[i].y);
double now = atan2(a[i].y, a[i].x);
if (now < 0) now += pi * 2;
p[i] = now;
}
double maxn = 0;
for (int i = 1; i <= n; i++) maxn = max(maxn, d[i]);
double l = 0, r = maxn;
for (int i = 1; i <= 50; i++) {
double mid = (l + r) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
printf("%.10lf\n", l);
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const long long MOD = 1e9 + 7;
const long double EPS = 1e-10;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
struct suff_array {
const int L;
string s;
int i, skip, lvl;
vector<vector<int>> P;
vector<pair<pair<int, int>, int>> M;
suff_array(const string& s)
: L(s.size()), s(s), P(1, vector<int>(L, 0)), M(L) {
for (i = 0; i < L - (L == 1); i++) P[0][i] = int(s[i]);
for (skip = 1, lvl = 1; skip < L; skip *= 2, lvl++) {
P.push_back(vector<int>(L, 0));
for (int i = 0; i < L; i++)
M[i] = {{P[lvl - 1][i], i + skip < L ? P[lvl - 1][i + skip] : -1000},
i};
sort(M.begin(), M.end());
for (int i = 0; i < L; i++)
P[lvl][M[i].second] = (i > 0 && M[i].first == M[i - 1].first)
? P[lvl][M[i - 1].second]
: i;
}
}
const vector<int>& get_sarray() { return P.back(); }
int lcp(int i, int j) {
int len = 0;
if (i == j) return L - i;
for (int k = P.size() - 1; k >= 0 && i < L && j < L; k--)
if (P[k][i] == P[k][j]) {
i += 1 << k;
j += 1 << k;
len += 1 << k;
}
return len;
}
};
const int N = 3e3 + 1;
long long tot[N][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int n;
cin >> n;
int v[n + 1];
string s;
for (int i = 1; i <= n; i++) {
cin >> v[i];
s.push_back(v[i]);
}
reverse(s.begin(), s.end());
suff_array sa(s);
set<int> bad;
bad.insert(0b0011);
bad.insert(0b0101);
bad.insert(0b1110);
bad.insert(0b1111);
auto match = [&](int id, int len, int bm) {
if (len > id) return false;
for (int i = 0; i < len; i++) {
if (v[id - i] != (bm >> i & 1)) {
return false;
}
}
return true;
};
long long ans = 0;
tot[0][0] = 1;
for (int i = 1; i <= n; i++) {
int maxv = 0;
for (int j = 1; j < i; j++) {
maxv = max(maxv, sa.lcp(n - i, n - j));
}
tot[i][0] = 1;
for (int j = 1; j <= 4; j++) {
for (int bm = 0; bm < 1 << j; bm++) {
if (j == 4 && bad.count(bm)) continue;
if (match(i, j, bm)) {
for (int len = j; len <= i; len++) {
tot[i][len] = (tot[i][len] + tot[i - j][len - j]) % MOD;
}
break;
}
}
}
for (int len = maxv + 1; len <= i; len++) {
ans = (ans + tot[i][len]) % MOD;
}
cout << ans << nl;
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
char c[1001];
int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int a[101][101];
int main() {
int n;
int ans = 1;
int h = 0, m = 0;
int q = 0;
scanf("%d\n", &n);
for (int i = 0; i < n; i++) {
char c;
int ch, cm;
scanf("[%d:%d %c.m.]: ", &ch, &cm, &c);
string ss;
getline(cin, ss);
if (c == 'p') ch += 12;
if (ch == 24 && c == 'p') ch = 12;
if (ch == 12 && c == 'a') ch = 0;
if (ch == h && cm == m)
q++;
else
q = 1;
if (q == 11) {
ans++;
q = 1;
}
if (h > ch) {
ans++;
h = ch;
m = cm;
continue;
}
if (h == ch && m > cm) {
ans++;
h = ch;
m = cm;
continue;
}
h = ch;
m = cm;
}
cout << ans;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
const int INF = 1e9;
const int N = 1e4 + 1;
const int LOG = 30;
vector<int> inds[N];
vector<pair<int, int> > answer[2];
int a[N], b[N];
void f(int* a, int i, int j, int ai) {
answer[ai].push_back({i, j});
a[i] ^= a[j];
}
vector<int> gauss(int* a, int n, int ai) {
vector<int> bits;
int cntFound = 0;
for (int lg = LOG - 1; lg >= 0; lg--) {
int pos = -1;
for (int i = cntFound; i < n; i++) {
if (a[i] & (1 << lg)) {
pos = i;
break;
}
}
if (pos != -1) {
bits.push_back(lg);
if (cntFound != pos) {
f(a, cntFound, pos, ai);
f(a, pos, cntFound, ai);
f(a, cntFound, pos, ai);
}
for (int i = 0; i < n; i++)
if (cntFound != i && (a[i] & (1 << lg))) {
f(a, i, cntFound, ai);
}
cntFound++;
}
}
return bits;
}
int a_r[N], b_r[N];
void solve() {
int n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
a_r[i] = a[i];
}
auto bitsa = gauss(a, n, 0);
for (long long i = 0; i < n; i++) {
cin >> b[i];
b_r[i] = b[i];
}
auto bitsb = gauss(b, n, 1);
if (bitsb.size() > bitsa.size()) {
cout << -1 << "\n";
return;
}
for (int i = 0; i < bitsb.size(); i++) {
if (!(b[i] & (1 << bitsa[i]))) {
f(a, i, i, 0);
}
for (int j = i + 1; j < bitsa.size(); j++) {
if (b[i] & (1 << bitsa[j])) {
f(a, i, j, 0);
}
}
}
for (int i = (int)bitsb.size(); i < (int)bitsa.size(); i++) {
f(a, i, i, 0);
}
reverse(answer[1].begin(), answer[1].end());
for (auto x : answer[1]) answer[0].push_back(x);
for (auto x : answer[0]) {
a_r[x.first] ^= a_r[x.second];
}
for (int i = 0; i < n; i++)
if (a_r[i] != b_r[i]) {
cout << "-1\n";
return;
}
cout << answer[0].size() << "\n";
for (auto x : answer[0]) cout << x.first + 1 << " " << x.second + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
}
| 19
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "no-stack-protector")
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using uint = unsigned int;
using ull = unsigned long long;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
default_random_engine generator;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(16) << fixed;
cerr << setprecision(16) << fixed;
int tests = 1;
for (int test = 1; test <= tests; ++test) {
solve();
}
}
class Tree {
public:
Tree() {}
Tree(int n) : n(n) {
arr.resize(4 * n);
pr.resize(4 * n);
build(0, 0, n);
}
void update(int lf, int rg, int val) { update(0, 0, n, lf, rg, val); }
pii get() {
pii res = get(0);
res.second *= -1;
return res;
}
private:
pii get(int v) { return {arr[v].first + pr[v], arr[v].second}; }
void push(int v) {
pr[2 * v + 1] += pr[v];
pr[2 * v + 2] += pr[v];
arr[v].first += pr[v];
pr[v] = 0;
}
void build(int v, int l, int r) {
if (l + 1 == r) {
arr[v] = {0, -l};
return;
}
int m = (l + r) / 2;
build(2 * v + 1, l, m);
build(2 * v + 2, m, r);
arr[v] = min(arr[2 * v + 1], arr[2 * v + 2]);
}
void update(int v, int l, int r, int lf, int rg, int val) {
if (lf <= l && r <= rg) {
pr[v] += val;
return;
}
if (rg <= l || r <= lf) {
return;
}
push(v);
int m = (l + r) / 2;
update(2 * v + 1, l, m, lf, rg, val);
update(2 * v + 2, m, r, lf, rg, val);
arr[v] = min(get(2 * v + 1), get(2 * v + 2));
}
int n;
vector<pii> arr;
vector<int> pr;
};
class BIT {
public:
BIT(int n) { arr.resize(n); }
void add(int pos, int val) {
for (int i = pos; i < (int)(arr).size(); i |= i + 1) {
arr[i] += val;
}
}
int sum(int pos) {
int res = 0;
for (int i = pos; i >= 0; i = (i & (i + 1)) - 1) {
res += arr[i];
}
return res;
}
private:
vector<int> arr;
};
struct Query {
int x, y;
int id;
};
void solve() {
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int &x : a) {
cin >> x;
--x;
}
int inf = 1e8;
Tree tree(n);
for (int i = 0; i < n; ++i) {
if (i - a[i] >= 0) {
tree.update(i, i + 1, i - a[i]);
} else {
tree.update(i, i + 1, inf);
}
}
vector<vector<int>> d(n);
int minn = n;
for (int i = 0; i < n; ++i) {
auto [val, p] = tree.get();
if (val != 0) {
break;
}
minn = min(minn, p);
d[minn].push_back(p);
tree.update(p + 1, n, -1);
tree.update(p, p + 1, inf);
}
vector<vector<Query>> arr(n);
for (int i = 0; i < q; ++i) {
Query que;
cin >> que.x >> que.y;
que.id = i;
arr[que.x].push_back(que);
}
vector<int> res(q);
BIT bit(n);
for (int i = n - 1; i >= 0; --i) {
for (int x : d[i]) {
bit.add(x, 1);
}
for (auto [x, y, id] : arr[i]) {
res[id] = bit.sum(n - y - 1) - bit.sum(x - 1);
}
}
for (int i = 0; i < q; ++i) {
cout << res[i] << "\n";
}
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 1;
const int maxbit = 30;
int n, a[maxn], cnt[maxn][maxbit];
int L[maxn], R[maxn];
stack<int> Stack;
void Input() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < maxbit; j++)
cnt[i][j] = cnt[i - 1][j] + ((a[i] >> j) & 1);
}
}
void Prepare() {
while (!Stack.empty()) Stack.pop();
for (int i = 1; i <= n; i++) {
while (!Stack.empty() && a[Stack.top()] <= a[i]) Stack.pop();
if (Stack.empty())
L[i] = 0;
else
L[i] = Stack.top();
Stack.push(i);
}
while (!Stack.empty()) Stack.pop();
for (int i = n; i >= 1; i--) {
while (!Stack.empty() && a[Stack.top()] < a[i]) Stack.pop();
if (Stack.empty())
R[i] = n + 1;
else
R[i] = Stack.top();
Stack.push(i);
}
}
bool Check(int l, int r, int x) {
for (int i = 0; i < maxbit; i++)
if (((x >> i) & 1) == 0) {
if (cnt[r][i] - cnt[l - 1][i] > 0) return true;
}
return false;
}
int GetLow(int x) {
int low = L[x], high = x, res = low;
while (low <= high) {
int mid = (low + high) / 2;
if (Check(mid, x, a[x]))
res = max(res, mid), low = mid + 1;
else
high = mid - 1;
}
return res;
}
int GetHigh(int x) {
int low = x, high = R[x], res = high;
while (low <= high) {
int mid = (low + high) / 2;
if (Check(x, mid, a[x]))
res = min(res, mid), high = mid - 1;
else
low = mid + 1;
}
return res;
}
void Solve() {
long long res = 0;
for (int i = 1; i <= n; i++) {
int low = GetLow(i), high = GetHigh(i);
res += (i - low) * ((long long)R[i] - high) +
(low - L[i]) * ((long long)R[i] - i);
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
Input();
Prepare();
Solve();
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int mark[1002][1002];
int area[1002][1002];
char res[1002][1002];
int total_area;
int fy, fx;
int n, m;
void fill_area(vector<pair<int, int> > P) {
int sz = P.size();
int unusable[10] = {0};
for (int i = 0; i < sz; i++) {
int y = P[i].first, x = P[i].second;
area[y][x] = 0;
if (res[y - 1][x] >= '0' && res[y - 1][x] <= '9')
unusable[res[y - 1][x] - '0'] = 1;
if (res[y + 1][x] >= '0' && res[y + 1][x] <= '9')
unusable[res[y + 1][x] - '0'] = 1;
if (res[y][x - 1] >= '0' && res[y][x - 1] <= '9')
unusable[res[y][x - 1] - '0'] = 1;
if (res[y][x + 1] >= '0' && res[y][x + 1] <= '9')
unusable[res[y][x + 1] - '0'] = 1;
total_area--;
}
int target = 0;
while (unusable[target]) target++;
for (int i = 0; i < sz; i++) {
int y = P[i].first, x = P[i].second;
res[y][x] = '0' + target;
}
while (fy > 0 && !area[fy][fx]) {
fx--;
if (fx == 0) {
fx = m;
fy--;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i <= m + 1; i++) res[0][i] = res[n + 1][i] = '#';
for (int i = 0; i < n; i++) {
char temp[1001];
scanf("%s", temp);
res[i][0] = res[i][m + 1] = '#';
strcpy(res[i + 1] + 1, temp);
for (int j = 0; j < m; j++)
if (temp[j] == '.')
area[i + 1][j + 1] = 1, total_area++, fy = i + 1, fx = j + 1;
}
int no_answer = 0;
queue<pair<int, int> > Q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (area[i][j]) {
int cnt =
area[i - 1][j] + area[i + 1][j] + area[i][j - 1] + area[i][j + 1];
if (cnt == 0) no_answer = 1;
if (cnt == 1) {
mark[i][j] = 1;
Q.push(pair<int, int>(i, j));
}
}
if (no_answer) {
printf("-1\n");
return 0;
}
while (total_area) {
while (!Q.empty()) {
pair<int, int> now = Q.front();
Q.pop();
if (!area[now.first][now.second]) continue;
pair<int, int> next = now;
if (area[now.first + 1][now.second])
next.first++;
else if (area[now.first - 1][now.second])
next.first--;
else if (area[now.first][now.second + 1])
next.second++;
else
next.second--;
vector<pair<int, int> > P;
P.push_back(pair<int, int>(next.first, next.second));
if (mark[next.first - 1][next.second])
P.push_back(pair<int, int>(next.first - 1, next.second));
if (mark[next.first + 1][next.second])
P.push_back(pair<int, int>(next.first + 1, next.second));
if (mark[next.first][next.second - 1])
P.push_back(pair<int, int>(next.first, next.second - 1));
if (mark[next.first][next.second + 1])
P.push_back(pair<int, int>(next.first, next.second + 1));
fill_area(P);
for (int i = max(1, next.first - 2); i <= min(n, next.first + 2); i++)
for (int j = max(1, next.second - 2); j <= min(m, next.second + 2);
j++) {
if (!area[i][j]) continue;
int cnt =
area[i - 1][j] + area[i + 1][j] + area[i][j - 1] + area[i][j + 1];
if (cnt == 1 && !mark[i][j]) {
mark[i][j] = 1;
Q.push(pair<int, int>(i, j));
}
}
}
if (!total_area) break;
vector<pair<int, int> > P;
P.push_back(pair<int, int>(fy, fx));
P.push_back(pair<int, int>(fy, fx - 1));
int my = fy, mx = fx;
fill_area(P);
for (int i = max(1, my - 2); i <= min(n, my + 2); i++)
for (int j = max(1, mx - 2); j <= min(m, mx + 2); j++) {
if (!area[i][j]) continue;
int cnt =
area[i - 1][j] + area[i + 1][j] + area[i][j - 1] + area[i][j + 1];
if (cnt == 1 && !mark[i][j]) {
mark[i][j] = 1;
Q.push(pair<int, int>(i, j));
}
}
}
for (int i = 1; i <= n; i++) {
res[i][m + 1] = 0;
printf("%s\n", res[i] + 1);
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2>
bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
const long double eps = 1e-8;
long double dot(complex<long double> a, complex<long double> b) {
return real(conj(a) * b);
}
long double cross(complex<long double> a, complex<long double> b) {
return imag(conj(a) * b);
}
int main() {
long double px, py, vx, vy, a, b, c, d;
cin >> px >> py >> vx >> vy;
cin >> a >> b >> c >> d;
complex<long double> p(px, py), v(vx, vy);
v /= abs(v);
const long double pi = acos(-1);
vector<complex<long double> > ans(7);
ans[0] = v * b;
ans[1] = v * polar(1.0l, pi / 2) * (a / 2);
ans[2] = v * polar(1.0l, pi / 2) * (c / 2);
ans[2] = v * polar(1.0l, pi / 2) * (c / 2);
ans[3] = -v * d + ans[2];
ans[5] = v * polar(1.0l, -pi / 2) * (c / 2);
ans[4] = -v * d + ans[5];
ans[6] = v * polar(1.0l, -pi / 2) * (a / 2);
for (int i = 0; i < (7); i++) ans[i] += p;
for (int i = 0; i < (7); i++) {
printf("%.20f %.20f\n", (double)ans[i].real(), (double)ans[i].imag());
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
long long coe[72];
int main() {
long long t, a, b, i, n;
cin >> t >> a >> b;
int ret = 0;
if ((t == 1) && a == 1 && b == 1) {
printf("inf\n");
return 0;
}
if (a == b) ++ret;
if (a == t) {
if (b == a)
printf("2\n");
else
printf("0\n");
} else if ((b - a) % (a - t)) {
cout << 0 << endl;
} else {
long long temp, x = b, m = a;
if (t != 1) {
while (b > 0 && a > 0) {
a -= b % m;
b = b / m;
if (a <= 0 || a % t != 0) break;
a /= t;
}
if (a == 0 && b == 0) ++ret;
} else {
m = b % a;
if (b > a && (b - m) % (a - m) == 0) ++ret;
}
cout << ret << endl;
}
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
long long s[2 * MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < 2 * n; i++) {
scanf("%lld", &s[i]);
}
sort(s, s + 2 * n);
long long ans = (s[n - 1] - s[0]) * (s[2 * n - 1] - s[n]);
for (int i = 1; i < n; i++) {
ans = min(ans, (s[2 * n - 1] - s[0]) * (s[i + n - 1] - s[i]));
}
printf("%lld\n", ans);
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool debug = false;
int k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
const int N = 2005;
struct Nxt {
int nxt[26];
};
char s[1000025], t[N];
int lt;
int a[N];
vector<Nxt> v[N], w;
pair<int, int> ans[N];
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n); (i)++) {
scanf("%s", s);
int len = (int)strlen(s);
v[i].resize(len + 1);
for (int(j) = 0; (j) < (int)(26); (j)++) v[i][len].nxt[j] = len;
for (int j = len - 1; j >= 0; j--) {
v[i][j] = v[i][j + 1];
v[i][j].nxt[s[j] - 'a'] = j;
}
}
scanf("%d", &m);
for (int(i) = 0; (i) < (int)(m); (i)++) {
scanf("%d", a + i);
a[i]--;
}
w.resize(m + 1);
for (int(i) = 0; (i) < (int)(26); (i)++) w[m].nxt[i] = m;
for (int i = m - 1; i >= 0; i--)
for (int(j) = 0; (j) < (int)(26); (j)++) {
w[i].nxt[j] =
v[a[i]][0].nxt[j] == v[a[i]].size() - 1 ? w[i + 1].nxt[j] : i;
}
scanf("%s", t);
lt = (int)strlen(t);
ans[0] = {0, -1};
for (int i = 1; i <= lt; i++) ans[i] = {m, -1};
for (int i = 0; i < lt; i++) {
for (int j = i + 1; j; j--) {
if (ans[j - 1].first != m) {
auto now = ans[j - 1];
now.second = v[a[now.first]][now.second + 1].nxt[t[i] - 'a'];
if (now.second == v[a[now.first]].size() - 1) {
now.first = w[now.first + 1].nxt[t[i] - 'a'];
now.second = now.first != m ? v[a[now.first]][0].nxt[t[i] - 'a'] : -1;
}
if (now < ans[j]) ans[j] = now;
}
}
}
for (int i = lt; i > 0; i--) {
if (ans[i].first != m) {
printf("%d\n", i);
return 0;
}
}
puts("0");
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, sz = 200;
long long dp[11][11], n, ans;
int fc3() {
int x;
cin >> x;
return x;
}
int func2(int i, int j) { return i < n ? fc3() : 0; }
int fc(int i, int j) {
i += j / n;
j %= n;
dp[i][j] = func2(i, j);
return i < n ? fc(i, j + 1) : 0;
}
int func(int k, int i, int j) {
return k < n ? min(dp[i][j], dp[i][k] + dp[k][j]) : dp[i][j];
}
int fc1(int k, int i, int j) {
i += j / n;
j %= n;
k += i / n;
i %= n;
dp[i][j] = func(k, i, j);
return k < n ? fc1(k, i, j + 1) : 0;
}
int fc2(int i, int j) {
i += j / n;
j %= n;
ans = i < n ? max(ans, dp[i][j]) : ans;
return i < n ? fc2(i, j + 1) : 0;
}
int main() {
iostream::sync_with_stdio(0);
cin.tie(0);
cin >> n;
fc(0, 0);
fc1(0, 0, 0);
fc2(0, 0);
cout << ans;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int c[100005];
vector<int> G[100005];
int if_visited[100005];
int mini;
void dfs(int node) {
if_visited[node] = 1;
int l = G[node].size();
for (int i = 0; i < l; i++) {
if (if_visited[G[node][i]] == 0) {
if (mini > c[G[node][i]]) mini = c[G[node][i]];
dfs(G[node][i]);
}
}
}
int main() {
int n, m;
cin >> n >> m;
long long int ans = 0;
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!if_visited[i]) {
mini = c[i];
dfs(i);
ans += mini;
}
}
cout << ans << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
int main() {
int i, x, y, a, b, d = 1, turns = (-1), m = 1, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
scanf("%d %d", &x, &y);
a = b = 0;
while (1) {
x1 = a;
y1 = b;
if (m == 1) {
a = a + d;
m++;
turns++;
} else if (m == 2) {
b = b + d;
m++;
d++;
turns++;
} else if (m == 3) {
a = a - d;
m++;
turns++;
} else if (m == 4) {
b = b - d;
m = 1;
d++;
turns++;
}
x2 = a;
y2 = b;
if ((((x >= x1 && x <= x2) || (x <= x1 && x >= x2)) &&
(y == y2 && y == y1)) ||
((x == x1 && x == x2) &&
((y >= y1 && y <= y2) || (y <= y1 && y >= y2))))
break;
}
printf("%d", turns);
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, m, p, l[N], r[N], pp[N];
char s[N], opt[N];
stack<int> st;
int main() {
scanf("%d%d%d", &n, &m, &p);
scanf("%s%s", s + 1, opt + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == '(')
st.push(i);
else {
int cur = st.top();
pp[cur] = i;
pp[i] = cur;
st.pop();
}
}
for (int i = 0; i <= n; i++) r[i] = i + 1;
for (int i = 1; i <= n + 1; i++) l[i] = i - 1;
for (int i = 1; i <= m; i++) {
if (opt[i] == 'L')
p = l[p];
else if (opt[i] == 'R')
p = r[p];
else {
if (s[p] == '(') {
r[l[p]] = r[pp[p]];
l[r[pp[p]]] = l[p];
p = (r[pp[p]] == n + 1) ? l[p] : r[pp[p]];
} else {
l[r[p]] = l[pp[p]];
r[l[pp[p]]] = r[p];
p = (r[p] == n + 1) ? l[pp[p]] : r[p];
}
}
}
int cur = 0;
while (r[cur] != n + 1) {
cur = r[cur];
printf("%c", s[cur]);
}
printf("\n");
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_INT = (1 << 31) - 1;
const long long MAX_LL = (1LL << 63) - 1;
int month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
struct date {
int y, m, d;
date() : y(1900), m(1), d(1) {}
};
istream& operator>>(istream& in, date& d) {
in >> d.y;
in.ignore();
in >> d.m;
in.ignore();
in >> d.d;
return in;
}
ostream& operator<<(ostream& out, const date& d) {
out << d.y << ":" << d.m << ":" << d.d;
return out;
}
bool operator>(const date& d1, const date& d2) {
return (d1.y > d2.y || d1.y == d2.y && d1.m > d2.m ||
d1.y == d2.y && d1.m == d2.m && d1.d > d2.d);
}
bool vis(int year) {
return (year % 4 == 0 && year % 100 != 0 || year % 400 == 0);
}
int main() {
date d1, d2;
cin >> d1 >> d2;
if (d1 > d2) swap(d1, d2);
int ans = 0;
if (d1.y != d2.y) {
for (int i = d1.y + 1; i < d2.y; ++i) {
ans += 365;
if (vis(i)) ++ans;
}
if (vis(d1.y)) ++month[2];
for (int i = d1.m + 1; i < 13; ++i) ans += month[i];
ans += month[d1.m] - d1.d;
if (vis(d1.y)) --month[2];
if (vis(d2.y)) ++month[2];
for (int i = 1; i < d2.m; ++i) ans += month[i];
ans += d2.d;
if (vis(d2.y)) --month[2];
} else {
if (vis(d1.y)) ++month[2];
if (d1.m == d2.m)
ans = d2.d - d1.d;
else {
for (int i = d1.m + 1; i < d2.m; ++i) ans += month[i];
ans += month[d1.m] - d1.d;
ans += d2.d;
}
if (vis(d1.y)) --month[2];
}
cout << ans << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T Bitcnt(T a) {
int sum = 0;
while (a) {
if (a & 1) sum++;
a /= 2;
}
return sum;
}
template <class T>
T Max3(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
T Lcm(T a, T b) {
T tmp = __gcd(a, b);
return (a / tmp) * b;
}
template <class T>
T Pow(T a, T b) {
T ans = 1;
T base = a;
while (b) {
if (b & 1) ans = (ans * base);
base = (base * base);
b /= 2;
}
return ans;
}
long long Bigmod(long long a, long long b) {
long long res = 1;
long long pw = a % 1000000007LL;
while (b > 0) {
if (b & 1) res = (res * pw) % 1000000007LL;
pw = (pw * pw) % 1000000007LL;
b /= 2;
}
return res;
}
int a_x[] = {1, -1, 0, 0};
int a_y[] = {0, 0, 1, -1};
long long X, Y;
void extend_euclid(long long a, long long b) {
if (b == 0) {
X = a;
Y = 0;
return;
}
extend_euclid(b, a % b);
long long x, y;
x = Y;
y = X - (a / b) * Y;
X = x;
Y = y;
}
long long inverse_modulo(long long a, long long b) {
extend_euclid(a, b);
return (X + 1000000007LL) % 1000000007LL;
}
double dist(double x1, double y1, pair<double, double> tmp) {
double t = 1LL * (x1 - tmp.first) * (x1 - tmp.first) +
1LL * (y1 - tmp.second) * (y1 - tmp.second);
return (t);
}
int n;
pair<int, int> inp[200005];
double dist1(int indx1, int indx2, int x, int y) {
double lx, ly, rx, ry, ltx, lty, rtx, rty;
lx = inp[indx1].first;
ly = inp[indx1].second;
rx = inp[indx2].first;
ry = inp[indx2].second;
int tot = 100;
double ans = (long long)1e18;
while (tot--) {
ltx = (lx * 2 + rx) / 3.0;
lty = (ly * 2 + ry) / 3.0;
rtx = (lx + rx * 2) / 3.0;
rty = (ly + ry * 2) / 3.0;
if (dist(ltx, lty, make_pair(x, y)) - dist(rtx, rty, make_pair(x, y)) <
1e-13) {
rx = rtx;
ry = rty;
ans = min(ans, dist(ltx, lty, make_pair(x * 1.0, y * 1.0)));
} else {
lx = ltx;
ly = lty;
ans = min(ans, dist(rtx, rty, make_pair(x * 1.0, y * 1.0)));
}
}
return ans;
}
double dist2(int indx1, int indx2, int x, int y) {
double lx, ly, rx, ry, ltx, lty, rtx, rty;
lx = inp[indx1].first;
ly = inp[indx1].second;
rx = inp[indx2].first;
ry = inp[indx2].second;
int tot = 100;
double ans = 0.0;
while (tot--) {
ltx = (lx * 2 + rx) / 3.0;
lty = (ly * 2 + ry) / 3.0;
rtx = (lx + rx * 2) / 3.0;
rty = (ly + ry * 2) / 3.0;
if (dist(ltx, lty, make_pair(x, y)) - dist(rtx, rty, make_pair(x, y)) >
1e-13) {
rx = rtx;
ry = rty;
ans = max(ans, dist(ltx, lty, make_pair(x * 1.0, y * 1.0)));
} else {
lx = ltx;
ly = lty;
ans = max(ans, dist(rtx, rty, make_pair(x * 1.0, y * 1.0)));
}
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
double mx = 0.0;
double mn = (long long)1e18;
int x, y;
scanf("%d %d", &x, &y);
for (int i = 0; i <= n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
inp[i] = make_pair(a, b);
}
for (int i = 0; i <= n - 1; i++) {
int f = i;
int s = (i + 1) % n;
double res = dist1(f, s, x, y);
mn = min(res, mn);
res = dist2(f, s, x, y);
mx = max(res, mx);
}
double ans;
ans = acos(-1.0) * (mx - mn);
printf("%.12lf\n", ans);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:36777216")
template <class T>
inline T &RD(T &);
template <class T>
inline void OT(const T &);
inline long long RD() {
long long x;
return RD(x);
}
inline char &RC(char &c) {
scanf(" %c", &c);
return c;
}
inline char RC() {
char c;
return RC(c);
}
inline long double &RF(long double &x) {
scanf("%lf", &x);
return x;
}
inline long double RF() {
long double x;
return RF(x);
}
inline char *RS(char *s) {
scanf("%s", s);
return s;
}
template <class T0, class T1>
inline T0 &RD(T0 &x0, T1 &x1) {
RD(x0), RD(x1);
return x0;
}
template <class T0, class T1, class T2>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2) {
RD(x0), RD(x1), RD(x2);
return x0;
}
template <class T0, class T1, class T2, class T3>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
RD(x0), RD(x1), RD(x2), RD(x3);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);
return x0;
}
template <class T0, class T1>
inline void OT(const T0 &x0, const T1 &x1) {
OT(x0), OT(x1);
}
template <class T0, class T1, class T2>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2) {
OT(x0), OT(x1), OT(x2);
}
template <class T0, class T1, class T2, class T3>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3) {
OT(x0), OT(x1), OT(x2), OT(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5, const T6 &x6) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);
}
inline char &RC(char &a, char &b) {
RC(a), RC(b);
return a;
}
inline char &RC(char &a, char &b, char &c) {
RC(a), RC(b), RC(c);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d) {
RC(a), RC(b), RC(c), RC(d);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e) {
RC(a), RC(b), RC(c), RC(d), RC(e);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g);
return a;
}
inline long double &RF(long double &a, long double &b) {
RF(a), RF(b);
return a;
}
inline long double &RF(long double &a, long double &b, long double &c) {
RF(a), RF(b), RF(c);
return a;
}
inline long double &RF(long double &a, long double &b, long double &c,
long double &d) {
RF(a), RF(b), RF(c), RF(d);
return a;
}
inline long double &RF(long double &a, long double &b, long double &c,
long double &d, long double &e) {
RF(a), RF(b), RF(c), RF(d), RF(e);
return a;
}
inline long double &RF(long double &a, long double &b, long double &c,
long double &d, long double &e, long double &f) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f);
return a;
}
inline long double &RF(long double &a, long double &b, long double &c,
long double &d, long double &e, long double &f,
long double &g) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g);
return a;
}
inline void RS(char *s1, char *s2) { RS(s1), RS(s2); }
inline void RS(char *s1, char *s2, char *s3) { RS(s1), RS(s2), RS(s3); }
template <class T>
inline void RST(T &A) {
memset(A, 0, sizeof(A));
}
template <class T0, class T1>
inline void RST(T0 &A0, T1 &A1) {
RST(A0), RST(A1);
}
template <class T0, class T1, class T2>
inline void RST(T0 &A0, T1 &A1, T2 &A2) {
RST(A0), RST(A1), RST(A2);
}
template <class T0, class T1, class T2, class T3>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
RST(A0), RST(A1), RST(A2), RST(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);
}
template <class T>
inline void FLC(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T0, class T1>
inline void FLC(T0 &A0, T1 &A1, int x) {
FLC(A0, x), FLC(A1, x);
}
template <class T0, class T1, class T2>
inline void FLC(T0 &A0, T1 &A1, T2 &A2) {
FLC(A0), FLC(A1), FLC(A2);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5), FLC(A6);
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, less<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(T &A) {
A.clear();
}
template <class T0, class T1>
inline void CLR(T0 &A0, T1 &A1) {
CLR(A0), CLR(A1);
}
template <class T0, class T1, class T2>
inline void CLR(T0 &A0, T1 &A1, T2 &A2) {
CLR(A0), CLR(A1), CLR(A2);
}
template <class T0, class T1, class T2, class T3>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);
}
template <class T>
inline void CLR(T &A, int n) {
for (int i = 0; i < int(n); ++i) CLR(A[i]);
}
template <class T>
inline T &SRT(T &A) {
sort(A.begin(), A.end());
return A;
}
template <class T, class C>
inline T &SRT(T &A, C B) {
sort(A.begin(), A.end(), B);
return A;
}
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long double EPS = 1e-8;
const long double OO = 1e15;
const long double PI = acos(-1.0);
template <class T>
inline void checkMin(T &a, const T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMax(T &a, const T b) {
if (b > a) a = b;
}
template <class T>
inline void checkMin(T &a, T &b, const T x) {
checkMin(a, x), checkMin(b, x);
}
template <class T>
inline void checkMax(T &a, T &b, const T x) {
checkMax(a, x), checkMax(b, x);
}
template <class T, class C>
inline void checkMin(T &a, const T b, C c) {
if (c(b, a)) a = b;
}
template <class T, class C>
inline void checkMax(T &a, const T b, C c) {
if (c(a, b)) a = b;
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline T cub(T a) {
return a * a * a;
}
inline int Ceil(int x, int y) { return (x - 1) / y + 1; }
inline bool _1(int x, int i) { return x & 1 << i; }
inline bool _1(long long x, int i) { return x & 1LL << i; }
inline long long _1(int i) { return 1LL << i; }
inline long long _U(int i) { return _1(i) - 1; };
template <class T>
inline T low_bit(T x) {
return x & -x;
}
template <class T>
inline T high_bit(T x) {
T p = low_bit(x);
while (p != x) x -= p, p = low_bit(x);
return p;
}
template <class T>
inline T cover_bit(T x) {
T p = 1;
while (p < x) p <<= 1;
return p;
}
inline int count_bits(int x) {
x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1);
x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2);
x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4);
x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8);
x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16);
return x;
}
inline int count_bits(long long x) {
x = (x & 0x5555555555555555LL) + ((x & 0xaaaaaaaaaaaaaaaaLL) >> 1);
x = (x & 0x3333333333333333LL) + ((x & 0xccccccccccccccccLL) >> 2);
x = (x & 0x0f0f0f0f0f0f0f0fLL) + ((x & 0xf0f0f0f0f0f0f0f0LL) >> 4);
x = (x & 0x00ff00ff00ff00ffLL) + ((x & 0xff00ff00ff00ff00LL) >> 8);
x = (x & 0x0000ffff0000ffffLL) + ((x & 0xffff0000ffff0000LL) >> 16);
x = (x & 0x00000000ffffffffLL) + ((x & 0xffffffff00000000LL) >> 32);
return x;
}
inline int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
inline long long reverse_bits(long long x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
inline void INC(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline int sum(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline void DEC(int &a, int b) {
a -= b;
if (a < 0) a += MOD;
}
inline int dff(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline void MUL(int &a, int b) { a = (long long)a * b % MOD; }
inline int pdt(int a, int b) { return (long long)a * b % MOD; }
inline int sum(int a, int b, int c) { return sum(sum(a, b), c); }
inline int sum(int a, int b, int c, int d) { return sum(sum(a, b), sum(c, d)); }
inline int pdt(int a, int b, int c) { return pdt(pdt(a, b), c); }
inline int pdt(int a, int b, int c, int d) { return pdt(pdt(pdt(a, b), c), d); }
inline int pow(int a, long long b) {
int c(1);
while (b) {
if (b & 1) MUL(c, a);
MUL(a, a), b >>= 1;
}
return c;
}
template <class T>
inline T pow(T a, long long b) {
T c(1);
while (b) {
if (b & 1) c *= a;
a *= a, b >>= 1;
}
return c;
}
inline int _I(int b) {
int a = MOD, x1 = 0, x2 = 1, q;
while (true) {
q = a / b, a %= b;
if (!a) return (x2 + MOD) % MOD;
DEC(x1, pdt(q, x2));
q = b / a, b %= a;
if (!b) return (x1 + MOD) % MOD;
DEC(x2, pdt(q, x1));
}
}
inline void DIA(int &a, int b) { MUL(a, _I(b)); }
inline int qtt(int a, int b) { return pdt(a, _I(b)); }
inline int phi(int n) {
int res = n;
for (int i = 2; sqr(i) <= n; ++i)
if (!(n % i)) {
DEC(res, qtt(res, i));
do {
n /= i;
} while (!(n % i));
}
if (n != 1) DEC(res, qtt(res, n));
return res;
}
struct Po;
struct Line;
struct Seg;
inline int sgn(long double x) { return x < -EPS ? -1 : x > EPS; }
inline int sgn(long double x, long double y) { return sgn(x - y); }
struct Po {
long double x, y;
Po(long double _x = 0, long double _y = 0) : x(_x), y(_y) {}
friend istream &operator>>(istream &in, Po &p) { return in >> p.x >> p.y; }
friend ostream &operator<<(ostream &out, Po p) {
return out << "(" << p.x << ", " << p.y << ")";
}
friend bool operator==(Po, Po);
friend bool operator!=(Po, Po);
friend Po operator+(Po, Po);
friend Po operator-(Po, Po);
friend Po operator*(Po, long double);
friend Po operator/(Po, long double);
bool operator<(const Po &rhs) const {
return sgn(x, rhs.x) < 0 || sgn(x, rhs.x) == 0 && sgn(y, rhs.y) < 0;
}
Po operator-() const { return Po(-x, -y); }
Po &operator+=(Po rhs) {
x += rhs.x, y += rhs.y;
return *this;
}
Po &operator-=(Po rhs) {
x -= rhs.x, y -= rhs.y;
return *this;
}
Po &operator*=(long double k) {
x *= k, y *= k;
return *this;
}
Po &operator/=(long double k) {
x /= k, y /= k;
return *this;
}
long double length_sqr() const { return sqr(x) + sqr(y); }
long double length() const { return sqrt(length_sqr()); }
Po unit() const { return (*this) / length(); }
bool dgt() const { return !sgn(x) && !sgn(y); }
long double atan() const { return atan2(y, x); }
void input() { scanf("%lf %lf", &x, &y); }
};
bool operator==(Po a, Po b) {
return sgn(a.x - b.x) == 0 && sgn(a.y - b.y) == 0;
}
bool operator!=(Po a, Po b) {
return sgn(a.x - b.x) != 0 || sgn(a.y - b.y) != 0;
}
Po operator+(Po a, Po b) { return Po(a.x + b.x, a.y + b.y); }
Po operator-(Po a, Po b) { return Po(a.x - b.x, a.y - b.y); }
Po operator*(Po a, long double k) { return Po(a.x * k, a.y * k); }
Po operator*(long double k, Po a) { return a * k; }
Po operator/(Po a, long double k) { return Po(a.x / k, a.y / k); }
struct Line {
Po a, b;
Line(const Po &a = Po(), const Po &b = Po()) : a(a), b(b) {}
Line(const Line &l) : a(l.a), b(l.b) {}
Line(long double x0, long double y0, long double x1, long double y1)
: a(Po(x0, y0)), b(Po(x1, y1)) {}
void getequation(long double, long double, long double) const;
Line operator+(Po x) const { return Line(a + x, b + x); }
friend ostream &operator<<(ostream &out, Line p) {
return out << p.a << "-" << p.b;
}
long double length() const { return (b - a).length(); }
bool dgt() const { return (a - b).dgt(); }
void input() { a.input(), b.input(); }
};
struct Seg : Line {
Seg(const Po &a = Po(), const Po &b = Po()) : Line(a, b) {}
Seg(const Line &l) : Line(l) {}
Seg(long double x0, long double y0, long double x1, long double y1)
: Line(x0, y0, x1, y1) {}
};
inline long double dot(const long double &x1, const long double &y1,
const long double &x2, const long double &y2) {
return x1 * x2 + y1 * y2;
}
inline long double dot(const Po &a, const Po &b) {
return dot(a.x, a.y, b.x, b.y);
}
inline long double dot(const Po &p0, const Po &p1, const Po &p2) {
return dot(p1 - p0, p2 - p0);
}
inline long double dot(const Po &o, const Line &l) { return dot(o, l.a, l.b); }
inline long double dot(const Line &l, const Po &o) { return dot(o, l.a, l.b); }
inline long double dot(const Line &l1, const Line &l2) {
return dot(l1.b - l1.a, l2.b - l2.a);
}
inline long double det(const long double &x1, const long double &y1,
const long double &x2, const long double &y2) {
return x1 * y2 - x2 * y1;
}
inline long double det(const Po &a, const Po &b) {
return det(a.x, a.y, b.x, b.y);
}
inline long double det(const Po &p0, const Po &p1, const Po &p2) {
return det(p1 - p0, p2 - p0);
}
inline long double det(const Po &o, const Line &l) { return det(o, l.a, l.b); }
inline long double det(const Line &l, const Po &o) { return det(o, l.a, l.b); }
inline long double det(const Line &l1, const Line &l2) {
return det(l1.b - l1.a, l2.b - l2.a);
}
void Line::getequation(long double A, long double B, long double C) const {
A = a.y - b.y, B = b.x - a.x, C = det(a, b);
}
template <class T1, class T2>
inline long double dist(const T1 &x, const T2 &y) {
return sqrt(dist_sqr(x, y));
}
template <class T1, class T2, class T3>
inline long double dist(const T1 &x, const T2 &y, const T3 &z) {
return sqrt(dist_sqr(x, y, z));
}
template <class T1, class T2>
inline int dett(const T1 &x, const T2 &y) {
return sgn(det(x, y));
}
template <class T1, class T2>
inline int dott(const T1 &x, const T2 &y) {
return sgn(dot(x, y));
}
template <class T1, class T2, class T3>
inline int dett(const T1 &x, const T2 &y, const T3 &z) {
return sgn(det(x, y, z));
}
template <class T1, class T2, class T3>
inline int dott(const T1 &x, const T2 &y, const T3 &z) {
return sgn(dot(x, y, z));
}
template <class T1, class T2, class T3, class T4>
inline int dett(const T1 &x, const T2 &y, const T3 &z, const T4 &w) {
return sgn(det(x, y, z, w));
}
template <class T1, class T2, class T3, class T4>
inline int dott(const T1 &x, const T2 &y, const T3 &z, const T4 &w) {
return sgn(dot(x, y, z, w));
}
inline long double dist_sqr(const long double &x, const long double &y) {
return sqr(x) + sqr(y);
}
inline long double dist_sqr(const long double &x, const long double &y,
const long double &z) {
return sqr(x) + sqr(y) + sqr(z);
}
inline long double dist_sqr(const Po &a, const Po &b) {
return sqr(a.x - b.x) + sqr(a.y - b.y);
}
inline long double dist_sqr(const Po &p, const Line &l) {
Po v0 = l.b - l.a, v1 = p - l.a;
return sqr(fabs(det(v0, v1))) / v0.length_sqr();
}
inline long double dist_sqr(const Po &p, const Seg &l) {
Po v0 = l.b - l.a, v1 = p - l.a, v2 = p - l.b;
if (sgn(dot(v0, v1)) * sgn(dot(v0, v2)) <= 0)
return dist_sqr(p, Line(l));
else
return min(v1.length_sqr(), v2.length_sqr());
}
inline long double dist_sqr(Line l, Po p) { return dist_sqr(p, l); }
inline long double dist_sqr(Seg l, Po p) { return dist_sqr(p, l); }
inline long double dist_sqr(Line l1, Line l2) {
if (sgn(det(l1, l2)) != 0) return 0;
return dist_sqr(l1.a, l2);
}
inline long double dist_sqr(Line l1, Seg l2) {
Po v0 = l1.b - l1.a, v1 = l2.a - l1.a, v2 = l2.b - l1.a;
long double c1 = det(v0, v1), c2 = det(v0, v2);
return sgn(c1) != sgn(c2) ? 0
: sqr(min(fabs(c1), fabs(c2))) / v0.length_sqr();
}
bool isIntersect(Seg l1, Seg l2) {
if (l1.a == l2.a || l1.a == l2.b || l1.b == l2.a || l1.b == l2.b) return true;
return min(l1.a.x, l1.b.x) <= max(l2.a.x, l2.b.x) &&
min(l2.a.x, l2.b.x) <= max(l1.a.x, l1.b.x) &&
min(l1.a.y, l1.b.y) <= max(l2.a.y, l2.b.y) &&
min(l2.a.y, l2.b.y) <= max(l1.a.y, l1.b.y) &&
sgn(det(l1.a, l2.a, l2.b)) * sgn(det(l1.b, l2.a, l2.b)) <= 0 &&
sgn(det(l2.a, l1.a, l1.b)) * sgn(det(l2.b, l1.a, l1.b)) <= 0;
}
inline long double dist_sqr(Seg l1, Seg l2) {
if (isIntersect(l1, l2))
return 0;
else
return min(dist_sqr(l1.a, l2), dist_sqr(l1.b, l2), dist_sqr(l2.a, l1),
dist_sqr(l2.b, l1));
}
inline bool isOnSide(const Po &p, const Seg &l) { return p == l.a || p == l.b; }
inline bool isOnSeg(const Po &p, const Seg &l) {
return sgn(det(p, l.a, l.b)) == 0 && sgn(l.a.x, p.x) * sgn(l.b.x, p.x) <= 0 &&
sgn(l.a.y, p.y) * sgn(l.b.y, p.y) <= 0;
}
inline bool isOnSegg(const Po &p, const Seg &l) {
return sgn(det(p, l.a, l.b)) == 0 && sgn(l.a.x, p.x) * sgn(l.b.x, p.x) < 0 &&
sgn(l.a.y, p.y) * sgn(l.b.y, p.y) < 0;
}
inline Po intersect(const Line &l1, const Line &l2) {
return l1.a + (l1.b - l1.a) * (det(l2.a, l1.a, l2.b) / det(l2, l1));
}
inline Po intersect(const Po &p, const Line &l) {
return intersect(Line(p, p + Po(l.a.y - l.b.y, l.b.x - l.a.x)), l);
}
inline Po rotate(Po p, long double alpha, Po o = Po()) {
p.x -= o.x, p.y -= o.y;
return Po(p.x * cos(alpha) - p.y * sin(alpha),
p.y * cos(alpha) + p.x * sin(alpha)) +
o;
}
inline int rand32() {
return (bool(rand() & 1) << 30) | (rand() << 15) + rand();
}
inline int random32(int l, int r) { return rand32() % (r - l + 1) + l; }
inline int random(int l, int r) { return rand() % (r - l + 1) + l; }
int dice() { return rand() % 6; }
bool coin() { return rand() % 2; }
namespace Clock {
long double st, rd, ed;
inline long double getTime() { return 1.0 * clock() / CLOCKS_PER_SEC; }
inline void start() { st = getTime(); }
inline long double elapsed() { return getTime() - st; }
} // namespace Clock
template <class T>
inline T &RD(T &x) {
char c;
for (c = getchar(); c < '0'; c = getchar())
;
x = c - '0';
for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
return x;
}
int ____Case;
template <class T>
inline void OT(const T &x) {
printf("%d ", x);
}
const int N = 100009, M = 2 * N;
char str[N];
int num[N];
int l[N], r[N];
int n, m;
struct Query;
vector<Query *> P[N];
vector<Query *> O[N];
struct Query {
int c[10], x, y;
bool act;
void input() {
RD(x, y);
--x, --y;
P[x].push_back(this);
}
void output() {
for (int i = 0; i < int(10); ++i) OT(c[i]);
puts("");
}
void st(int t[]) {
act = true;
O[l[x]].push_back(this), O[r[y]].push_back(this);
for (int i = 0; i < int(10); ++i) c[i] -= t[i];
}
int id();
void ed(int t[]) {
if (act) {
act = false;
for (int i = 0; i < int(10); ++i) c[i] += t[i];
}
}
} Q[N];
int Query::id() { return this - Q; }
void del(int p) {
r[l[p]] = r[p];
l[r[p]] = l[p];
}
struct Interpreter {
int cp, dp, rr;
int c[10];
void run(int _cp) {
vector<Query *> cur;
RST(c);
cp = _cp;
dp = 1;
rr = 0;
while (true) {
if (cp < _cp || cp >= n) break;
checkMax(rr, cp);
for (int i = 0; i < int(int(O[cp].size())); ++i) O[cp][i]->ed(c);
CLR(O[cp]);
if (!P[cp].empty()) {
for (int i = 0; i < int(int(P[cp].size())); ++i) {
cur.push_back(P[cp][i]);
P[cp][i]->st(c);
}
CLR(P[cp]);
}
if (isdigit(str[cp])) {
++c[num[cp]--];
if (num[cp] == -1) del(cp);
cp = dp == 1 ? r[cp] : l[cp];
} else {
dp = str[cp] == '>';
int _cp = cp;
cp = dp == 1 ? r[cp] : l[cp];
if (!isdigit(str[cp])) del(_cp);
}
}
for (int i = 0; i < int(int(O[cp].size())); ++i) O[cp][i]->ed(c);
CLR(O[cp]);
if (rr != n - 1) run(rr + 1);
}
} I;
int main() {
RD(n, m);
RS(str);
for (int i = 0; i < int(n); ++i)
num[i] = str[i] - 48, l[i] = i - 1, r[i] = i + 1;
for (int i = 0; i < int(m); ++i) Q[i].input();
I.run(0);
for (int i = 0; i < int(m); ++i) Q[i].output();
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
inline int Mid(int x, int y) { return (x + y) >> 1; }
struct node {
int l, r, siz, sum;
} tree[10004 * 4];
void push_up(int id) {
tree[id].sum = tree[(id << 1)].sum + tree[(id << 1 | 1)].sum;
tree[id].siz = tree[(id << 1)].siz + tree[(id << 1 | 1)].siz;
}
void build(int l, int r, int id) {
tree[id].l = l, tree[id].r = r;
tree[id].sum = tree[id].siz = 0;
if (l == r) return;
int mid = Mid(l, r);
build(l, mid, (id << 1));
build(mid + 1, r, (id << 1 | 1));
}
void updata(int pos, int val, int id) {
if (tree[id].l == tree[id].r) {
tree[id].siz += val;
tree[id].sum += pos * val;
return;
}
int mid = Mid(tree[id].l, tree[id].r);
if (pos <= mid)
updata(pos, val, (id << 1));
else
updata(pos, val, (id << 1 | 1));
push_up(id);
}
int query(int k, int id) {
if (k <= 0) return 0;
if (tree[id].siz <= k) {
return tree[id].sum;
}
if (tree[id].l == tree[id].r) {
return min(tree[id].siz, k) * tree[id].l;
}
int mid = Mid(tree[id].l, tree[id].r);
if (tree[(id << 1)].siz <= k) {
return tree[(id << 1)].sum + query(k - tree[(id << 1)].siz, (id << 1 | 1));
} else
query(k, (id << 1));
}
vector<int> a[100005], G[100005];
int n, cost, now;
int work(int x) {
for (int i = 0; i < G[x].size(); i++) {
cost += G[x][i];
updata(G[x][i], -1, 1);
now++;
}
int hehe = x - now;
if (hehe <= 0) return cost;
return cost + query(hehe, 1);
}
void input() {
build(0, 10004, 1);
for (int i = 0; i < 100005; i++) a[i].clear(), G[i].clear();
for (int i = 1; i <= n; i++) {
int u, v;
scanf("%d %d", &u, &v);
a[u].push_back(v);
updata(v, 1, 1);
}
for (int i = 1; i < 100005; i++) sort(a[i].begin(), a[i].end());
for (int i = 0; i < 100005; i++) {
for (int j = 0; j < a[i].size(); j++) {
G[a[i].size() - j].push_back(a[i][j]);
}
}
}
int main() {
int i, j, u, v;
while (~scanf("%d", &n)) {
input();
int ans = 1e9 + 10;
cost = 0;
now = 0;
for (i = n; i >= 0; i--) {
int tmp = work(i);
if (tmp == -1) break;
ans = min(ans, tmp);
}
printf("%d\n", ans);
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int b[30], c[30];
int a[4][4], j;
int n, sum, sum1;
int s[30];
int d[30], r[30];
void get(int num) {
if (num == 2 * n && s[0] != s[1]) return;
if (num == 3 * n && s[0] != s[2]) return;
if (num == 4 * n && s[0] != s[3]) return;
if (num == (n - 1) * n + 2 && d[0] != d[1]) return;
if (num == (n - 1) * n + 3 && d[0] != d[2]) return;
if (num == (n - 1) * n + 4 && d[0] != d[3]) return;
if (num == n * n) {
sum = 0;
sum1 = 0;
for (int i = 0; i < n; i++) sum1 += a[i][i];
for (int i = 0; i < n; i++) sum += a[n - 1 - i][i];
if (sum != sum1 || sum != s[0]) return;
cout << sum << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << a[i][j] << " ";
cout << endl;
}
exit(0);
}
for (int i = 0; i <= j; i++)
if (c[i]) {
c[i]--;
a[num / n][num % n] = r[i];
s[num / n] += r[i];
d[num % n] += r[i];
get(num + 1);
s[num / n] -= r[i];
d[num % n] -= r[i];
c[i]++;
}
}
int main(void) {
cin >> n;
for (int i = 0; i < n * n; i++) cin >> b[i];
sort(b, b + n * n);
j = 0;
c[0] = 1;
r[0] = b[0];
for (int i = 1; i < n * n; i++)
if (b[i] == b[i - 1])
c[j]++;
else {
j++;
r[j] = b[i];
c[j]++;
}
get(0);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 10;
long long n, m, a[maxn], d[1000010];
struct seg_tree {
struct nodes {
long long l, r, sum, max_num;
} node[maxn << 2];
void up(long long now) {
return (
void)(node[now].sum = node[(now << 1)].sum + node[(now << 1 | 1)].sum,
node[now].max_num =
max(node[(now << 1)].max_num, node[(now << 1 | 1)].max_num));
}
void build(long long l, long long r, long long now) {
node[now].l = l, node[now].r = r;
if (l == r) return (void)(node[now].sum = a[l], node[now].max_num = a[l]);
build(l, ((l + r) >> 1), (now << 1)),
build(((l + r) >> 1) + 1, r, (now << 1 | 1));
return up(now);
}
void chenge(long long l, long long r, long long now) {
if (r < node[now].l or node[now].r < l or node[now].max_num <= 2) return;
if (node[now].l == node[now].r)
return (void)(node[now].max_num = node[now].sum = d[node[now].sum]);
chenge(l, r, (now << 1)), chenge(l, r, (now << 1 | 1));
return up(now);
}
void quary(long long l, long long r, long long now, long long &ans) {
if (r < node[now].l or node[now].r < l) return;
if (l <= node[now].l and node[now].r <= r)
return (void)(ans += node[now].sum);
quary(l, r, (now << 1), ans), quary(l, r, (now << 1 | 1), ans);
return up(now);
}
} tree;
signed main() {
for (long long i = 1; i <= 1000000; i++) {
for (long long j = i; j <= 1000000; j += i) {
d[j]++;
}
}
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
tree.build(1, n, 1);
for (long long i = 1, x, y, z; i <= m; i++) {
scanf("%lld%lld%lld", &x, &y, &z);
if (x & 1)
tree.chenge(y, z, 1);
else {
long long ans = 0;
tree.quary(y, z, 1, ans);
printf("%lld\n", ans);
}
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, m;
int p[MAXN], s[MAXN], b[MAXN], inc[MAXN], pref[MAXN];
int tmp[MAXN], ans[MAXN];
struct Data {
int ty, x, y, z, id;
Data() {}
Data(int ty, int x, int y, int z, int id)
: ty(ty), x(x), y(y), z(z), id(id) {}
} a[MAXN], d[MAXN];
inline bool cmpx(Data a, Data b) {
return a.x == b.x ? a.ty > b.ty : a.x < b.x;
}
inline bool cmpy(Data a, Data b) {
return a.y == b.y ? a.ty > b.ty : a.y < b.y;
}
int c[MAXN];
void add(int x, int d) {
for (int i = x; i <= n + m; i += (i & -i)) c[i] += d;
}
int query(int x) {
int res = 0;
for (int i = x; i; i -= (i & -i)) res += c[i];
return res;
}
void solve(int l, int r) {
if (l == r) return;
int mid = (l + r) >> 1;
solve(l, mid);
solve(mid + 1, r);
for (int i = l; i <= r; i++) {
d[i] = a[i];
d[i].x = i;
}
sort(d + l, d + r + 1, cmpy);
for (int i = l; i <= r; i++)
if (d[i].x <= mid && !d[i].ty)
add(d[i].z, 1);
else if (d[i].x > mid && d[i].ty)
ans[d[i].id] += query(d[i].z - 1);
for (int i = l; i <= r; i++)
if (d[i].x <= mid && !d[i].ty) add(d[i].z, -1);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= m; i++) scanf("%d", &inc[i]);
for (int i = 1; i <= m; i++) scanf("%d", &pref[i]);
for (int i = 1; i <= n; i++) a[i] = Data(0, -b[i], -s[i], b[i] + p[i], i);
for (int j = 1; j <= m; j++)
a[j + n] = Data(1, -pref[j] + 1, -inc[j] + 1, inc[j] + pref[j] + 1, j + n);
for (int i = 1; i <= n + m; i++) tmp[i] = a[i].x;
sort(tmp + 1, tmp + n + m + 1);
for (int i = 1; i <= n + m; i++)
a[i].x = lower_bound(tmp + 1, tmp + n + m + 1, a[i].x) - tmp;
for (int i = 1; i <= n + m; i++) tmp[i] = a[i].y;
sort(tmp + 1, tmp + n + m + 1);
for (int i = 1; i <= n + m; i++)
a[i].y = lower_bound(tmp + 1, tmp + n + m + 1, a[i].y) - tmp;
for (int i = 1; i <= n + m; i++) tmp[i] = a[i].z;
sort(tmp + 1, tmp + n + m + 1);
for (int i = 1; i <= n + m; i++)
a[i].z = lower_bound(tmp + 1, tmp + n + m + 1, a[i].z) - tmp;
sort(a + 1, a + n + m + 1, cmpx);
solve(1, n + m);
for (int i = 1; i <= n; i++) a[i] = Data(0, b[i], -s[i], p[i] - b[i], i);
for (int j = 1; j <= m; j++)
a[j + n] = Data(1, pref[j], -inc[j] + 1, inc[j] - pref[j] + 1, j + n);
for (int i = 1; i <= n + m; i++) tmp[i] = a[i].x;
sort(tmp + 1, tmp + n + m + 1);
for (int i = 1; i <= n + m; i++)
a[i].x = lower_bound(tmp + 1, tmp + n + m + 1, a[i].x) - tmp;
for (int i = 1; i <= n + m; i++) tmp[i] = a[i].y;
sort(tmp + 1, tmp + n + m + 1);
for (int i = 1; i <= n + m; i++)
a[i].y = lower_bound(tmp + 1, tmp + n + m + 1, a[i].y) - tmp;
for (int i = 1; i <= n + m; i++) tmp[i] = a[i].z;
sort(tmp + 1, tmp + n + m + 1);
for (int i = 1; i <= n + m; i++)
a[i].z = lower_bound(tmp + 1, tmp + n + m + 1, a[i].z) - tmp;
sort(a + 1, a + n + m + 1, cmpx);
solve(1, n + m);
for (int j = n + 1; j <= n + m; j++) printf("%d ", ans[j]);
printf("\n");
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n;
cin >> n;
unsigned long long arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
unsigned long long p1 = 0, p2 = 0;
for (unsigned long long i = 1; i < n; i++) {
if (arr[p1] * (i + 1) < arr[i] * (p1 + 1)) p1 = i;
if ((arr[p2] + 1) * (i + 1) > (arr[i] + 1) * (p2 + 1)) p2 = i;
}
double mina = 10 * double(arr[p1]) / (p1 + 1);
double maxa = 10 * double(arr[p2] + 1) / (p2 + 1);
double x = (n + 1) * maxa - 10 * arr[n - 1];
double y = (n + 1) * mina - 10 * arr[n - 1];
unsigned long long xx = x, yy = y;
if (xx == x && xx % 10 == 0)
xx = xx / 10 - 1;
else
xx /= 10;
yy /= 10;
if (xx > yy)
cout << "not unique";
else
cout << "unique" << endl << arr[n - 1] + xx;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
int n;
cin >> n;
int l = n, r = 1, sz = 0;
if (n % 2 == 0) {
for (int i = 0; i < n / 2; ++i) {
cout << l-- << " " << r++ << " ";
}
} else {
cout << l-- << " ";
for (int i = 0; i < n / 2; ++i) {
cout << r++ << " " << l-- << " ";
}
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int n, a[2][210000], b[210000], c[210000], flg[210000];
int lowbit(int x) { return (x & (-x)); }
void add(int index, int val) {
while (index <= n) {
b[index] += val;
index = index + lowbit(index);
}
}
int sum(int index) {
int tot;
tot = 0;
while (index > 0) {
tot += b[index];
index = index - lowbit(index);
}
return tot;
}
void process(int *p) {
int i, tmp;
for (i = 0; i <= n; i++) b[i] = 0;
for (i = 1; i <= n; i++) {
tmp = sum(p[i] + 1);
add(p[i] + 1, 1);
p[i] = p[i] - tmp;
}
}
int _find(int x) {
int left, right, mid, px;
left = 1;
right = n;
while (left <= right) {
mid = (left + right) / 2;
px = mid - sum(mid);
if (px < x) left = mid + 1;
if (px > x) right = mid - 1;
if (px == x) {
if (flg[mid] == 0) return mid;
right = mid - 1;
}
}
}
int main() {
int x, i;
while (scanf("%d", &n) != EOF) {
for (i = 1; i <= n; i++) scanf("%d", &a[0][i]);
for (i = 1; i <= n; i++) scanf("%d", &a[1][i]);
process(a[0]);
process(a[1]);
x = 0;
for (i = n; i >= 1; i--) {
c[i] = (a[0][i] + a[1][i] + x) % (n - i + 1);
x = (a[0][i] + a[1][i] + x) / (n - i + 1);
}
for (i = 0; i <= n; i++) flg[i] = b[i] = 0;
for (i = 1; i <= n; i++) {
c[i] = _find(c[i] + 1);
add(c[i], 1);
flg[c[i]] = 1;
}
for (i = 1; i <= n; i++) printf("%d ", c[i] - 1);
printf("\n");
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b) {
return a;
} else {
return b;
}
}
long long min(long long a, long long b) {
if (a < b) {
return a;
} else {
return b;
}
}
struct P {
double x, y;
P() {}
P(int x, int y) : x(double(x)), y(double(y)) {}
P(double x, double y) : x(x), y(y) {}
P operator+(const P &a) const { return P(x + a.x, y + a.y); }
P operator-(const P &a) const { return P(x - a.x, y - a.y); }
double operator^(const P &a) const { return x * a.x + y * a.y; }
void in() { scanf("%lf%lf", &x, &y); }
void out() { printf("REQUIRED %.7f %.7f\n", x, y); }
double dist(P a, P b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
double sqdist(P a, P b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
};
int n, x[205001], w[205001], cm;
int dp[205001 + 205001];
struct d {
int x, w;
} a[205001];
bool operator<(d u, d v) { return u.x < v.x; }
int res = 0;
struct dat {
int w;
int x;
int op;
int v;
dat(int w, int x, int op, int v) : w(w), x(x), op(op), v(v) {}
};
bool operator<(dat u, dat v) {
if (u.x < v.x) return false;
if (u.x > v.x) return true;
return u.op > v.op;
}
priority_queue<dat> Q;
int main() {
cm = 0;
scanf("%d", &n);
for (int i = (1); i <= (n); i++) scanf("%d%d", &a[i].x, &a[i].w);
sort(a + 1, a + n + 1);
for (int i = (1); i <= (n); i++)
Q.push(dat(a[i].w * 2, a[i].x - a[i].w, 1, 0));
while (Q.size() > 0) {
dat y = Q.top();
Q.pop();
if (y.op == 1) {
res = max(res, cm + 1);
Q.push(dat(y.w * 2, y.x + y.w, 0, cm + 1));
} else {
cm = max(cm, y.v);
}
}
printf("%d\n", res);
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
ostream &operator<<(ostream &O, pair<T1, T2> &t) {
return O << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream &operator<<(ostream &O, vector<T> &t) {
for (int _ = 0; _ < (int)t.size(); ++_) O << t[_] << " ";
return O;
}
int res = (2147483647);
void rec(int a, int b, int c) {
if (a == b) {
res = min(res, c);
return;
}
if (c >= res) return;
if (a < b) swap(a, b);
if ((a & 1) == 0) rec(a >> 1, b, c + 1);
if (a % 3 == 0) rec(a / 3, b, c + 1);
if (a % 5 == 0) rec(a / 5, b, c + 1);
}
int main() {
int a, b;
cin >> a >> b;
rec(a, b, 0);
cout << (res == (2147483647) ? -1 : res);
return 0;
}
int cpp4cf_main() {
freopen("B.cpp", "r", stdin);
char s[99];
bool f;
while (true) {
cin >> s;
if (cin.eof()) break;
if (strstr(s, "/*")) {
cin >> s;
if (strstr(s, "Test")) {
cin >> s;
if (strstr(s, "on")) {
cout << "Output: ";
cpp4cf_main();
cout << "\nAnswer: ";
f = false;
while (true) {
cin >> s;
if (strstr(s, "*/")) break;
if (strstr(s, "//")) {
if (f)
cout << endl;
else
f = true;
} else
cout << s << " ";
}
cout << "\n\n";
}
}
}
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
typedef priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
rpqpi;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k, s, mi, ma;
cin >> n >> k >> s;
mi = k;
ma = k * (n - 1);
if (s < mi || s > ma)
cout << "NO\n";
else {
cout << "YES\n";
long long now = 1, p;
for (int i = 0; i < k; ++i) {
p = (s + k - i - 1) / (k - i);
if (i & 1) {
now -= p;
} else {
now += p;
}
cout << now << " ";
s -= p;
}
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int a[10], n, m, k, l, o, i, j;
int main() {
cin >> a[1] >> a[2] >> a[3] >> a[4];
sort(a + 1, a + 5);
for (i = 1; i <= 2; i++)
for (j = i + 1; j <= 3; j++)
for (l = j + 1; l <= 4; l++)
if (a[i] + a[j] > a[l]) {
cout << "TRIANGLE";
return 0;
} else if (a[i] + a[j] == a[l])
k = 1;
if (k == 1) {
cout << "SEGMENT";
} else
cout << "IMPOSSIBLE";
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int a[] = {0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1,
14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1,
51, 1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1,
52, 2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4,
267, 1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1, 6, 1,
52, 15, 2, 1, 15, 1, 2, 1, 12, 1, 10, 1, 4, 2};
int main() {
int n;
cin >> n;
cout << a[n];
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int num[5000 + 20];
int length[20];
int ww[100000 + 20];
int dp[5000 + 20][5000 + 20];
void upd(int &a, int b) {
if (a < b) a = b;
}
int main() {
memset(dp, 0, sizeof(dp));
memset(num, 0, sizeof(num));
int n;
scanf("%d", &n);
memset(length, 0, sizeof(length));
int ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
}
for (int k = 1; k <= n; k++) {
dp[k][0] = 1;
dp[0][k] = 1;
}
for (int i = 1; i <= n; i++) {
for (int k = i - 1; k >= 1; k--) {
if (num[k] % 7 == num[i] % 7 || abs(num[k] - num[i]) == 1) {
upd(dp[i][0], dp[k][0] + 1);
}
upd(dp[i][0], 1);
dp[0][i] = dp[i][0];
}
}
for (int i = 1; i <= n; i++) {
memset(length, 0, sizeof(length));
memset(ww, 0, sizeof(ww));
for (int p = 1; p < i; p++) {
upd(length[num[p] % 7], dp[p][i]);
upd(ww[num[p] - 1], dp[p][i]);
upd(ww[num[p] + 1], dp[p][i]);
}
for (int k = i + 1; k <= n; k++) {
upd(dp[k][i], length[num[k] % 7] + 1);
upd(dp[k][i], ww[num[k]] + 1);
upd(dp[k][i], dp[0][i] + 1);
upd(ww[num[k] - 1], dp[k][i]);
upd(ww[num[k] + 1], dp[k][i]);
upd(length[num[k] % 7], dp[k][i]);
upd(ans, dp[k][i]);
upd(ans, dp[i][k]);
dp[i][k] = dp[k][i];
}
}
cout << ans << endl;
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int n;
string str;
long long A[2000];
long long B[2005];
int id;
bool used[2005];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%I64d %I64d", &A[i], &B[i]);
}
cin >> str;
str = str + 'L';
id = -1;
for (int i = 0; i < n; i++) {
if (id == -1 || A[id] > A[i] || (A[id] == A[i] && B[id] > B[i])) {
id = i;
}
}
used[id] = true;
cout << id + 1 << " ";
for (int i = 1; i < n; i++) {
int to = -1;
for (int j = 0; j < n; j++) {
if (!used[j]) {
if (to == -1) {
to = j;
} else {
long long now = (A[j] - A[id]) * (B[to] - B[id]) -
(A[to] - A[id]) * (B[j] - B[id]);
if (str[i - 1] == 'R') {
now = -now;
}
if (now > 0) {
to = j;
}
}
}
}
used[to] = true;
id = to;
cout << id + 1 << " ";
}
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
long long int ar[n + 2];
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
sort(ar + 1, ar + n + 1);
int pos = (n + 1) / 2;
long long int ans = ar[pos];
long long res = 0;
for (int j = pos + 1; j <= n; j++) {
if (res + (j - pos) * (ar[j] - ar[j - 1]) > m) {
long long int baki1 = m - res;
long long koyta1 = (j - pos);
ans = max(ans, ar[j - 1] + baki1 / koyta1);
}
res += (j - pos) * (ar[j] - ar[j - 1]);
if (res > m) {
break;
}
long long int baki = m - res;
if (j == n) {
long long koyta = (n - pos + 1);
ans = max(ans, ar[j] + baki / koyta);
}
}
if (n == 1) ans = ar[1] + m;
cout << ans << endl;
return 0;
}
| 6
|
#include <bits/stdc++.h>
constexpr int P = 998244353;
int power(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % P)
if (b & 1) res = 1ll * res * a % P;
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, k;
std::cin >> n >> k;
n /= 2;
std::vector<int> a(k);
for (int i = 0; i < k; ++i) std::cin >> a[i];
std::sort(a.begin(), a.end());
for (int i = k - 1; i >= 0; --i) a[i] -= a[0];
std::vector<int> f(a.back() * n + 1);
f[0] = 1;
for (int i = 0; i < a.back() * n; ++i) {
int res = 0;
for (auto j : a)
if (j && j <= i + 1) res = (res + 1ll * j * f[i - j + 1]) % P;
res = 1ll * res * n % P;
for (auto j : a)
if (j && j <= i) res = (res + 1ll * (i - j + 1) * (P - f[i - j + 1])) % P;
f[i + 1] = 1ll * res * power(i + 1, P - 2) % P;
}
int ans = 0;
for (int i = 0; i <= a.back() * n; ++i) ans = (ans + 1ll * f[i] * f[i]) % P;
std::cout << ans << "\n";
return 0;
}
| 16
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.