solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
const int N = 4194303;
char s[17][17];
int dist[17][17][1 << 16], n, m, M;
int qx[N + 5], qy[N + 5], qz[N + 5], front, rear;
int px[10], py[10], len, stx, sty;
bool can[4];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 0; i < 17; i++)
for (int j = 0; j < 17; j++)
if (i < 1 || i > n || j < 1 || j > m)
s[i][j] = '#';
else if (s[i][j] >= '0' && s[i][j] <= '9') {
len = max(len, s[i][j] - '0');
px[s[i][j] - '0'] = i;
py[s[i][j] - '0'] = j;
}
M = 1 << (len - 1 << 1);
M--;
int code = 0, x, y, z, nx, ny, nz;
for (int i = 1; i < len; i++)
for (int k = 0; k < 4; k++)
if (px[i] + dx[k] == px[i + 1] && py[i] + dy[k] == py[i + 1])
code |= k << (i - 1 << 1);
memset(dist, -1, sizeof(dist));
qx[rear] = px[1];
qy[rear] = py[1];
qz[rear++] = code;
dist[px[1]][py[1]][code] = 0;
while (front != rear) {
x = qx[front];
y = qy[front];
z = qz[front++];
front &= N;
if (s[x][y] == '@') {
printf("%d\n", dist[x][y][z]);
return 0;
}
can[0] = can[1] = can[2] = can[3] = true;
for (int i = 1, curx = x, cury = y, k; i < len - 1; i++) {
k = (z >> (i - 1 << 1)) & 3;
curx += dx[k];
cury += dy[k];
for (int kk = 0; kk < 4; kk++)
if (x + dx[kk] == curx && y + dy[kk] == cury) can[kk] = false;
}
for (int k = 0; k < 4; k++)
if (can[k]) {
nx = x + dx[k];
ny = y + dy[k];
if (s[nx][ny] == '#') continue;
nz = ((z << 2) & M) | (k ^ 1);
if (dist[nx][ny][nz] != -1) continue;
qx[rear] = nx;
qy[rear] = ny;
qz[rear++] = nz;
dist[nx][ny][nz] = dist[x][y][z] + 1;
rear &= N;
}
}
puts("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 505;
int n;
char grid[nax][nax];
int cc[nax][nax];
int cc_size[nax * nax];
int when_added[nax * nax];
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
const char EMPTY = '.';
bool inside(int x, int y) { return 0 <= min(x, y) && max(x, y) < n; }
void dfs(int x, int y, int which_cc) {
cc[x][y] = which_cc;
++cc_size[which_cc];
for (int i = 0; i < 4; ++i) {
int x2 = x + dx[i];
int y2 = y + dy[i];
if (inside(x2, y2) && grid[x2][y2] == EMPTY && cc[x2][y2] == 0)
dfs(x2, y2, which_cc);
}
}
void add(int x, int y, int& answer, int current_time) {
if (inside(x, y) && grid[x][y] == EMPTY) {
int id = cc[x][y];
if (when_added[id] != current_time) {
when_added[id] = current_time;
answer += cc_size[id];
}
}
}
int main() {
int k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%s", grid[i]);
int how_many_cc = 0;
for (int x = 0; x < n; ++x)
for (int y = 0; y < n; ++y)
if (grid[x][y] == EMPTY && cc[x][y] == 0) dfs(x, y, ++how_many_cc);
int cur_time = 1;
int best_answer = 0;
for (int y_low = 0; y_low + k <= n; ++y_low) {
for (int x = 0; x < k; ++x)
for (int y = y_low; y < y_low + k; ++y) --cc_size[cc[x][y]];
for (int x_low = 0; x_low + k <= n; ++x_low) {
int answer = k * k;
for (int x = x_low; x < x_low + k; ++x) {
add(x, y_low - 1, answer, cur_time);
add(x, y_low + k, answer, cur_time);
}
for (int y = y_low; y < y_low + k; ++y) {
add(x_low - 1, y, answer, cur_time);
add(x_low + k, y, answer, cur_time);
}
++cur_time;
best_answer = max(best_answer, answer);
if (x_low + k != n) {
for (int y = y_low; y < y_low + k; ++y) {
++cc_size[cc[x_low][y]];
--cc_size[cc[x_low + k][y]];
}
}
}
for (int x = n - k; x < n; ++x)
for (int y = y_low; y < y_low + k; ++y) ++cc_size[cc[x][y]];
}
printf("%d", best_answer);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long m = 1e9 + 7;
int main() {
long long n;
cin >> n;
long long abc[n + 1];
long long d[n + 1];
abc[0] = 0;
d[0] = 1;
for (int i = 1; i <= n; ++i) {
d[i] = (3 * (abc[i - 1] % m)) % m;
abc[i] = (d[i - 1] % m + 2 * (abc[i - 1] % m) % m) % m;
}
cout << d[n] << "\n";
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 1<<20, mod = 1e9 + 7;
string s;
int n, ans = 1<<30;
int p[maxn], sm[maxn], tt[maxn];
void solvep(string s) {//stuff with +
p[0] = 0;
int gm = 0;
//cout << s << '\n';
for(int i = 1; i <= n; i++) {
p[i] = p[i-1] + (s[i] == '1' ? -1 : 1);
gm = min(gm, p[i]);
// cout << p[i] << " ";
}
// cout << '\n';
sm[n] = p[n];
for(int i = n-1; i >= 0;i--) sm[i] = min(p[i], sm[i+1]);
//for(int i = 0; i <= n; i++) cout << sm[i] << " ";
//for(int i = 0; i <= n; i++) cout << p[i] << ' '; cout << '\n';
int r = 0;
for(int i = 0; i <= n; i++) {
sm[i] += r;
p[i] += r;
//cout << i << " " << sm[i] << " " << sm[i]-2 << " " << gm << '\n';
if(s[i] == '?' && sm[i] - 2 >= gm) {
r-=2;
//cout <<"at " << i << '\n';
sm[i] -= 2;
p[i] -= 2;
s[i] = '1';
}
tt[i] = r;
if(s[i] == '?') s[i] = '0';
//cout << p[i] << "\n";
}
//for(int i = 0; i <= n; i++) cout << p[i] << ' '; cout << '\n';
//cout << s << '\n';
int x = 0, y = 0; r = 0;
for(auto i : s) {
if(i == '1') r--;
else if(i != '.') r++;
x = min(x, r);
y = max(y, r);
}
ans = min(ans, y-x);
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> s;
n = s.size();
s = "." + s;
for(int i = 0; i < 2; i++) {
memset(p, 0, sizeof p);
memset(sm, 0, sizeof sm);
solvep(s);
memset(p, 0, sizeof p);
memset(sm, 0, sizeof sm);
for(auto &i : s) if(i != '?' && i != '.') i ^='0'^'1';
solvep(s);
reverse(s.begin(), s.end());
s.pop_back();
s = "." + s;
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int prt;
struct Var {
string type;
string name;
bool operator<(const Var& v) const {
if (type != v.type) return type < v.type;
if (name != v.name) return name < v.name;
return false;
}
bool operator==(const Var& v) const {
return type == v.type && name == v.name;
}
};
struct Func {
string name;
vector<Var> par;
bool operator<(const Func& f) const {
if (name != f.name) return name < f.name;
if (par.size() != f.par.size()) return par.size() < f.par.size();
if (par != f.par) return par < f.par;
return false;
}
};
map<string, vector<string> > mapa;
void print(const Func& f) {
printf("%s(", f.name.c_str());
for (int i = 0; i < f.par.size(); ++i) {
printf("%s %s,", f.par[i].type.c_str(), f.par[i].name.c_str());
}
printf(")\n");
}
bool pode(const Func& at, Func& cal) {
if (at.name != cal.name) return false;
if (at.par.size() != cal.par.size()) return false;
for (int i = 0; i < at.par.size(); ++i) {
Var ta = at.par[i], tc = cal.par[i];
vector<string> tipos = mapa[tc.name];
if (ta.type != "T" &&
find(tipos.begin(), tipos.end(), ta.type) == tipos.end())
return false;
}
return true;
}
set<Func> funcs;
char linha[300], tipo[300], nome[300];
int main() {
int n;
scanf("%d", &n);
gets(linha);
for (int i = 0; i < n; ++i) {
gets(linha);
int tam = strlen(linha);
string aux = "";
int prt = 0;
while (prt < tam && aux != "void") {
if (linha[prt] != ' ') aux += linha[prt];
++prt;
}
aux = "";
while (prt < tam && linha[prt] != '(') {
if (linha[prt] != ' ') aux += linha[prt];
++prt;
}
Func funcao;
funcao.name = aux;
++prt;
while (prt < tam && linha[prt] != ')') {
aux = "";
while (prt < tam && linha[prt] != ',' && linha[prt] != ')') {
if (linha[prt] != ' ') aux += linha[prt];
++prt;
}
++prt;
if (aux != "") {
Var var;
var.type = aux;
var.name = "";
funcao.par.push_back(var);
}
}
funcs.insert(funcao);
}
int q;
scanf("%d", &q);
while (q--) {
scanf("%s %s", tipo, nome);
mapa[nome].push_back(tipo);
}
scanf("%d", &q);
gets(linha);
while (q--) {
gets(linha);
int prt = 0, tam = strlen(linha);
string aux = "";
while (prt < tam && linha[prt] != '(') {
if (linha[prt] != ' ') aux += linha[prt];
++prt;
}
++prt;
Func funcao;
funcao.name = aux;
while (prt < tam && linha[prt] != ')') {
aux = "";
while (prt < tam && linha[prt] != ')' && linha[prt] != ',') {
if (linha[prt] != ' ') aux += linha[prt];
++prt;
}
++prt;
if (aux != "") {
Var var;
var.name = aux;
var.type = "";
funcao.par.push_back(var);
}
}
int cont = 0;
for (set<Func>::iterator it = funcs.begin(); it != funcs.end(); ++it) {
if (pode(*it, funcao)) ++cont;
}
printf("%d\n", cont);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int A,B,C,K; cin >> A >> B >> C >> K;
cout << A+B+C+max({A,B,C})*(pow(2,K)-1) << endl;
} | 0 |
#include <bits/stdc++.h>
int main() {
int *a, i, n, max, t;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &max);
a = (int *)malloc(n * sizeof(int));
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
if (a[0] == max) {
printf("%d\n", max);
} else {
for (i = 1; i < n; i++) {
a[0] = a[0] + a[i];
a[i] = 0;
if (a[0] >= max) {
printf("%d\n", max);
break;
}
}
if (i == n) printf("%d\n", a[0]);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int inf = 1e9 + 7;
int head[maxn], to[maxn << 1], nxt[maxn << 1];
int Vertex;
int qu[maxn], qf, qb, dist[2][maxn], fa[maxn], i, v, ok;
int dijk(int u, int *Dist) {
for (i = 1; i <= Vertex; i++) Dist[i] = inf;
Dist[u] = 0;
qf = qb = 0;
qu[qb++] = u;
while (qf < qb) {
u = qu[qf++];
for (i = head[u]; i; i = nxt[i]) {
v = to[i];
if (Dist[v] > Dist[u] + 1) {
if (ok) fa[v] = u;
Dist[v] = Dist[u] + 1;
qu[qb++] = v;
}
}
}
return qu[qf - 1];
}
int u, U, V, E;
int vis[maxn];
long long answer;
vector<pair<pair<int, int>, int> > res;
int main() {
scanf("%d", &Vertex);
for (i = 1; i < Vertex; i++) {
scanf("%d%d", &u, &v);
nxt[++E] = head[u];
to[E] = v;
head[u] = E;
nxt[++E] = head[v];
to[E] = u;
head[v] = E;
}
U = dijk(1, dist[0]);
V = dijk(U, dist[0]);
ok = 1;
dijk(V, dist[1]);
u = U;
while (u) {
vis[u] = 1;
u = fa[u];
}
for (i = qf - 1; i >= 0; i--) {
u = qu[i];
if (!vis[u]) {
if (dist[0][u] > dist[1][u]) {
answer += dist[0][u];
res.push_back(make_pair(make_pair(u, U), u));
} else {
answer += dist[1][u];
res.push_back(make_pair(make_pair(u, V), u));
}
}
}
u = U;
while (u != V) {
answer += dist[1][u];
res.push_back(make_pair(make_pair(u, V), u));
u = fa[u];
}
cout << answer << endl;
for (i = 0; i < ((int)((res).size())); i++) {
printf("%d %d %d\n", res[i].first.first, res[i].first.second,
res[i].second);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int a[N];
int main() {
int t, n;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
bool vis[4] = {0};
int maxn = 0, p = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int d = a[i] - a[i - 1];
if (i > 1) {
if (d > 0)
vis[1] = 1;
else if (d < 0)
vis[2] = 1;
else
vis[0] = 1;
}
}
if ((vis[1] && !vis[2] || !vis[1] && vis[2]) && !vis[0])
cout << "YES" << endl;
else if ((!vis[1] && !vis[2]) && vis[0]) {
if (n % 2 == 0) {
if (a[1] >= n / 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else {
if (a[1] >= (n - 1) / 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
} else {
int ff = 0;
if (n % 2 == 0) {
if (a[n / 2] == a[n / 2 + 1]) a[n / 2]--;
}
for (int i = 1; i <= n; i++) {
if (a[i] < min(i - 1, n - i)) ff = 1;
}
if (ff)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
vector<vector<int> > operator*(const vector<vector<int> > &a,
const vector<vector<int> > &b) {
vector<vector<int> > res(a.size(), vector<int>(b[0].size()));
assert(a[0].size() == b.size());
for (int i = 0; i < res.size(); i++)
for (int j = 0; j < res[0].size(); j++)
for (int k = 0; k < a[0].size(); k++) {
res[i][j] += a[i][k] * (long long)b[k][j] % mod;
res[i][j] %= mod;
}
return res;
}
vector<vector<int> > pow(vector<vector<int> > m, int n) {
vector<vector<int> > res(m.size(), vector<int>(m.size()));
for (int i = 0; i < m.size(); i++) res[i][i] = 1;
for (; n; n >>= 1) {
if (n & 1) res = res * m;
m = m * m;
}
return res;
}
int solve(int n) {
vector<vector<int> > M(25 * 2, vector<int>(25 * 2));
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++) {
for (int k = 1; k < 5; k++) {
if (j == k || j == 1 && k == 4 || j == 4 && k == 1 ||
j == 2 && k == 3 || j == 3 && k == 2 ||
i == 2 && j == 1 && k == 3 || i == 3 && j == 1 && k == 2)
continue;
M[k * 5 + j][j * 5 + i] = 1;
}
}
for (int i = 0; i < 25; i++) M[i + 25][i] = M[i + 25][i + 25] = 1;
M = pow(M, n + 1);
vector<vector<int> > A(50, vector<int>(25));
for (int i = 0; i < 25; i++) A[i][i] = 1;
vector<vector<int> > B = M * A;
vector<vector<int> > C(25, vector<int>(1));
C[0][0] = 1;
vector<vector<int> > D = B * C;
long long res = 0;
for (int i = 0; i < 25; i++) res += D[i + 25][0];
return res % mod;
}
int calc(int n) {
int res = ((long long)solve(n) + solve((n + 1) / 2) - solve(2) + mod) % mod;
if (res % 2) res += mod;
res /= 2;
return res;
}
void run() {
int l, r;
cin >> l >> r;
long long ans = calc(r) - calc(l - 1);
ans = (ans % mod + mod) % mod;
cout << ans << endl;
}
int main() {
run();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510000;
int f[maxn];
int n, d, up;
int c[66];
int b[66];
int main() {
cin >> n >> d;
f[0] = 1;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
for (int j = (up += x); j >= x; j--)
if (f[j - x]) f[j] = 1;
}
int num = 0, ans = 0;
while (true) {
int to = ans + d;
while (!f[to] && to > ans) to--;
if (ans == to) break;
ans = to;
num++;
}
cout << ans << ' ' << num << endl;
}
| 4 |
#include<iostream>
#include<cstdio>
using namespace std;
int main() {
int n,m,q,a[2005];
scanf("%d%d%d",&n,&m,&q);
for (register int i=1;i<=n;++i) {
scanf("%d",a+i);
}
int l=0,r=2000000000;
while (l<r) {
int mid=(l+r)>>1;
bool ok=0;
for (register int i=1;i<=n;++i) {
int p=a[i],k=0,tmp=0,cnt=0;
for (register int j=1;j<=n+1;++j) {
if (a[j]<p||j==n+1) {
tmp+=j-k-1<m?0:min(j-k-1-m+1,j-k-1-cnt);
k=j;
cnt=0;
}
else if (a[j]>p+mid) {
++cnt;
}
}
if (tmp>=q) {
ok=1;
break;
}
}
ok?r=mid:l=mid+1;
}
printf("%d",l);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using Real = long double;
Real g_err = 1e-9;
bool r_eq(Real x, Real y, Real err = g_err) {
return abs(x - y) <= err || abs(x - y) <= abs(x) * err;
}
bool r_le(Real x, Real y, Real err = g_err) {
return x - y <= err || x - y <= abs(x) * err;
}
bool r_ge(Real x, Real y, Real err = g_err) { return r_le(y, x, err); }
bool r_gt(Real x, Real y, Real err = g_err) { return !r_le(x, y, err); }
bool r_lt(Real x, Real y, Real err = g_err) { return !r_le(y, x, err); }
bool r_ne(Real x, Real y, Real err = g_err) { return !r_eq(x, y, err); }
bool rp_eq(Real x, Real y, Real err = g_err) { return abs(x - y) <= err; }
bool rp_le(Real x, Real y, Real err = g_err) { return x - y <= err; }
bool rp_ge(Real x, Real y, Real err = g_err) { return rp_le(y, x, err); }
bool rp_gt(Real x, Real y, Real err = g_err) { return !rp_le(x, y, err); }
bool rp_lt(Real x, Real y, Real err = g_err) { return !rp_le(y, x, err); }
bool rp_ne(Real x, Real y, Real err = g_err) { return !rp_eq(x, y, err); }
template <typename T>
bool updMax(T& tmax, const T& x) {
if (x > tmax) {
tmax = x;
return true;
} else {
return false;
}
}
template <typename T>
bool updMin(T& tmin, const T& x) {
if (x < tmin) {
tmin = x;
return true;
} else {
return false;
}
}
struct Point {
Real x;
Real y;
Point() : x(0), y(0) {}
Point(Real x_, Real y_) : x(x_), y(y_) {}
bool operator==(const Point& p) const { return x == p.x && y == p.y; }
bool operator!=(const Point& p) const { return !(*this == p); }
bool sim(const Point& p, Real err = g_err) const {
return r_eq(x, p.x, err) && r_eq(y, p.y, err);
}
static bool sim(const Point& p1, const Point& p2, Real err = g_err) {
return p1.sim(p2, err);
}
Point& operator+=(const Point& p) {
x += p.x;
y += p.y;
return *this;
}
Point& operator-=(const Point& p) {
x -= p.x;
y -= p.y;
return *this;
}
Point& operator*=(Real k) {
x *= k;
y *= k;
return *this;
}
Point& operator/=(Real k) {
x /= k;
y /= k;
return *this;
}
Point operator+(const Point& p) const { return Point(*this) += p; }
Point operator-(const Point& p) const { return Point(*this) -= p; }
Point operator*(Real k) const { return Point(*this) *= k; }
Point operator/(Real k) const { return Point(*this) /= k; }
Point operator-() const { return (*this) * (-1); }
Real len() const { return hypot(x, y); }
static Point polar(Real r, Real th) {
return Point(r * cos(th), r * sin(th));
}
Point rotate(Real th) const { return polar(len(), atan2(y, x) + th); }
Point rotateQ() const { return Point(-y, x); }
bool parallel(const Point& p, Real err = g_err) const {
return r_eq(x * p.y, y * p.x, err);
}
Real innerProd(const Point& p) const { return x * p.x + y * p.y; }
Real outerProd(const Point& p) const { return x * p.y - y * p.x; }
Real arg() const { return atan2(y, x); }
Real angle(const Point& p) const {
Real th = atan2(p.y, p.x) - atan2(y, x);
return th > 3.141592653589793238462643383279502884L
? th - 2 * 3.141592653589793238462643383279502884L
: th <= -3.141592653589793238462643383279502884L
? th + 2 * 3.141592653589793238462643383279502884L
: th;
}
};
Point operator*(Real k, const Point& p) { return p * k; }
ostream& operator<<(ostream& os, const Point& p) {
return os << "(" << p.x << ", " << p.y << ")";
}
struct Line;
ostream& operator<<(ostream& os, const Line& l);
struct Line {
Point dir;
Point base;
static Line x_axis;
static Line y_axis;
static constexpr int SIDE_ON = 1;
static constexpr int SIDE_P = 2;
static constexpr int SIDE_N = 4;
static constexpr int IST_NONE = -1;
static constexpr int IST_ALL = -2;
static constexpr int IST_ONE = 0;
Line() : dir(0, 0), base(0, 0) {}
Line(const Point& d, const Point& b) : dir(d), base(b) {}
bool operator==(const Line& l) const {
return dir == l.dir && base == l.base;
}
bool operator!=(const Line& l) const { return !(*this == l); }
bool sim(const Line& l1, Real err = g_err) const {
return dir.sim(l1.dir, err) && dir.sim(l1.base - base, err);
}
static bool sim(const Line& l1, const Line& l2, Real err = g_err) {
return l1.sim(l2, err);
}
static Line connect(const Point& p1, const Point& p2) {
return Line(p2 - p1, p1);
}
bool parallel(const Line& l, Real err = g_err) const {
return dir.parallel(l.dir, err);
}
int ptSide(const Point& p, Real err = g_err) const {
Real t1 = dir.y * (p.x - base.x);
Real t2 = dir.x * (p.y - base.y);
if (r_eq(t1, t2, err)) return SIDE_ON;
if (r_lt(t1, t2, err)) return SIDE_P;
return SIDE_N;
}
bool ptOn(const Point& p, Real err = g_err) const {
return ptSide(p, err) == SIDE_ON;
}
tuple<int, Real, Real> intersect_coeff(const Line& l) const {
if (dir.parallel(l.dir)) {
if (ptOn(l.base))
return make_tuple(IST_ALL, 0, 0);
else
return make_tuple(IST_NONE, 0, 0);
} else {
Real d = dir.x * (-l.dir.y) - (-l.dir.x) * dir.y;
Point z = l.base - base;
Real t1 = ((-l.dir.y) * z.x + l.dir.x * z.y) / d;
Real t2 = ((-dir.y) * z.x + dir.x * z.y) / d;
return {IST_ONE, t1, t2};
}
}
Point unsafe_intersect(const Line& l) const {
auto [rc, t1, t2] = intersect_coeff(l);
assert(rc == IST_ONE);
return base + t1 * dir;
}
Point perpend_foot(const Point& p) const {
Real t1 = perpend_foot_coeff(p);
return base + t1 * dir;
}
Real perpend_foot_coeff(const Point& p) const {
auto [rc, t1, t2] = intersect_coeff(Line(dir.rotateQ(), p));
return t1;
}
Real len(const Point& p) const { return (p - perpend_foot(p)).len(); }
};
ostream& operator<<(ostream& os, const Line& l) {
return os << "[d " << l.dir << ", b " << l.base << ")";
}
Line Line::x_axis(Point(1, 0), Point(0, 0));
Line Line::y_axis(Point(0, 1), Point(0, 0));
struct Circle {
Point c;
Real r;
Circle() : c(0, 0), r(0) {}
Circle(const Point& c_, Real r_) : c(c_), r(r_) {}
bool operator==(const Circle& o) const { return c == o.c && r == o.r; }
bool operator!=(const Circle& o) const { return !(*this == o); }
bool sim(const Circle& o, Real err = g_err) const {
return c.sim(o.c, err) && r_eq(r, o.r, err);
}
static bool sim(const Circle& c1, const Circle& c2, Real err = g_err) {
return c1.sim(c2, err);
}
bool ptOn(const Point& p, Real err = g_err) const {
return r_eq((p - c).len(), r, err);
}
tuple<bool, Point, Point> intersect(const Line& o) const {
Point f = o.perpend_foot(c);
Real d = (f - c).len();
if (d > r) return make_tuple(false, Point(), Point());
Real t = sqrt(r * r - d * d);
Point e = o.dir / o.dir.len();
return make_tuple(true, f + t * e, f - t * e);
}
tuple<bool, Point, Point> intersect(const Circle& o) const {
Real d = (o.c - c).len();
if (d + r < o.r || d + o.r < r || r + o.r < d) {
return make_tuple(false, Point(), Point());
}
Point v = (o.c - c) / d;
Real t = (r * r - o.r * o.r + d * d) / (2 * d);
Line l(v.rotateQ(), c + t * v);
return intersect(l);
}
};
ostream& operator<<(ostream& os, const Circle& circ) {
return os << "[c " << circ.c << ", " << circ.r << "]";
}
Point circumcenter(const Point& z1, const Point& z2, const Point& z3) {
Line l12((z2 - z1).rotateQ(), (z1 + z2) / 2);
Line l23((z3 - z2).rotateQ(), (z2 + z3) / 2);
return l12.unsafe_intersect(l23);
}
vector<Point> convex_hull(const vector<Point>& pts) {
vector<Point> spts(pts);
int n = pts.size();
if (n == 0) return vector<Point>();
auto sub = [&]() -> vector<Point> {
vector<Point> ret;
for (int i = 0; i < n; i++) {
Point pt = spts.at(i);
if (i > 0 && spts.at(i - 1).sim(spts.at(i))) continue;
while (true) {
int rs = ret.size();
if (rs - 2 < 0) break;
Point q0 = ret.at(rs - 2);
Point q1 = ret.at(rs - 1);
if ((q0 - q1).outerProd(pt - q1) < 0) break;
ret.pop_back();
}
ret.push_back(pt);
}
ret.pop_back();
return ret;
};
sort(spts.begin(), spts.end(), [](const Point& a, const Point& b) -> bool {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
});
auto vec1 = sub();
reverse(spts.begin(), spts.end());
auto vec2 = sub();
vec1.insert(vec1.end(), vec2.begin(), vec2.end());
if (vec1.empty()) return vector<Point>({pts.at(0)});
return vec1;
}
tuple<Real, int, int> convex_diameter(const vector<Point>& pts) {
int n = pts.size();
if (n <= 1) {
cerr << "diameter is called with <=1 points.\n";
exit(1);
}
auto conn = [&](long long int i, long long int j) -> Point {
return pts.at(j % n) - pts.at(i % n);
};
auto edge = [&](long long int i) -> Point { return conn(i, i + 1); };
if (n == 2) return make_tuple(conn(0, 1).len(), 0, 1);
int k = -1;
int m = -1;
for (int i = 0, cnt = 0; cnt < 2; i++) {
if (edge(i).y <= 0 && edge(i + 1).y > 0) {
m = i + 1;
cnt++;
}
if (edge(i).y >= 0 && edge(i + 1).y < 0) {
k = i + 1;
cnt++;
}
}
Real vmax = 0;
int k0 = -1, m0 = -1;
bool run_k = true;
bool run_m = true;
while (run_k || run_m) {
if (!run_m ||
(run_k && edge(k).arg() - (-3.141592653589793238462643383279502884L) <=
edge(m).arg())) {
if (updMax(vmax, conn(k + 1, m).len())) {
k0 = k + 1, m0 = m;
}
k++;
if (edge(k).y > 0) run_k = false;
} else {
if (updMax(vmax, conn(k, m + 1).len())) {
k0 = k, m0 = m + 1;
}
m++;
if (edge(m).y < 0) run_m = false;
}
}
return make_tuple(vmax, k0 % n, m0 % n);
}
int in_triangle(const Point& pt, const Point& tr0, const Point& tr1,
const Point& tr2) {
auto chk = [&](const Point& b, const Point& e, const Point& p) -> bool {
Point be = e - b;
Point bp = p - b;
Real r = r_eq(be.x, 0.0) ? bp.y / be.y : bp.x / be.x;
return 0.0 <= r && r <= 1.0;
};
Line l01 = Line::connect(tr0, tr1);
Line l12 = Line::connect(tr1, tr2);
Line l20 = Line::connect(tr2, tr0);
int side = l01.ptSide(tr2);
if (side == Line::SIDE_ON) {
if (!l01.ptOn(pt)) return Line::SIDE_N;
return chk(tr0, tr1, pt) || chk(tr1, tr2, pt) || chk(tr2, tr0, pt)
? Line::SIDE_ON
: Line::SIDE_N;
}
int other = side ^ (Line::SIDE_P | Line::SIDE_N);
if (l01.ptSide(pt) == other || l12.ptSide(pt) == other ||
l20.ptSide(pt) == other)
return Line::SIDE_N;
if (l01.ptSide(pt) == Line::SIDE_ON || l12.ptSide(pt) == Line::SIDE_ON ||
l20.ptSide(pt) == Line::SIDE_ON)
return Line::SIDE_ON;
return Line::SIDE_P;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T1, typename T2, typename T3>
ostream& operator<<(ostream& os, const tuple<T1, T2, T3>& t) {
os << "(" << get<0>(t) << ", " << get<1>(t) << ", " << get<2>(t) << ")";
return os;
}
template <typename T1, typename T2, typename T3, typename T4>
ostream& operator<<(ostream& os, const tuple<T1, T2, T3, T4>& t) {
os << "(" << get<0>(t) << ", " << get<1>(t) << ", " << get<2>(t) << ", "
<< get<3>(t) << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << '[';
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
os << ']';
return os;
}
template <typename T, typename C>
ostream& operator<<(ostream& os, const set<T, C>& v) {
os << '{';
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
os << '}';
return os;
}
template <typename T, typename C>
ostream& operator<<(ostream& os, const unordered_set<T, C>& v) {
os << '{';
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
os << '}';
return os;
}
template <typename T, typename C>
ostream& operator<<(ostream& os, const multiset<T, C>& v) {
os << '{';
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
os << '}';
return os;
}
template <typename T1, typename T2, typename C>
ostream& operator<<(ostream& os, const map<T1, T2, C>& mp) {
os << '[';
for (auto it = mp.begin(); it != mp.end(); it++) {
if (it != mp.begin()) os << ", ";
os << it->first << ": " << it->second;
}
os << ']';
return os;
}
template <typename T1, typename T2, typename C>
ostream& operator<<(ostream& os, const unordered_map<T1, T2, C>& mp) {
os << '[';
for (auto it = mp.begin(); it != mp.end(); it++) {
if (it != mp.begin()) os << ", ";
os << it->first << ": " << it->second;
}
os << ']';
return os;
}
template <typename T, typename T2>
ostream& operator<<(ostream& os, const queue<T, T2>& orig) {
queue<T, T2> que(orig);
bool first = true;
os << '[';
while (!que.empty()) {
T x = que.front();
que.pop();
if (!first) os << ", ";
os << x;
first = false;
}
return os << ']';
}
template <typename T, typename T2>
ostream& operator<<(ostream& os, const deque<T, T2>& orig) {
deque<T, T2> que(orig);
bool first = true;
os << '[';
while (!que.empty()) {
T x = que.front();
que.pop_front();
if (!first) os << ", ";
os << x;
first = false;
}
return os << ']';
}
template <typename T, typename T2, typename T3>
ostream& operator<<(ostream& os, const priority_queue<T, T2, T3>& orig) {
priority_queue<T, T2, T3> pq(orig);
bool first = true;
os << '[';
while (!pq.empty()) {
T x = pq.top();
pq.pop();
if (!first) os << ", ";
os << x;
first = false;
}
return os << ']';
}
template <typename T>
ostream& operator<<(ostream& os, const stack<T>& st) {
stack<T> tmp(st);
os << '[';
bool first = true;
while (!tmp.empty()) {
T& t = tmp.top();
if (first)
first = false;
else
os << ", ";
os << t;
tmp.pop();
}
os << ']';
return os;
}
ostream& operator<<(ostream& os, int8_t x) {
os << (int32_t)x;
return os;
}
template <class... Args>
string dbgFormat(const char* fmt, Args... args) {
size_t len = snprintf(nullptr, 0, fmt, args...);
char buf[len + 1];
snprintf(buf, len + 1, fmt, args...);
return string(buf);
}
template <class Head>
void dbgLog(bool with_nl, Head&& head) {
cerr << head;
if (with_nl) cerr << endl;
}
template <class Head, class... Tail>
void dbgLog(bool with_nl, Head&& head, Tail&&... tail) {
cerr << head << " ";
dbgLog(with_nl, forward<Tail>(tail)...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << setprecision(20);
long long int n, q;
cin >> n >> q;
vector<Point> P(n);
for (long long int i = 0; i < n; i++) {
long long int x, y;
cin >> x >> y;
P[i] = Point(x, y);
}
Point g(0, 0);
Real tots = 0;
for (long long int i = 1; i < n - 1; i++) {
Point lg = (P[0] + P[i] + P[i + 1]) / 3.0;
Point v0i = P[i] - P[0];
Point v0j = P[i + 1] - P[0];
Real s = abs(v0i.x * v0j.y - v0i.y * v0j.x);
tots += s;
g += s * lg;
}
g = g / tots;
vector<Real> L(n), Th(n);
for (long long int i = 0; i < n; i++) {
L[i] = (P[i] - g).len();
Th[i] = (P[0] - g).angle(P[i] - g);
};
;
;
Real th0 = (P[0] - g).arg();
;
long long int pinA = 0, pinB = 1;
for (long long int _q = 0; _q < q; _q++) {
long long int tp;
cin >> tp;
if (tp == 1) {
long long int f, t;
cin >> f >> t;
f--;
t--;
if (f == pinA) {
pinA = pinB;
pinB = t;
} else {
pinB = t;
};
Point e(L[pinA], 0);
Point pa = g + e.rotate(th0 + Th[pinA]);
g = pa + e.rotate(3 * 3.141592653589793238462643383279502884L / 2);
;
th0 += 3.141592653589793238462643383279502884L / 2.0 - (th0 + Th[pinA]);
;
} else if (tp == 2) {
long long int v;
cin >> v;
v--;
Point e(L[v], 0);
Point pv = g + e.rotate(th0 + Th[v]);
cout << pv.x << " " << pv.y << "\n";
}
}
return 0;
}
| 5 |
#include <cstdio>
#include <algorithm>
#include <vector>
#include <functional>
#include <cassert>
#include <map>
#include <set>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 5000001;
long long fact[N];
long long invfact[N];
long long inv[N];
void init() {
fact[0] = fact[1] = 1;
for (int i = 2; i < N; i ++) fact[i] = fact[i - 1] * i % MOD;
inv[1] = 1;
for (int i = 2; i < N; i ++) inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
invfact[0] = invfact[1] = 1;
for (int i = 2; i < N; i ++) invfact[i] = invfact[i - 1] * inv[i] % MOD;
}
long long C(long long n, long long r) {
if (n < 0 || r < 0 || n < r) return 0;
return fact[n] * invfact[n - r] % MOD * invfact[r] % MOD;
}
vector<int> get_centroids(vector<vector<int> > const & g, int root, set<int> const & forbidden) {
int n = 0;
map<int, int> available; {
function<void (int, int)> go = [&](int i, int parent) {
//available.emplace(i, available.size());
available[i] = n ++;
for (auto j : g[i]) if (j != parent and not forbidden.count(j)) {
go(j, i);
}
};
go(root, -1);
}
//int n = available.size();
vector<int> result;
vector<int> size(n, -1);
function<void (int, int)> go = [&](int x, int parent) {
bool is_centroid = true;
int i = available[x];
size[i] = 1;
for (auto y : g[x]) if (y != parent and !forbidden.count(y)) {
int j = available[y];
go(y, x);
size[i] += size[j];
if (size[j] > n / 2) is_centroid = false;
}
if (n - size[i] > n / 2) is_centroid = false;
if (is_centroid) result.push_back(x);
};
go(root, -1);
return result;
}
int main() {
init();
int n;
scanf("%d", &n);
vector<vector<int>> g(n);
for (int i = 0; i < n - 1; i ++) {
int a, b;
scanf("%d%d", &a, &b);
a --, b --;
g[a].push_back(b);
g[b].push_back(a);
}
set<int> forbidden;
auto get = get_centroids(g, 0, forbidden);
if (get.size() == 2) {
long long ans = fact[n / 2] * fact[n / 2] % MOD;
printf("%lld\n", ans);
return 0;
}
int centroid = get[0];
vector<int> sz(n);
function<void (int, int)> get_size = [&](int u, int prev) {
sz[u] = 1;
for (auto v : g[u]) if (v != prev) {
get_size(v, u);
sz[u] += sz[v];
}
};
get_size(centroid, -1);
vector<int> subtrees;
for (auto v : g[centroid]) subtrees.push_back(sz[v]);
int k = (int) subtrees.size();
vector<vector<long long>> dp(k + 1, vector<long long> (n + 1, 0));
dp[0][1] = 1;
for (int i = 0; i < k; i ++) {
int num = subtrees[i];
for (int j = 0; j <= n; j ++) {
for (int l = 0; l <= num; l ++) {
if (l & 1) {
(dp[i + 1][j + num - l] -= dp[i][j] * C(num, l) % MOD * fact[num] % MOD * invfact[num - l] % MOD) %= MOD;
} else {
(dp[i + 1][j + num - l] += dp[i][j] * C(num, l) % MOD * fact[num] % MOD * invfact[num - l] % MOD) %= MOD;
}
}
}
}
long long ans = 0;
for (int i = 0; i <= n; i ++) {
(ans += dp[k][i] * fact[i] % MOD) %= MOD;
}
ans = ((ans % MOD) + MOD) % MOD;
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double eps = 1e-8;
using namespace std;
int a[200005];
int b[200005];
int c[200005];
int d[200005];
int n;
int ans;
int main() {
int t, cases = 0;
scanf("%d", &n);
int ans = 0x3f3f3f3f;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 0; i < n / 2; i++) {
if (a[i + n / 2] - a[i] < ans) ans = a[i + n / 2] - a[i];
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n - 1; i++) {
if ((a[i] > a[i - 1]) && (a[i] > a[i + 1])) {
++count;
}
if (a[i] < a[i - 1] && a[i] < a[i + 1]) {
++count;
}
}
cout << count;
return 0;
}
| 1 |
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define FOR(i, s, n) for (ll i = (s); i < (ll)(n); i++)
#define FOREQ(i, s, n) for (ll i = (s); i <= (ll)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
ll n, m, w, t;
ll sell[100];
ll weight[100];
char str[1000];
vector<ll> goodBuy[100];
vector<ll> goodWeight[100];
ll px[100];
ll py[100];
ll dist(int i, int j) { return abs(px[i] - px[j]) + abs(py[i] - py[j]); }
ll memo[8][1 << 7];
ll CalcTime(int last, int rest) {
if (memo[last][rest] != -1) { return memo[last][rest]; }
ll ret = 1LL << 60;
if (rest == 0) {
ret = dist(last, n);
} else {
REP(i, n) {
if (!((rest >> i) & 1)) { continue; }
int nrest = rest & (~(1 << i));
ret = min(ret, CalcTime(i, nrest) + dist(last, i));
}
}
return memo[last][rest] = ret;
}
ll dp[10010];
ll CalcRieki(int use) {
ll ret = 0;
MEMSET(dp, 0);
REP(i, n) {
if (!((use >> i) & 1)) { continue; }
REP(j, goodBuy[i].size()) {
REP(k, w) {
int nw = k + goodWeight[i][j];
if (nw > w) { break; }
dp[nw] = max(dp[nw], dp[k] + goodBuy[i][j]);
ret = max(ret, dp[nw]);
}
}
}
return ret;
}
ll mainDP[10010];
int main() {
while (scanf("%lld %lld %lld %lld", &n, &m, &w, &t) > 0) {
MEMSET(mainDP, 0);
MEMSET(memo, -1);
REP(i, 100) { goodBuy[i].clear(); }
REP(i, 100) { goodWeight[i].clear(); }
map<string, ll> mapto;
REP(i, m) {
scanf("%s %lld %lld", str, &weight[i], &sell[i]);
mapto[str] = i;
}
REP(i, n) {
ll l;
scanf("%lld %lld %lld", &l, &px[i], &py[i]);
REP(j, l) {
ll b;
scanf("%s %lld", str, &b);
ll index = mapto[str];
goodWeight[i].push_back(weight[index]);
goodBuy[i].push_back(max(sell[index] - b, 0LL));
}
}
px[n] = 0;
py[n] = 0;
ll ans = 0;
REP(i, 1 << n) {
ll time = CalcTime(n, i);
ll rieki = CalcRieki(i);
REP(k, t) {
ll nt = k + time;
if (nt > t) { break; }
mainDP[nt] = max(mainDP[nt], mainDP[k] + rieki);
ans = max(ans, mainDP[nt]);
}
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 1000010;
const int mo = 1000000007;
using namespace std;
int n, cnt[2];
long long f[maxn];
int main() {
scanf("%d", &n);
int x;
for (int i = 1; i <= n; ++i) scanf("%d", &x), ++cnt[x - 1];
f[0] = f[1] = 1;
for (int i = 2; i <= cnt[0]; ++i) f[i] = (f[i - 1] + f[i - 2] * (i - 1)) % mo;
long long ans = f[cnt[0]];
for (int i = 1; i <= cnt[1]; ++i) ans = (ans * (i + cnt[0])) % mo;
printf("%I64d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long N = 2e5 + 10;
using namespace std;
long long n, a[N], x, m, xx, sum = 0, store[N] = {}, ind = 1, a2[N] = {};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
while (m--) {
int type;
cin >> type >> x;
if (type == 1) {
cin >> xx;
a[x] = xx;
a2[x] = ind - 1;
} else if (type == 2)
sum += x, store[ind] = sum, ind++;
else
cout << sum - store[a2[x]] + a[x] << '\n';
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t[15];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, a;
cin >> n >> m;
int mini = INT_MAX, mini2 = INT_MAX, ind = 20;
for (int i = 0; i < n; i++) {
cin >> a;
t[a]++;
mini = min(mini, a);
}
for (int i = 0; i < m; i++) {
cin >> a;
t[a]++;
if (t[a] >= 2) {
ind = min(ind, a);
}
mini2 = min(mini2, a);
}
if (ind != 20)
cout << ind << endl;
else
cout << min(mini * 10 + mini2, mini2 * 10 + mini) << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define MOD 1000000007;
string S;
long long dp[100010][13];
int main(){
cin >> S;
dp[0][0] = 1;
for(int i = 0; i < S.size(); i++){
int num;
if(S[i] == '?') num = 10;
else num = S[i] - '0';
for(int j = 0; j < 10; j++){
if(num != 10 && num != j) continue;
for(int k = 0; k < 13; k++) dp[i+1][(k*10+j)%13] += dp[i][k];
}
for(int l = 0; l < 13; l++) dp[i+1][l] %= MOD;
}
cout << dp[S.size()][5] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lb = 1000;
void vrikodara(long long n = 12) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(n) << fixed;
}
long long t1, t2, x1, x2;
double t0, d = INT_MAX;
void solve() {
cin >> t1 >> t2 >> x1 >> x2 >> t0;
if (t1 == t2) {
cout << x1 << " " << x2;
return;
}
if (t1 == t0) {
cout << x1 << " 0";
return;
}
if (t2 == t0) {
cout << "0 " << x2;
return;
}
long long a1 = -1, a2 = -1;
for (long long y1 = x1; y1 >= 0; y1--) {
double num = t0 * y1 - t1 * y1;
double den = t2 - t0;
long long y2 = ceil(num / den);
long long yd = y2 - 1;
double a = (t1 * y1 + t2 * y2) / (double)(y1 + y2);
double b = (t1 * y1 + t2 * yd) / (double)(y1 + yd);
if (yd < 0 || yd > x2) b = 1e17;
if (y2 > x2) a = 1e17;
double p1 = a - t0, p2 = b - t0;
if (p1 == 0) {
cout << y1 << " " << y2;
return;
}
if (p2 == 0) {
cout << y1 << " " << yd;
return;
}
if (p1 > 0 && p1 < d) {
a1 = y1;
a2 = y2;
d = p1;
}
if (p2 > 0 && p2 < d) {
a1 = y1;
a2 = yd;
d = p2;
}
}
if (a1 == a2 && a1 == -1) {
cout << "0 " << x2;
return;
}
cout << a1 << " " << a2;
}
int32_t main() {
vrikodara();
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <cstdio>
#include <utility>
#include <map>
using namespace std;
char s[510], ans[510];
inline void upd(char &p, int &m, char c, char d) {
if (p > c) p = c, m = 0;
if (p == c) m |= 1 << d;
}
void solve() {
int n, k;
scanf("%d%d%s", &n, &k, s);
for (int i = 0; i < n; i++) {
s[i] -= 'a';
}
if (n == 1) {
if (s[0] == k - 1) {
s[0] = 0;
} else if (s[0]) {
s[0]--;
}
s[0] += 'a';
puts(s);
return;
}
int m1 = 1 << 26, m2 = 0;
char pp = -1, p2 = -1;
for (int i = 0; i < n; i++) {
char z, u = s[i];
int n1 = 0, n2 = 0;
if (u == k - 1) {
u = 0;
} else if (u) {
--u;
}
if (m2 && p2 != -1 && s[i] < pp) {
z = s[i];
pp = p2;
p2 = 26;
n1 = m2;
n2 = 0;
} else {
z = pp;
int f = pp == p2;
pp = p2 = 26;
for (int j = 0; j < k; j++) {
if (m1 >> j & 1) {
upd(pp, n1, s[i], j);
if (i + 1 < n) upd(p2, n2, j, s[i]);
upd(pp, n1, j, u);
}
if (f && (m2 >> j & 1)) {
upd(pp, n1, j, s[i]);
upd(pp, n1, u, j);
}
}
if (m1 >> 26 & 1) {
if (i + 1 < n) upd(p2, n2, -1, s[i]);
upd(pp, n1, -1, u);
}
}
if (i > 1) ans[i-2] = z;
m1 = n1;
m2 = n2;
}
ans[n-2] = pp;
for (int i = 0; i < k; i++) {
if ((m1 | m2) >> i & 1) {
ans[n-1] = i;
break;
}
}
for (int i = 0; i < n; i++) {
ans[i] += 'a';
}
ans[n] = 0;
puts(ans);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, set<int>> mp;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool cross(long long x1, long long y1, long long x2, long long y2) {
return (x1 * y2 - x2 * y1);
}
bool check(long long i, long long j, long long x1, long long y1, long long x2,
long long y2, long long x3, long long y3, long long x4,
long long y4) {
long long a = ((y2 - y1) * (x4 - x3) - (y4 - y3) * (x2 - x1));
if (a == 0) {
return (x1 == x3 && y1 == y3) || (x1 == x4 && y1 == y4) ||
(x2 == x3 && y2 == y3) || (x2 == x4 && y2 == y4);
}
long long x =
((x2 - x1) * (y3 * x4 - y4 * x3) - (y1 * x2 - y2 * x1) * (x4 - x3)) / a;
long long y;
if (x2 - x1 == 0) {
y = ((y4 - y3) * x + (y3 * x4 - y4 * x3)) / (x4 - x3);
} else {
y = ((y2 - y1) * x + (y1 * x2 - y2 * x1)) / (x2 - x1);
}
if (x >= min(x1, x2) && x <= max(x1, x2) && y >= min(y1, y2) &&
y <= max(y1, y2) && x >= min(x3, x4) && x <= max(x3, x4) &&
y >= min(y3, y4) && y <= max(y3, y4)) {
if (cross(x1 - x, y1 - y, x2 - x, y2 - y) == 0 &&
cross(x3 - x, y3 - y, x4 - x, y4 - y) == 0) {
mp[pair<long long, long long>(x, y)].insert(i);
mp[pair<long long, long long>(x, y)].insert(j);
return true;
}
}
return false;
}
int main() {
int N;
cin >> N;
vector<vector<long long>> vs;
long long res = 0;
for (int i = 0; i < N; i++) {
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
vs.push_back({x1, y1, x2, y2});
long long a = x1 - x2, b = y1 - y2;
long long g = gcd(abs(a), abs(b));
a = a / g;
b = b / g;
long long k;
if (b != 0) {
k = (max(y2, y1) - min(y2, y1)) / abs(b);
} else {
k = (max(x2, x1) - min(x2, x1)) / abs(a);
}
res += k + 1;
}
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
long long x1, y1, x2, y2, x3, y3, x4, y4;
x1 = vs[i][0];
y1 = vs[i][1];
x2 = vs[i][2];
y2 = vs[i][3];
x3 = vs[j][0];
y3 = vs[j][1];
x4 = vs[j][2];
y4 = vs[j][3];
if (check(i, j, x1, y1, x2, y2, x3, y3, x4, y4)) {
}
}
}
for (auto it = mp.begin(); it != mp.end(); it++) {
res -= it->second.size() - 1;
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
void needForSpeed() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool isPrime(long long a) {
if (a < 2) return 0;
for (long long i = 2; i <= sqrt(a); i++)
if (a % i == 0) return 0;
return 1;
}
long long binpow(long long base, long long pow, long long mod) {
if (pow == 0)
return 1;
else if (pow % 2)
return base * binpow(base, pow - 1, mod) % mod;
else {
long long p = binpow(base, pow / 2, mod);
return p * p % mod;
}
}
int solve() {
long long n, m, ans = 0;
cin >> n >> m;
long long l = 1, r = n;
while (m--) {
long long L, R;
cin >> L >> R;
long long t = min(L, R);
R = max(L, R);
L = t;
if (L >= r || R <= l) return cout << 0, 0;
l = max(l, L);
r = min(r, R);
}
if (r <= l) return cout << 0, 0;
cout << (r - l);
return 0;
}
int main() {
needForSpeed();
int tests = 1;
while (tests--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void min_self(C &a, C b) {
a = min(a, b);
}
template <class C>
void max_self(C &a, C b) {
a = max(a, b);
}
const long long MOD = 1000000007;
long long mod(long long n, long long m = MOD) {
n %= m, n += m, n %= m;
return n;
}
const int MAXN = 1e5 + 5;
const int LOGN = 21;
const long long INF = 1e14;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
template <class T1, class T2>
void add(T1 &x, T2 y, long long m = MOD) {
x += y;
if (x >= m) x -= m;
}
template <class T1, class T2>
void sub(T1 &x, T2 y, long long m = MOD) {
x -= y;
if (x < 0) x += m;
}
char grid[10][10];
void solve() {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
cin >> grid[i][j];
}
}
auto change = [&](char &x) { x = '0' + mod((x - '0'), 9) + 1; };
change(grid[0][0]);
change(grid[3][1]);
change(grid[6][2]);
change(grid[1][3]);
change(grid[4][4]);
change(grid[7][5]);
change(grid[2][6]);
change(grid[5][7]);
change(grid[8][8]);
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
cout << grid[i][j];
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int test = 1; test <= t; test++) {
solve();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
char ss[N];
char str[N];
int main() {
scanf("%s", ss + 1);
int n = strlen(ss + 1);
for (int i = 1; i <= n; i++) {
if (ss[i] == '1' || ss[i] == '2') {
puts("No");
return 0;
}
if (ss[i] == '3') str[i] = '3';
if (ss[i] == '4') str[i] = '6';
if (ss[i] == '5') str[i] = '9';
if (ss[i] == '6') str[i] = '4';
if (ss[i] == '7') str[i] = '7';
if (ss[i] == '8') str[i] = '0';
if (ss[i] == '9') str[i] = '5';
if (ss[i] == '0') str[i] = '8';
}
for (int i = 1; i <= n; i++) {
if (ss[i] != str[n - i + 1]) {
puts("No");
return 0;
}
}
puts("YES");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=(0);(i)<(int)(n);++(i))
using ll = long long;
//using P = pair<int, int>;
using namespace std;
struct Node {
int location;
int p, l, r;
Node() {}
};
struct Point {
int id, x, y;
Point() {}
Point (int id, int x, int y) :id(id), x(x), y(y) {}
bool operator<(const Point& p) const {
return id < p.id;
}
void print() {
printf("%d\n", id);
}
};
static const int MAX = 1000000;
static const int NIL = -1;
int N;
Point P[MAX];
Node T[MAX];
int np;
bool lessX(const Point &p1, const Point &p2) {
return p1.x < p2.x;
}
bool lessY(const Point &p1, const Point &p2) {
return p1.y < p2.y;
}
int makekDTree(int l, int r, int depth) {
if (!(l<r)) return NIL;
int mid = (l + r) / 2;
int t = np++;
if (depth%2 == 0) {
sort(P + l, P + r, lessX);
}
else {
sort(P + l, P + r, lessY);
}
T[t].location = mid;
T[t].l = makekDTree(l, mid, depth + 1);
T[t].r = makekDTree(mid+1, r, depth + 1);
return t;
}
void find(int v, int sx, int tx, int sy, int ty, int depth, vector<Point> & ans) {
int x = P[T[v].location].x;
int y = P[T[v].location].y;
if (sx <= x and x <= tx and sy <= y and y <= ty) {
ans.push_back(P[T[v].location]);
}
if (depth%2 == 0) {
if (T[v].l != NIL) {
if (sx <= x) find(T[v].l, sx, tx, sy, ty, depth + 1, ans);
}
if (T[v].r != NIL) {
if (x <= tx) find(T[v].r, sx, tx, sy, ty, depth + 1, ans);
}
}
else {
if (T[v].l != NIL) {
if (sy <= y) find(T[v].l, sx, tx, sy, ty, depth + 1, ans);
}
if (T[v].r != NIL) {
if (y <= ty) find(T[v].r, sx, tx, sy, ty, depth + 1, ans);
}
}
}
int main() {
int x, y;
scanf("%d", &N);
rep(i, N) {
scanf("%d %d", &x, &y);
P[i] = Point(i, x, y);
T[i].l = T[i].r = T[i].p = NIL;
}
np = 0;
int root = makekDTree(0, N, 0);
int q;
scanf("%d", &q);
int sx, tx, sy, ty;
vector<Point> ans;
rep(i, q) {
scanf("%d %d %d %d", &sx, &tx, &sy, &ty);
ans.clear();
find(root, sx, tx, sy, ty, 0, ans);
sort(ans.begin(), ans.end());
rep(j, ans.size()) {
ans[j].print();
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long long ara[N], sum[N];
int main() {
long long n, p;
scanf("%lld %lld", &n, &p);
for (long long i = 1; i <= n; i++)
scanf("%lld", &ara[i]), sum[i] = sum[i - 1] + ara[i];
long long ans = 0;
for (long long i = 1; i < n; i++) {
ans = max(ans, sum[i] % p + (sum[n] - sum[i]) % p);
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define PB push_back
const int INF = (1LL<<30);
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
while(true) {
int n;
cin >> n;
if(!n) break;
vector<string> t(n);
REP(i, n) cin >> t[i];
// 内包されているようなのは消す
vector<bool> del(n, false);
REP(i, n) REP(j, n) {
if(i==j || del[i] || del[j] || t[i].size() < t[j].size()) continue;
REP(k, t[i].size()-t[j].size()+1) {
string tmp = t[i].substr(k, t[j].size());
// cout << tmp << endl;
if(tmp == t[j]) del[j] = true;
}
}
vector<string> s;
REP(i, n) if(!del[i]) s.PB(t[i]);
n = s.size();
// i->j とつなげるときのsuffixとprefixが一致する最大の長さ
VVI trans(n, VI(n, 0));
REP(i, n) REP(j, n) {
if(i==j) continue;
REP(k, min(s[i].size(), s[j].size())) {
string tmp1 = s[i].substr(s[i].size()-k-1), tmp2 = s[j].substr(0, k+1);
// cout << tmp1 << " " << tmp2 << endl;
if(tmp1 == tmp2) trans[i][j] = k+1;
}
}
// bitDPする
VVI dp(1LL<<n, VI(n, INF));
REP(i, n) dp[1<<i][i] = s[i].size();
REP(i, 1LL<<n) REP(j, n) {
if(dp[i][j] == INF) continue;
REP(k, n) {
if(i&1<<k) continue;
chmin(dp[i|1<<k][k], dp[i][j]+((int)s[k].size()-trans[j][k]));
}
}
int ans = INF;
REP(i, n) chmin(ans, dp[(1LL<<n)-1][i]);
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
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 double &RF(double &);
inline double RF() {
double x;
return RF(x);
}
inline char *RS(char *s);
inline char &RC(char &c);
inline char RC();
inline char &RC(char &c) {
scanf(" %c", &c);
return c;
}
inline char RC() {
char c;
return RC(c);
}
template <class T>
inline T &RDD(T &);
inline long long RDD() {
long long x;
return RDD(x);
}
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 double &RF(double &a, double &b) {
RF(a), RF(b);
return a;
}
inline double &RF(double &a, double &b, double &c) {
RF(a), RF(b), RF(c);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d) {
RF(a), RF(b), RF(c), RF(d);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e) {
RF(a), RF(b), RF(c), RF(d), RF(e);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e,
double &f) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e,
double &f, 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 T0, class T1>
inline T0 &RDD(T0 &a, T1 &b) {
RDD(a), RDD(b);
return a;
}
template <class T0, class T1, class T2>
inline T1 &RDD(T0 &a, T1 &b, T2 &c) {
RDD(a), RDD(b), RDD(c);
return a;
}
template <class T>
inline void RST(T &A) {
memset(A, 0, sizeof(A));
}
template <class T>
inline void FLC(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T>
inline void CLR(T &A) {
A.clear();
}
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 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, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);
}
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, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);
}
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, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x),
FLC(A6, x);
}
template <class T>
inline void CLR(priority_queue<T> &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(stack<T> &S) {
while (!S.empty()) S.pop();
}
template <class T>
inline void CLR(queue<T> &Q) {
while (!Q.empty()) Q.pop();
}
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 < n; ++i) CLR(A[i]);
}
template <class T>
inline bool EPT(T &a) {
return a.empty();
}
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 cmp) {
sort(A.begin(), A.end(), cmp);
return A;
}
template <class T>
inline T &RVS(T &A) {
reverse(A.begin(), A.end());
return A;
}
template <class T>
inline T &UNQQ(T &A) {
A.resize(unique(A.begin(), A.end()) - A.begin());
return A;
}
template <class T>
inline T &UNQ(T &A) {
SRT(A);
return UNQQ(A);
}
template <class T, class C>
inline T &UNQ(T &A, C cmp) {
SRT(A, cmp);
return UNQQ(A);
}
const int MOD = int(1e9) + 7;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-9;
const double OO = 1e20;
const double PI = acos(-1.0);
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, 1, -1};
template <class T>
inline bool checkMin(T &a, const T b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline bool checkMax(T &a, const T b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class C>
inline bool checkUpd(T &a, const T b, C c) {
return c(b, a) ? a = b, 1 : 0;
}
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 min(T a, T b, T c, T d, T e) {
return min(min(min(a, b), min(c, d)), e);
}
template <class T>
inline T max(T a, T b, T c, T d, T e) {
return max(max(max(a, b), max(c, d)), e);
}
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline T cub(T a) {
return a * a * a;
}
template <class T>
inline T ceil(T x, T y) {
return (x - 1) / y + 1;
}
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
inline int sgn(double x) { return x < -EPS ? -1 : x > EPS; }
inline int sgn(double x, double y) { return sgn(x - y); }
inline double cos(double a, double b, double c) {
return (sqr(a) + sqr(b) - sqr(c)) / (2 * a * b);
}
inline double cot(double x) { return 1. / tan(x); };
inline double sec(double x) { return 1. / cos(x); };
inline double csc(double x) { return 1. / sin(x); };
namespace BO {
inline bool _1(int x, int i) { return bool(x & 1 << i); }
inline bool _1(long long x, int i) { return bool(x & 1LL << i); }
inline long long _1(int i) { return 1LL << i; }
inline long long _U(int i) { return _1(i) - 1; };
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;
}
template <class T>
inline bool odd(T x) {
return x & 1;
}
template <class T>
inline bool even(T x) {
return !odd(x);
}
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;
}
template <class T>
inline int cover_idx(T x) {
int p = 0;
while (_1(p) < x) ++p;
return p;
}
inline int clz(int x) { return __builtin_clz(x); }
inline int clz(long long x) { return __builtin_clzll(x); }
inline int ctz(int x) { return __builtin_ctz(x); }
inline int ctz(long long x) { return __builtin_ctzll(x); }
inline int lg2(int x) { return !x ? -1 : 31 - clz(x); }
inline int lg2(long long x) { return !x ? -1 : 63 - clz(x); }
inline int low_idx(int x) { return !x ? -1 : ctz(x); }
inline int low_idx(long long x) { return !x ? -1 : ctz(x); }
inline int high_idx(int x) { return lg2(x); }
inline int high_idx(long long x) { return lg2(x); }
inline int parity(int x) { return __builtin_parity(x); }
inline int parity(long long x) { return __builtin_parityll(x); }
inline int count_bits(int x) { return __builtin_popcount(x); }
inline int count_bits(long long x) { return __builtin_popcountll(x); }
} // namespace BO
using namespace BO;
namespace NT {
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
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 x, int y) {
int ret;
__asm__ __volatile__("\tmull %%ebx\n\tdivl %%ecx\n"
: "=d"(ret)
: "a"(x), "b"(y), "c"(MOD));
return ret;
}
inline int gcd(int m, int n, int &x, int &y) {
x = 1, y = 0;
int xx = 0, yy = 1, q;
while (1) {
q = m / n, m %= n;
if (!m) {
x = xx, y = yy;
return n;
}
DEC(x, pdt(q, xx)), DEC(y, pdt(q, yy));
q = n / m, n %= m;
if (!n) return m;
DEC(xx, pdt(q, x)), DEC(yy, pdt(q, y));
}
}
inline int sum(int a, int b, int c) { return sum(a, sum(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(a, pdt(b, c)); }
inline int pdt(int a, int b, int c, int d) { return pdt(pdt(a, b), pdt(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;
}
template <class T>
inline T pow(T a, int b) {
return pow(a, (long long)b);
}
inline int _I(int b) {
int a = MOD, x1 = 0, x2 = 1, q;
while (1) {
q = a / b, a %= b;
if (!a) return x2;
DEC(x1, pdt(q, x2));
q = b / a, b %= a;
if (!b) return x1;
DEC(x2, pdt(q, x1));
}
}
inline void DIV(int &a, int b) { MUL(a, _I(b)); }
inline int qtt(int a, int b) { return pdt(a, _I(b)); }
struct Int {
int val;
operator int() const { return val; }
Int(int _val = 0) : val(_val) {
val %= MOD;
if (val < 0) val += MOD;
}
Int(long long _val) : val(_val) {
_val %= MOD;
if (_val < 0) _val += MOD;
val = _val;
}
Int &operator+=(const int &rhs) {
INC(val, rhs);
return *this;
}
Int operator+(const int &rhs) const { return sum(val, rhs); }
Int &operator-=(const int &rhs) {
DEC(val, rhs);
return *this;
}
Int operator-(const int &rhs) const { return dff(val, rhs); }
Int &operator*=(const int &rhs) {
MUL(val, rhs);
return *this;
}
Int operator*(const int &rhs) const { return pdt(val, rhs); }
Int &operator/=(const int &rhs) {
DIV(val, rhs);
return *this;
}
Int operator/(const int &rhs) const { return qtt(val, rhs); }
Int operator-() const { return MOD - *this; }
};
} // namespace NT
using namespace NT;
template <class T>
inline T &RD(T &x) {
char c;
while (!isdigit((c = getchar())))
;
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
return x;
}
template <class T>
inline T &RDD(T &x) {
char c;
while ((c = getchar()), c != '-' && !isdigit(c))
;
if (c == '-') {
x = '0' - (c = getchar());
while (isdigit((c = getchar()))) x = x * 10 + '0' - c;
} else {
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
}
return x;
}
inline double &RF(double &x) {
char c;
while ((c = getchar()), c != '-' && c != '.' && !isdigit(c))
;
if (c == '-')
if ((c = getchar()) == '.') {
x = 0;
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + '0' - c;
x *= l;
} else {
x = '0' - c;
while (isdigit((c = getchar()))) x = x * 10 + '0' - c;
if (c == '.') {
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + '0' - c;
x *= l;
}
}
else if (c == '.') {
x = 0;
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + c - '0';
x *= l;
} else {
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
if (c == '.') {
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + c - '0';
x *= l;
}
}
return x;
}
inline char *RS(char *s) {
scanf("%s", s);
return s;
}
long long last_ans;
int Case;
template <class T>
inline void OT(const T &x) {
cout << x << endl;
}
const int N = int(1e3) + 9;
vector<int> adj[N];
int n, m;
int a[N], b[N];
int fa[N];
long long p[N], p0;
int Q[N], cz, op;
void add_path(int u) {
while (~fa[u]) {
Q[op++] = u;
p0 += b[u];
int v = fa[u];
fa[u] = -1;
u = v;
}
}
bool find_circle() {
for (int i = 0; i < n; ++i) fa[i] = -1, p[i] = 0;
for (int i = 0; i < op; ++i) p[Q[i]] = p0;
cz = 0;
int op = ::op;
while (cz < op) {
int u = Q[cz++];
for (auto v : adj[u])
if (v != fa[u] && p[u] > a[v]) {
if (~fa[v] || p[v] == p0 && p[u] != p0) {
add_path(u);
add_path(v);
return 1;
}
if (p[v] == p0) continue;
p[v] = p[u] + b[v];
fa[v] = u;
Q[op++] = v;
}
}
return 0;
}
bool ok(int _p0) {
op = 0;
Q[op++] = 0;
p0 = _p0;
while (find_circle())
;
return op == n;
}
int main() {
for (int ____T = RD(); ____T--;) {
RD(n, m);
for (int i = 1; i < n; ++i) RD(a[i]);
for (int i = 1; i < n; ++i) RD(b[i]);
for (int i = 0; i < n; ++i) adj[i].clear();
for (int ____n = m; ____n-- > 0;) {
int x, y;
RD(x, y);
--x;
--y;
adj[x].push_back(y);
adj[y].push_back(x);
}
int l = 2, r = int(1e9) + 1;
while (l < r) {
int m = (l + r) / 2;
if (ok(m))
r = m;
else
l = m + 1;
}
cout << l << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
long long n, a, b, w;
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a;
if (a & 1)
if (i & 1)
b++;
else
w++;
b += (a >> 1), w += (a >> 1);
}
cout << min(b, w);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(n);i++)
#define name (i++?" ":"")
int main(){
int n;
cin>>n;
vector <int> a(n);
REP(i,n) cin>>a[i];
int q;
cin>>q;
\
REP(i,q){
int b,e,t;
cin>>b>>e>>t;
swap_ranges(a.begin()+b,a.begin()+e,a.begin()+t);
}
int i=0;
for(int e:a) cout<<name<<e;
cout<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 0; i < 9; i++) {
cout << i << "??<>" << (i + 1) << "\n";
}
cout << "9??>>??0\n";
cout << "??<>1\n";
for (int i = 0; i <= 9; i++) {
cout << "?" << i << ">>" << i << "?\n";
}
cout << "?>>??\n";
cout << ">>?\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int l, r, x, y, k;
void solve(int test) {
cin >> l >> r >> x >> y >> k;
if ((ceil(l * 1.0 / k) >= x && ceil(l * 1.0 / k) <= y &&
ceil(l * 1.0 / k) * k <= r) ||
((r / k) >= x && (r / k) <= y && (r / k) * k >= l)) {
cout << "YES";
} else
cout << "NO";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int test = 1;
for (int(i) = 0; (i) < test; (i)++) {
solve(i + 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct node {
int v, next;
} edge[500005 << 2];
int adj[500005], adj2[500005], pos, fa[500005], fa2[500005];
int fi_fa[500005], cnt, out[500005][4];
void add(int adj[], int u, int v) {
++pos;
edge[pos].v = v, edge[pos].next = adj[u];
adj[u] = pos;
}
void dfs(int adj[], int u, int fa[]) {
for (int p = adj[u], v; p; p = edge[p].next)
if ((v = edge[p].v) != fa[u]) {
fa[v] = u;
dfs(adj, v, fa);
}
}
int root(int u) {
if (fi_fa[u] == u) return u;
return fi_fa[u] = root(fi_fa[u]);
}
bool check(int x, int y) {
if (!x || !y) return 0;
if (fa[x] == y || fa[y] == x) return 1;
return 0;
}
void solve(int u, int f) {
for (int p = adj[u], v, t; p; p = edge[p].next)
if ((v = edge[p].v) != f) {
solve(v, u);
if (fa2[u] != v && fa2[v] != u) {
t = root(v);
++cnt;
out[cnt][0] = u, out[cnt][1] = v, out[cnt][2] = t, out[cnt][3] = fa2[t];
}
}
}
int main() {
scanf("%d", &n);
int u, v;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
add(adj, u, v), add(adj, v, u);
}
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
add(adj2, u, v), add(adj2, v, u);
}
dfs(adj, 1, fa);
dfs(adj2, 1, fa2);
for (int i = 1; i <= n; ++i) fi_fa[i] = check(i, fa2[i]) ? fa2[i] : i;
solve(1, 0);
printf("%d\n", cnt);
for (int i = 1; i <= cnt; ++i)
printf("%d %d %d %d\n", out[i][0], out[i][1], out[i][2], out[i][3]);
return 0;
}
| 5 |
#include<iostream>
#include<algorithm>
using namespace std;
int a[100010];
int main()
{
int n,m; cin>>n>>m;
for(int i=1;i<=m;i++)
cin>>a[i];
sort(a+1 ,a+1+m);
for(int i=m;i>=2;i--)
a[i]=a[i]-a[i-1];
sort(a+2 , a+1+m);
int ans=0;
for(int i=2;i<=m-n+1;i++)
ans+=a[i];
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
long long x[105], y[105];
long long ans;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
for (long long i = 1; i <= n; ++i) {
cin >> x[i] >> y[i];
}
for (long long i = 1; i <= n; ++i) {
swap(x[i], y[i]);
for (long long j = 1; j <= n; ++j) {
if (i == j) continue;
swap(x[j], y[j]);
if (max(x[i], x[j]) <= a && y[i] + y[j] <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
if (x[i] + x[j] <= a && max(y[i], y[j]) <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
swap(x[j], y[j]);
if (max(x[i], x[j]) <= a && y[i] + y[j] <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
if (x[i] + x[j] <= a && max(y[i], y[j]) <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
}
swap(x[i], y[i]);
for (long long j = 1; j <= n; ++j) {
if (i == j) continue;
swap(x[j], y[j]);
if (max(x[i], x[j]) <= a && y[i] + y[j] <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
if (x[i] + x[j] <= a && max(y[i], y[j]) <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
swap(x[j], y[j]);
if (max(x[i], x[j]) <= a && y[i] + y[j] <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
if (x[i] + x[j] <= a && max(y[i], y[j]) <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
}
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include<iostream>
using namespace std;
int main(){
string S;
cin>>S;
int a=0;
for(int i=0;i<4;i++){
if(S[i]=='+')a++;
if(S[i]=='-')a--;
}
cout<<a<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<int> a(6);
for (int i = 0; i < 6; ++i) {
cin >> a[i];
}
sort(a.rbegin(), a.rend());
int n;
cin >> n;
vector<int> b(n);
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
set<pair<int, int>> s;
vector<int> frets;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 6; ++j) {
frets.push_back(b[i] - a[j]);
}
s.insert(make_pair(b[i] - a[0], i));
}
sort(frets.begin(), frets.end());
int ans = INT_MAX;
for (int minFret : frets) {
while (!s.empty()) {
auto it = s.begin();
int fret = it->first;
if (fret >= minFret) {
break;
}
int id = it->second;
bool found = false;
for (int i = 0; i < 6; ++i) {
if (b[id] - a[i] >= minFret) {
s.insert(make_pair(b[id] - a[i], id));
found = true;
break;
}
}
s.erase(it);
if (!found) {
break;
}
}
if ((int)s.size() == n) {
ans = min(ans, prev(s.end())->first - minFret);
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double Pi = 3.14159265359;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long N = 2e5 + 10;
const long long INF = 1e18;
long long n, m, L, x, d, t, p;
vector<long long> OX;
map<long long, vector<pair<long long, long long> > > g;
map<pair<long long, long long>, pair<long long, long long> > ma;
map<long long, long long> par;
map<long long, long long> dis;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> L;
OX.push_back(0), OX.push_back(L);
for (long long i = 0; i < n; i++) {
cin >> x >> d >> t >> p;
if (x - p >= 0 && p + t < d + p) {
g[x - p].push_back({x + d, p + t});
OX.push_back(x - p);
OX.push_back(x + d);
if (ma.count({x - p, x + d}) == 0) {
ma[{x - p, x + d}] = {p + t, i + 1};
} else if (ma[{x - p, x + d}].first > p + t) {
ma[{x - p, x + d}].first = p + t;
ma[{x - p, x + d}].second = i + 1;
}
}
}
sort(OX.begin(), OX.end());
for (int i = 0; i < OX.size() - 1; i++) {
g[OX[i]].push_back({OX[i + 1], OX[i + 1] - OX[i]});
g[OX[i + 1]].push_back({OX[i], OX[i + 1] - OX[i]});
}
for (int i = 0; i < OX.size(); i++) {
dis[OX[i]] = INF;
}
set<pair<long long, long long> > st;
dis[0] = 0;
st.insert({0, 0});
while (st.size()) {
long long fr = st.begin()->second;
st.erase({dis[fr], fr});
for (auto u : g[fr]) {
if (dis[u.first] > dis[fr] + u.second) {
st.erase({dis[u.first], u.first});
dis[u.first] = dis[fr] + u.second;
par[u.first] = fr;
st.insert({dis[u.first], u.first});
}
}
}
vector<long long> path;
long long node = L;
while (node != 0) {
if (ma[{par[node], node}].second != 0) {
path.push_back(ma[{par[node], node}].second);
}
node = par[node];
}
cout << dis[L] << '\n';
cout << path.size() << '\n';
for (int i = path.size() - 1; i >= 0; i--) {
cout << path[i] << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct bData {
int openLeft, value, openRight;
bData() : openLeft(0), value(0), openRight(0) {}
bData(int l, int v, int r) : openLeft(l), value(v), openRight(r) {}
};
int log(int x) {
int output = 0;
while (x > 1) {
output++;
x /= 2;
}
return output;
}
int max(int x, int y) { return x > y ? x : y; }
bData merge(bData bd1, bData bd2) {
int dValue = min(bd1.openLeft, bd2.openRight);
int value = bd1.value + bd2.value + 2 * dValue;
return bData((bd1.openLeft - dValue) + bd2.openLeft, value,
bd1.openRight + (bd2.openRight - dValue));
}
bData merge(bData bd1, bData bd2, bData bd3) {
return merge(merge(bd1, bd2), bd3);
}
bData mergeAll(bData** data, int n, int start, int end) {
if (end <= start) {
return bData(0, 0, 0);
} else if (end - start == 1) {
return data[0][start];
} else {
int logn = log(n);
int level = logn;
int p = 1 << logn;
while (p >= 1) {
if (end / p > start / p) {
if (start % p == 0) {
return merge(data[level][start / p],
mergeAll(data, n, start + p, end));
} else if (((start / p) + 1) * p + p <= end) {
return merge(mergeAll(data, n, start, (start / p + 1) * p),
data[level][start / p + 1],
mergeAll(data, n, ((start / p) + 1) * p + p, end));
} else {
p /= 2;
level--;
}
} else {
p /= 2;
level--;
}
}
return bData(0, 0, 0);
}
}
int main() {
string str;
cin >> str;
const char* cstr = str.c_str();
int n = str.length();
int m;
cin >> m;
int l, r;
int lg = log(n) + 1;
bData** data = new bData*[lg];
for (int i = 0, p = 1; i < lg; i++, p *= 2) {
data[i] = new bData[n / p + 1];
for (int j = 0, start = 0, end = p - 1; end < n;
start += p, end = min(start + p - 1, n), j++) {
if (i == 0) {
data[0][j] = cstr[start] == '(' ? bData(1, 0, 0) : bData(0, 0, 1);
} else {
data[i][j] = merge(data[i - 1][2 * j], data[i - 1][2 * j + 1]);
}
}
}
for (int t = 0; t < m; t++) {
cin >> l;
l--;
cin >> r;
r--;
cout << mergeAll(data, n, l, r + 1).value << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long T1, T2, A1, A2, B1, B2;
cin >> T1 >> T2 >> A1 >> A2 >> B1 >> B2;
if(T1 * A1 + T2 * A2 == T1 * B1 + T2 * B2) puts("infinity");
else {
if(T1 * A1 + T2 * A2 > T1 * B1 + T2 * B2) {
swap(A1, B1);
swap(A2, B2);
}
if(A1 < B1) puts("0");
else {
cout << (A1 - B1) * T1 / ((T1 * B1 + T2 * B2) - (T1 * A1 + T2 * A2)) * 2 + 1 - ((A1 - B1) * T1 % ((T1 * B1 + T2 * B2) - (T1 * A1 + T2 * A2)) == 0)<< endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline regex make_regex(const string& user) {
return regex("\\b" + user + "\\b");
}
void reduce_adjacent(int i, vector<pair<set<string>, string>>& messages) {
if (i > 0 && messages[i - 1].first.erase(*messages[i].first.begin()) == 1 &&
messages[i - 1].first.size() == 1) {
reduce_adjacent(i - 1, messages);
}
if (i < messages.size() - 1 &&
messages[i + 1].first.erase(*messages[i].first.begin()) == 1 &&
messages[i + 1].first.size() == 1) {
reduce_adjacent(i + 1, messages);
}
}
int main() {
ios_base::sync_with_stdio(false);
int t;
for (cin >> t; t--;) {
int n;
cin >> n;
vector<string> users(n);
for (int i = 0; i < n; ++i) {
cin >> users[i];
}
vector<regex> regexes(n);
transform(users.begin(), users.end(), regexes.begin(), make_regex);
int m;
cin >> m;
cin.ignore();
vector<pair<set<string>, string>> messages(m);
for (int i = 0; i < m; ++i) {
string line;
getline(cin, line);
auto sep = line.find(':');
string name = line.substr(0, sep);
messages[i] = {(name == "?" ? set<string>(users.begin(), users.end())
: set<string>({name})),
line.substr(sep + 1)};
if (name == "?") {
for (int j = 0; j < n; ++j) {
if (regex_search(messages[i].second, regexes[j])) {
messages[i].first.erase(users[j]);
}
}
}
}
for (int i = 0; i < m; ++i) {
if (messages[i].first.size() == 1) {
reduce_adjacent(i, messages);
}
}
if (any_of(messages.begin(), messages.end(),
[](const pair<set<string>, string>& p) {
return p.first.empty();
})) {
cout << "Impossible\n";
continue;
}
for (int i = 0; i < m; ++i) {
if (messages[i].first.size() > 1 && i < messages.size() - 1) {
messages[i + 1].first.erase(*messages[i].first.begin());
}
cout << *messages[i].first.begin() << ":" << messages[i].second << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
char data[200001];
int main() {
scanf("%d", &n);
scanf("%s", data);
int ans = 0;
int I = 0;
for (; I < n; I++) {
if (data[I] == '<')
ans++;
else
break;
}
I--;
for (int J = n - 1; J > I; J--) {
if (data[J] == '>')
ans++;
else
break;
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 1e6 + 10;
struct EDGE {
int x, y, v;
EDGE(int _x = 0, int _y = 0, int _v = 0) : x(_x), y(_y), v(_v) {}
bool operator<(const EDGE& b) const { return v < b.v; }
} a[SIZE];
int dp[SIZE];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (m); ++i) {
scanf("%d%d%d", &(a[i].x), &(a[i].y), &(a[i].v));
}
sort(a, a + m);
for (int i = 0; i < (m); ++i) {
int j;
vector<pair<int, int> > pp;
for (j = i; j < m && a[j].v == a[i].v; j++) {
pp.push_back(make_pair(dp[a[j].x] + 1, a[j].y));
}
for (int k = 0; k < (((int)(pp).size())); ++k) {
dp[pp[k].second] = max(dp[pp[k].second], pp[k].first);
}
i = j - 1;
}
int an = 0;
for (int i = 0; i < (n); ++i) an = max(an, dp[i + 1]);
printf("%d\n", an);
return 0;
}
| 5 |
#define NDEBUG
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <cassert>
#include <unistd.h>
#include <cstdio>
#include <cstdlib>
#include <stack>
#include <random>
using namespace std;
typedef long long ll;
struct LCNode {
typedef LCNode* NP;
typedef int D;
static const int INF = 1LL<<25;
static LCNode last_d;
static NP last;
NP p, l, r;
int sz;
int v, sm, lz;
int lsm, rsm, ma, mv;
bool rev, lzf;
LCNode(D v) :p(NULL), l(last), r(last), sz(1),
v(v), sm(v), rev(false),
lsm(max(v, 0)), rsm(max(v, 0)), ma(max(v, 0)), mv(v) {}
LCNode() : l(NULL), r(NULL), sz(0), v(-INF), mv(-INF) {}
inline int pos() {
if (p) {
if (p->l == this) return -1;
if (p->r == this) return 1;
}
return 0;
}
inline void rot() {
NP qq = p->p;
int pps = p->pos();
if (p->l == this) {
p->l = r; r->p = p;
r = p; p->p = this;
} else {
p->r = l; l->p = p;
l = p; p->p = this;
}
p->update(); update();
p = qq;
if (!pps) return;
if (pps == -1) {
qq->l = this;
} else {
qq->r = this;
}
qq->update();
}
void splay() {
assert(this != last);
int ps;
while ((ps = pos())) {
int pps = p->pos();
if (!pps) {
rot();
} else if (ps == pps) {
p->rot(); rot();
} else {
rot(); rot();
}
}
}
void expose() {
assert(this != last);
supush();
NP u = this;
do {
u->splay();
} while ((u = u->p));
u = last;
u->p = this;
do {
u->p->r = u;
u->p->update();
u = u->p;
} while (u->p);
splay();
}
void push() {
int lsz = l->sz, rsz = r->sz;
if (rev) {
if (lsz) {
l->revdata();
}
if (rsz) {
r->revdata();
}
rev = false;
}
if (lzf) {
if (lsz) {
l->lzdata(lz);
}
if (rsz) {
r->lzdata(lz);
}
lzf = false;
}
}
void supush() {
if (p) {
p->supush();
}
push();
}
inline void revdata() {
assert(this != last);
swap(l, r);
swap(lsm, rsm);
rev ^= true;
}
inline void lzdata(D d) {
assert(this != last);
v = mv = d;
sm = sz*d;
lsm = rsm = ma = max(0, sm);
lz = d;
lzf = true;
}
NP update() {
assert(this != last);
sz = 1+l->sz+r->sz;
sm = v+l->sm+r->sm;
lsm = max(l->lsm, l->sm+v+r->lsm);
rsm = max(r->rsm, r->sm+v+l->rsm);
ma = l->rsm+v+r->lsm;
ma = max(ma, l->ma);
ma = max(ma, r->ma);
mv = v;
mv = max(mv, l->mv);
mv = max(mv, r->mv);
return this;
}
void evert() {
expose();
revdata();
}
};
LCNode LCNode::last_d = LCNode();
LCNode::NP LCNode::last = &last_d;
int getint() {
char c;
int res = 0;
bool neg = false;
while (true) {
c = getchar_unlocked();
if (c == '-') {
neg = true;
break;
}
if ('0' <= c && c <= '9') {
res = c-'0';
break;
}
}
while (c = getchar_unlocked(), '0' <= c && c <= '9') {
res *= 10;
res += c-'0';
}
if (neg) res *= -1;
return res;
}
void putint(int d) {
static char buf[10];
int c = 0;
bool neg = false;
if (d < 0) {
putchar_unlocked('-');
d *= -1;
}
if (!d) {
putchar_unlocked('0');
return;
}
while (d) {
buf[c++] = d%10;
d = d/10;
}
while (c--) {
putchar_unlocked(buf[c]+'0');
}
}
const int MN = 201000;
LCNode tr[MN];
int main() {
int n = getint(), q = getint();
for (int i = 0; i < n; i++) {
int w = getint();
tr[i] = LCNode(w);
}
for (int i = 0; i < n-1; i++) {
int s = getint(), e = getint(); s--; e--;
tr[s].evert();
tr[e].expose();
tr[s].p = &tr[e];
}
for (int i = 0; i < q; i++) {
int t = getint(), a = getint(), b = getint(), c = getint();
a--; b--;
if (t == 1) {
tr[a].evert();
tr[b].expose();
tr[b].lzdata(c);
} else {
tr[a].evert();
tr[b].expose();
int d;
if (tr[b].mv < 0) d = tr[b].mv;
else d = tr[b].ma;
putint(d);
putchar_unlocked('\n');
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
int64_t n;
cin >> n;
struct point {
int64_t x, y;
};
vector<point> a(n + 1);
for (int64_t i = 1; i < n + 1; i++) {
cin >> a[i].x >> a[i].y;
}
vector<int64_t> c(n + 1), k(n + 1);
for (int64_t i = 1; i < n + 1; i++) {
cin >> c[i];
}
for (int64_t i = 1; i < n + 1; i++) {
cin >> k[i];
}
vector<vector<int64_t>> d(n + 1, vector<int64_t>(n + 1, INT64_MAX));
for (int64_t i = 1; i < n + 1; i++) {
d[0][i] = c[i];
d[i][0] = c[i];
}
for (int64_t i = 1; i < n + 1; i++) {
for (int64_t j = 1; j < n + 1; j++) {
d[i][j] = d[j][i] =
(k[i] + k[j]) * (abs(a[i].x - a[j].x) + abs(a[i].y - a[j].y));
}
}
int64_t ans = 0;
vector<int64_t> used(n + 1, 0);
vector<int64_t> min_c(n + 1, INT64_MAX), p(n + 1, -1);
vector<pair<int64_t, int64_t>> mst;
min_c[0] = 0;
for (int64_t i = 0; i < n + 1; i++) {
int64_t v = -1;
for (int64_t j = 0; j < n + 1; j++) {
if (!used[j] && (v == -1 || min_c[j] < min_c[v])) {
v = j;
}
}
used[v] = true;
ans += min_c[v];
mst.emplace_back(v, p[v]);
for (int64_t j = 0; j < n + 1; j++) {
if (d[v][j] < min_c[j]) {
min_c[j] = d[v][j];
p[j] = v;
}
}
}
cout << ans << "\n";
vector<int64_t> ans1;
vector<pair<int64_t, int64_t>> ans2;
for (auto it : mst) {
if (it.second == -1) {
continue;
}
if (it.second == 0) {
ans1.push_back(it.first);
} else {
ans2.emplace_back(it.first, it.second);
}
}
cout << ans1.size() << "\n";
for (auto it : ans1) {
cout << it << " ";
}
cout << "\n";
cout << ans2.size() << "\n";
for (auto it : ans2) {
cout << it.first << " " << it.second << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 17;
typedef long long int ll;
const ll inf = 1e18;
ll w[1 << N];
ll dp[1 << N];
ll a[N][N];
int main()
{
int n;
cin >> n;
for(int i=0;i<n;++i)
for(int j=0;j<n;++j)
cin >> a[i][j];
int nn = 1 << n;
for(int s=0;s<nn;++s)
{
for(int i=0;i<n;++i) if(s>>i&1)
for(int j=i+1;j<n;++j) if(s>>j&1)
w[s] += a[i][j];
//~ cerr << s << ' ' << w[s] << endl;
}
for(int s=0;s<nn;++s)
{
dp[s] = 0;
for(int m=s;m;m = s & (m-1))
dp[s] = max(dp[s], w[m] + dp[m^s]);
}
cout << dp[nn-1] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define MAXN (100010)
int n, m, tot;
std::vector<int> vec[MAXN];
std::deque<int> ans;
bool vis[MAXN];
void go(int u, bool mark){
for(auto v : vec[u]){
if(vis[v]) continue;
vis[v] = true;
if(mark) ans.push_back(v);
else ans.push_front(v);
go(v, mark);
tot ++;
break;
}
}
int main(){
scanf("%d%d", &n, &m);
for(int i = 1; i <= m; ++ i){
int u, v;
scanf("%d%d", &u, &v);
vec[u].push_back(v);
vec[v].push_back(u);
}
for(int i = 1; i <= n; ++ i){
if(!vis[i]){
vis[i] = true;
tot = 1;
ans.clear();
ans.push_back(i);
go(i, true);
go(i, false);
if(tot >= 2){
printf("%d\n", (int)ans.size());
for(auto v : ans){
printf("%d ", v);
}
printf("\n");
break;
}
}
}
return 0;
} | 0 |
#include<iostream>
#include<bitset>
using namespace std;
int main(void){
int n,c,benefit,ma=-1000000000;
cin>>n;
bool f[n][10];
int p[n][11];
for(int i=0;i<n;i++)for(int j=0;j<10;j++)cin>>f[i][j];
for(int i=0;i<n;i++)for(int j=0;j<=10;j++)cin>>p[i][j];
bitset<10>bit;
for(int b=1;b<1<<10;b++){
bit=b;
benefit=0;
for(int i=0;i<n;i++){
c=0;
for(int j=0;j<10;j++)c+=(bit[j]&&f[i][j]);
benefit+=p[i][c];
}
ma=max(ma,benefit);
}
cout<<ma<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[12500], u[2500], t[2500];
int n, m;
int main() {
for (int i = 0; i < (10000); ++i) s[i] = 'Z';
gets(u);
n = strlen(u);
for (int i = 0; i < (n); ++i) s[i + 2500] = u[i];
gets(t);
m = strlen(t);
int res = m;
for (int i = 0; i + m < 10000; ++i) {
int cur = 0;
for (int j = 0; j < (m); ++j) cur += s[i + j] != t[j];
res = min(res, cur);
}
printf("%d\n", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 200005;
int n, m;
int f[N];
int head[N], nxt[N * 2], to[N * 2], w[N * 2], cnt;
int dfn[N], DFN, dep[N], top[N], fa[N], size[N], son[N];
bool vis[N];
int ed[N], tree[N];
int Max[N << 2], lazy[N << 2];
int ans[N];
int Ans[N];
struct edge {
int a, b, c, id;
friend bool operator<(edge a, edge b) { return a.c < b.c; }
} e[N];
inline void insert(int a, int b, int c) {
to[++cnt] = b;
nxt[cnt] = head[a];
head[a] = cnt;
w[cnt] = c;
to[++cnt] = a;
nxt[cnt] = head[b];
head[b] = cnt;
w[cnt] = c;
}
int getf(int x) {
if (x == f[x]) return x;
return f[x] = getf(f[x]);
}
void dfs1(int x, int f) {
fa[x] = f;
size[x] = 1;
for (int i = head[x]; i; i = nxt[i])
if (to[i] != f) {
ed[to[i]] = w[i];
dfs1(to[i], x);
size[x] += size[to[i]];
if (size[to[i]] > size[son[x]]) son[x] = to[i];
}
}
void dfs2(int x, int f) {
top[x] = f;
dfn[x] = ++DFN;
tree[DFN] = x;
dep[x] = dep[fa[x]] + 1;
if (son[x]) dfs2(son[x], f);
for (int i = head[x]; i; i = nxt[i])
if (to[i] != fa[x] && to[i] != son[x]) dfs2(to[i], to[i]);
}
void build(int num, int l, int r) {
lazy[num] = 2e9;
if (l == r) {
Max[num] = e[ed[tree[l]]].c;
return;
}
int mid = (l + r) >> 1;
build(num << 1, l, mid);
build(num << 1 | 1, mid + 1, r);
Max[num] = max(Max[num << 1], Max[num << 1 | 1]);
}
int getMx(int num, int l, int r, int x, int y, int k) {
if (x <= l && r <= y) {
lazy[num] = min(lazy[num], k);
return Max[num];
}
int mid = (l + r) >> 1, Mx = 0;
if (x <= mid) Mx = getMx(num << 1, l, mid, x, y, k);
if (y > mid) Mx = max(Mx, getMx(num << 1 | 1, mid + 1, r, x, y, k));
return Mx;
}
int solve(int a, int b, int c) {
int x = a, y = b, Mx = 0;
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
Mx = max(Mx, getMx(1, 2, n, dfn[top[x]], dfn[x], c));
x = fa[top[x]];
}
if (dep[x] < dep[y]) swap(x, y);
if (x != y) Mx = max(Mx, getMx(1, 2, n, dfn[y] + 1, dfn[x], c));
return Mx;
}
inline void down(int k) {
int l = k << 1, r = k << 1 | 1;
lazy[l] = min(lazy[l], lazy[k]);
lazy[r] = min(lazy[r], lazy[k]);
}
void Getans(int num, int l, int r) {
if (l == r) {
ans[ed[tree[l]]] = lazy[num];
return;
}
int mid = (l + r) >> 1;
down(num);
Getans(num << 1, l, mid);
Getans(num << 1 | 1, mid + 1, r);
}
signed main() {
n = read();
m = read();
for (int i = 1; i <= m; ++i) {
e[i].a = read();
e[i].b = read();
e[i].c = read();
e[i].id = i;
}
for (int i = 1; i <= n; ++i) f[i] = i;
sort(e + 1, e + m + 1);
int num = 1;
for (int i = 1; i <= m; ++i) {
int fa = getf(e[i].a), fb = getf(e[i].b);
if (fa == fb) continue;
f[fa] = fb;
vis[i] = true;
++num;
insert(e[i].a, e[i].b, i);
if (num == n) break;
}
dfs1(1, 1);
dfs2(1, 1);
build(1, 2, n);
for (int i = 1; i <= m; ++i) {
if (vis[i]) continue;
ans[i] = solve(e[i].a, e[i].b, e[i].c);
}
Getans(1, 2, n);
for (int i = 1; i <= m; ++i) Ans[e[i].id] = ans[i];
for (int i = 1; i <= m; ++i) {
if (Ans[i] == 2e9)
printf("-1 ");
else
printf("%d ", Ans[i] - 1);
}
puts("");
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#define int long long
using namespace std;
const int mod = 1000000007;
signed main() {
int n, m; cin >> n >> m;
int ans = 1;
for (int i = 2; i <= sqrt(m); i++) {
if (m%i == 0) {
int cnt = 0;
while (m%i == 0) {
m /= i; cnt++;
}
int p = 1;
//m+n-1Cm
for (int i = 1; i <= cnt; i++) {
p *= cnt + n - i;
p %= mod;
}
for (int i = 2; i <= cnt; i++) {
while (p%i != 0)p += mod;
p /= i;
p %= mod;
}
ans *= p;
ans %= mod;
}
}
if (m != 1) {
ans *= n;
ans %= mod;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9;
int n, m, le, ri;
string s;
int val(string s) {
int res = 0, i;
for (i = s.length() - 1; s[i] != ' '; i--)
;
i++;
for (int j = i; j < s.length(); j++) res = res * 10 + (s[j] - '0');
return res;
}
int main() {
scanf("%d%d\n", &n, &m);
le = n + 1;
for (int i = 0; i < m; i++) {
getline(cin, s);
int len = s.length();
if (s[7] == 'r')
ri = max(ri, val(s));
else
le = min(le, val(s));
}
int res = le - ri - 1;
if (res <= 0)
puts("-1");
else
printf("%d\n", res);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[100010], q[100010];
long long min(long long x, long long y) { return x < y ? x : y; }
long long max(long long x, long long y) { return x > y ? x : y; }
int main() {
int n, d, b, i;
long long ans1 = 0, ans2 = 0;
scanf("%d%d%d", &n, &d, &b);
q[0] = 0;
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
q[i] = q[i - 1] + a[i];
}
for (i = 1; i <= n / 2; i++) {
if ((long long)q[min((long long)i * (d + 1), n)] - q[0] >=
(long long)(ans1 + 1) * b)
ans1++;
if ((long long)q[n] - q[max(1, (long long)n - i * (d + 1))] >=
(long long)(ans2 + 1) * b)
ans2++;
}
printf("%d\n", n / 2 - min(ans1, ans2));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void pass() { return; }
const double EPS = 1e-6;
mt19937 rnd(rand() << 15 + rand());
const long long MOD = 1e9 + 7;
const long long BIG_MOD = 1e18 + 7;
const long long MAXN = 1e6 + 7;
long long a[MAXN];
long long last[MAXN];
long long myright[MAXN];
signed main() {
cout.tie(NULL);
cout.precision(20);
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
if (n == 1) {
cout << "1\n";
return 0;
}
for (long long i = 0; i < MAXN; ++i) {
last[i] = n;
}
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
for (long long i = n - 1; i >= 0; --i) {
myright[i] = last[a[i]] - i - 1;
last[a[i]] = i;
}
long long ans = 0;
for (long long i = 0; i < n; ++i) {
ans += (i + 1) * (myright[i] + 1) - 1;
}
double sr = (double)ans / (n * (n - 1) / 2);
cout << (double)(sr * n * (n - 1) + n) / (n * n);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int T;
cin >> T;
int ans = 0;
for (int i = 0; i < n; i++) {
int d = 0;
while (i + d < n) {
if (a[i + d] - a[i] > T) break;
d++;
}
ans = max(ans, d);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class node {
public:
int val;
int idx;
};
int n, m, k;
int A[1000100];
node B[1000100];
int myfunc(node f1, node f2) { return f1.val < f2.val; }
int getPre(int idx) {
for (int i = idx; i >= 1; i--) {
if (A[i] != A[idx]) return i + 1;
}
return 1;
}
int C[20000010];
vector<int> vec;
int cal() {
int day = A[n];
int last = 0;
for (int i = n; i >= 1; i--) {
if (A[i] == day) {
int idx = getPre(i);
last = last + (i - idx + 1);
if (last >= k) {
C[day] = k;
last -= k;
} else {
C[day] = last;
last = 0;
}
i = idx;
} else {
if (last >= k) {
C[day] = k;
last -= k;
} else {
C[day] = last;
last = 0;
}
i++;
}
day--;
}
if (last > 0) return -1;
int ans = 0;
int j = 1;
for (int i = 0; i <= 20000000; i++) {
if (C[i] == k) continue;
while (j <= m && B[j].val < i) {
j++;
}
while (j <= m && C[i] < k) {
vec.push_back(B[j].idx);
C[i]++;
j++;
}
}
return 1;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &B[i].val);
B[i].idx = i;
}
sort(A + 1, A + n + 1);
sort(B + 1, B + m + 1, myfunc);
int uuu = cal();
if (uuu == -1)
printf("%d\n", uuu);
else {
printf("%d\n", vec.size());
for (int i = 0; i < vec.size(); i++) printf("%d ", vec[i]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
char s[10000], ans[10000];
int i = 0, j = 0, l;
gets(s);
l = strlen(s);
for (i = 0; i < l; i++) {
if (s[i] == ' ' && (s[i + 1] == ' ' || s[i + 1] == '.' || s[i + 1] == ',' ||
s[i + 1] == '?' || s[i + 1] == '!'))
continue;
if (s[i] != ' ' && (s[i - 1] == '.' || s[i - 1] == ',' || s[i - 1] == '?' ||
s[i - 1] == '!')) {
ans[j] = ' ';
j++;
}
ans[j] = s[i];
j++;
}
ans[j] = '\0';
printf("%s\n", ans);
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
using namespace std;
int main(){
while(1){
int n;
cin>>n;
if(n==0) return 0;
int yk=0,h=0,m=0,ans=0;
for(int i=0;i<n;i++){
string s;
cin>>s;
if(s=="lu") h++;
else if(s=="ld") h--;
else if(s=="ru") m++;
else m--;
int nans;
if(h==m){
if(h==0&&m==0) nans=0;
else nans=1;
if(yk!=nans){
ans++;
yk=nans;
}
}
}
cout<<ans<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 1;
const long long MOD = 1e9 + 7;
const int base = 257;
const int M = 1e6 + 1;
const int INFI = 1e8;
long long Hash[M], po[M];
long long gethash(long long l, long long r) {
return ((Hash[r] - Hash[l - 1] * po[r - l + 1] + MOD * MOD) % MOD);
}
void precomputehashing() {
po[0] = 1;
for (int i = 1; i <= M; i++) po[i] = (po[i - 1] * base) % MOD;
string s;
s = " " + s;
for (int i = 1; i <= s.size() - 1; i++)
Hash[i] = (Hash[i - 1] * base + s[i] - '*' + 1) % MOD;
}
long long fac[N], ifac[N];
long long PowerMod(long long a, long long n) {
long long ret = 1;
while (n) {
if (n & 1) {
ret *= a;
ret %= MOD;
}
a *= a;
a %= MOD;
n /= 2;
}
return ret;
}
void precomputecombinatoris() {
int i;
fac[0] = 1;
for (i = 1; i < N; i++) {
fac[i] = (i * fac[i - 1]) % MOD;
}
ifac[N - 1] = PowerMod(fac[N - 1], MOD - 2);
for (i = N - 2; i >= 0; i--) {
ifac[i] = ((i + 1) * ifac[i + 1]) % MOD;
}
}
long long C(int r, int n) {
long long ret = fac[n];
ret *= ifac[r];
ret %= MOD;
ret *= ifac[n - r];
ret %= MOD;
return ret;
}
long long n, dp[N];
int m;
struct Matrix {
long long x[N][N];
Matrix() {
for (int i = 0; i <= N - 2; i++) {
for (int j = 0; j <= N - 2; j++) {
x[i][j] = 0;
}
}
}
friend Matrix operator*(const Matrix &a, const Matrix &b) {
Matrix res;
for (int i = 0; i <= N - 2; i++) {
for (int j = 0; j <= N - 2; j++) {
for (int k = 0; k <= N - 2; k++) {
res.x[i][j] += a.x[i][k] * b.x[k][j];
if (res.x[i][j] >= MOD) res.x[i][j] %= MOD;
}
}
}
return res;
}
};
Matrix POW(Matrix A, long long n) {
if (n == 1) return A;
Matrix B = POW(A, n / 2);
B = B * B;
if (n & 1) return B * A;
return B;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
if (n < m) {
cout << 1;
return 0;
}
if (n == m) {
cout << 2;
return 0;
}
dp[0] = 2;
for (int i = 1; i <= m - 1; i++) {
dp[i] = dp[i - 1] + 1;
}
if (n < m * 2) {
cout << dp[n - m];
return 0;
}
Matrix cur;
for (int i = 0; i <= m - 1; i++) {
for (int j = 0; j <= m - 1; j++) {
cur.x[i][j] = dp[m - 1 - i];
}
}
Matrix a;
a.x[0][0] = 1;
a.x[0][m - 1] = 1;
for (int i = 1; i <= m - 1; i++) {
a.x[i][i - 1] = 1;
}
m *= 2;
m--;
n -= m;
Matrix res = POW(a, n);
res = res * cur;
cout << res.x[0][0] % MOD;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s,t;
cin>>s>>t;
int ct = 0;
for(int i=0;i<s.size();i++)
ct += (s[i] == t[i]);
cout<<ct;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
int sz[100005];
int a[100005], ds[100005][20], dp[100005][20];
vector<int> mp[100005];
long long ans;
void dfs(int x, int pa) {
for (int c : mp[x])
if (c != pa) {
dfs(c, x);
sz[x] += sz[c];
for (int(j) = 0; (j) < (int)(20); (j)++) ds[x][j] += dp[c][j];
}
for (int(j) = 0; (j) < (int)(20); (j)++) {
int val = (1 << j);
int me = (a[x] >> j) & 1;
for (int c : mp[x])
if (c != pa) {
int s1 = dp[c][j], s0 = sz[c] - s1;
if (me == 1) {
ans += (long long)s0 * val;
} else {
ans += (long long)s1 * val;
}
}
if (me == 1)
dp[x][j] = sz[x] - ds[x][j] + 1;
else
dp[x][j] = ds[x][j];
}
sz[x]++;
}
void dfs2(int j, int x, int pa, int o0, int o1) {
int val = (1 << j);
int me = (a[x] >> j) & 1;
if (me == 1) {
ans += (long long)o0 * val;
} else {
ans += (long long)o1 * val;
}
for (int c : mp[x])
if (c != pa) {
int cur0, cur1;
if (me == 1) {
cur0 = sz[x] - dp[x][j] - (dp[c][j]) + o1;
cur1 = sz[x] - 1 - ds[x][j] - (sz[c] - dp[c][j]) + o0 + 1;
} else {
cur1 = ds[x][j] - dp[c][j] + o1;
cur0 = sz[x] - 1 - ds[x][j] - (sz[c] - dp[c][j]) + o0 + 1;
}
dfs2(j, c, x, cur0, cur1);
}
}
void fmain(int tid) {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
for (int i = 0, u, v; i < n - 1; i++) {
scanf("%d%d", &u, &v);
mp[u].push_back(v);
mp[v].push_back(u);
};
dfs(1, 0);
for (int(j) = 0; (j) < (int)(20); (j)++) dfs2(j, 1, 0, 0, 0);
assert(ans % 2 == 0);
ans /= 2;
for (int(i) = 1; (i) <= (int)(n); (i)++) ans += a[i];
printf("%lld\n", ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize ("O3")
using namespace std;
#define optimize ios::sync_with_stdio(0);cin.tie(0);cout.tie(0)
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef vector<char> vc;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
bool isPalindrome(string s){
int n = s.length();
for(int i=0; i<n/2; i++){
if(s[i] != s[n-1-i]) return false;
}
return true;
}
void solve()
{
string s;
cin >> s;
int n = s.length();
if(isPalindrome(s)){
string s2 = "";
for(int i=0; i<n; i++){
s2 += 'a';
}
if(s == s2){
cout << "NO" << endl;
}
else {
cout << "YES" << endl;
int i = 0;
for(i=0; i<n; i++){
if(s[i] != 'a'){
break;
}
}
for(int j=0; j<i; j++){
cout << s[j];
}
cout << 'a';
for(int j = i; j<n; j++) cout << s[j];
cout << endl;
}
} else {
cout << "YES" << '\n';
for(int i=0; i<n/2; i++){
cout << s[i];
}
cout << 'a';
for(int i=n/2; i<n; i++){
cout << s[i];
}
cout << '\n';
}
}
int main()
{
optimize; // Don't use printf & scanf
int T=1;
cin >> T;
while(T--)
solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-12;
const double PI = acos(-1.0);
const int mod = 998244353;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int ar[100050];
void solve() {
int n, k;
cin >> n >> k;
bool exi = false, gp = false;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
if (ar[i] == k) exi = true;
}
for (int i = 1; i < n; i++) {
if (ar[i] >= k && (ar[i + 1] >= k || i < n - 1 && ar[i + 2] >= k)) {
gp = true;
break;
}
}
if (n == 1 && ar[1] == k || exi && gp)
cout << "yes\n";
else
cout << "no\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int H,W,C1,C2,D1,D2;
cin>>H>>W>>C1>>C2>>D1>>D2;
C1--,C2--,D1--,D2--;
vector<char> p(H*W);
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
cin>>p[i*W+j];
}
}
vector<int> seen(H*W,-1);
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;
pq.push(make_pair(0,C1*W+C2));
seen[C1*W+C2]=0;
while(!pq.empty()){
int a,b;
tie(a,b)=pq.top();
pq.pop();
if(seen[b]<a){
continue;
}
int x=b/W,y=b%W;
for(int i=-2;i<=2;i++){
for(int j=-2;j<=2;j++){
int c=x+i,d=y+j;
if(c<0||H<=c||d<0||W<=d){
continue;
}
else{
int E=c*W+d;
if(i==0&&j==0){
continue;
}
else if(abs(i)+abs(j)==1){
if((seen[E]==-1||seen[E]>a)&&p[E]=='.'){
seen[E]=a;
pq.push(make_pair(a,E));
}
}
else{
if((seen[E]==-1||seen[E]>a+1)&&p[E]=='.'){
seen[E]=a+1;
pq.push(make_pair(a+1,E));
}
}
}
}
}
}
cout<<seen[D1*W+D2]<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char ar[1000000 + 7];
int i, l, k, f = 0, n, m, c = 0;
scanf("%s", ar);
l = strlen(ar);
for (i = 0; i < strlen(ar); i++) {
if (ar[i] == 'a') {
k = i;
f = 1;
break;
}
}
for (i = 0; i < l; i++) {
if (ar[i] == 'a') c++;
}
if (c == l) {
ar[l - 1] = 'z';
} else if (k != 0 && f == 1) {
for (i = 0; i < k; i++) ar[i] = ar[i] - 1;
} else if (f == 0) {
for (i = 0; i < l; i++) ar[i] = ar[i] - 1;
} else if (f == 1 && k == 0) {
for (i = 0; i < l - 1; i++) {
if (ar[i] == 'a' && ar[i + 1] != 'a') {
m = i;
break;
}
}
for (i = m + 1; i < l; i++) {
if (ar[i] == 'a') {
n = i;
f = 2;
break;
}
}
if (f == 2) {
for (i = m + 1; i < n; i++) ar[i] = ar[i] - 1;
} else if (f == 1) {
for (i = m + 1; i < l; i++) ar[i] = ar[i] - 1;
}
}
for (i = 0; i < l; i++) printf("%c", ar[i]);
return 0;
}
| 1 |
#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 ans;
long long int f = 0;
for (long long int i = 3; i <= 360; i++) {
if ((n * i) % 180 == 0 && (n * i) / 180 <= i - 2) {
f = 1;
ans = i;
break;
}
}
if (f == 1)
cout << ans << endl;
else
cout << -1 << endl;
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
//BEGIN CUT HERE
struct RUP{
int n;
vector<int> dat,laz;
const int def=INT_MAX;
RUP(){}
RUP(int n_){init(n_);}
void init(int n_){
n=1;
while(n<n_) n*=2;
dat.clear();
dat.resize(2*n-1,def);
laz.clear();
laz.resize(2*n-1,-1);
}
inline void eval(int len,int k){
if(laz[k]<0) return;
if(k*2+1<n*2-1){
laz[k*2+1]=laz[k];
laz[k*2+2]=laz[k];
}
dat[k]=laz[k];
laz[k]=-1;
}
int update(int a,int b,int x,int k,int l,int r){
eval(r-l,k);
if(r<=a||b<=l) return dat[k];
if(a<=l&&r<=b) return laz[k]=x;
eval(r-l,k);
dat[k]=min(update(a,b,x,k*2+1,l,(l+r)/2),
update(a,b,x,k*2+2,(l+r)/2,r));
return dat[k];
}
int query(int a,int b,int k,int l,int r){
eval(r-l,k);
if(r<=a||b<=l) return def;
if(a<=l&&r<=b) return dat[k];
int vl=query(a,b,k*2+1,l,(l+r)/2);
int vr=query(a,b,k*2+2,(l+r)/2,r);
return min(vl,vr);
}
void update(int a,int b,int x){
update(a,b,x,0,0,n);
}
int query(int a,int b){
return query(a,b,0,0,n);
}
};
//END CUT HERE
signed main(){
int n,q;
cin>>n>>q;
RUP rup(n);
for(int i=0;i<q;i++){
int f;
cin>>f;
if(!f){
int s,t,x;
cin>>s>>t>>x;
rup.update(s,t+1,x);
}else{
int s,t;
cin>>s>>t;
cout<<rup.query(s,t+1)<<endl;
}
}
return 0;
}
/*
verified on 2017/07/12
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_D
*/ | 0 |
#include <bits/stdc++.h>
using pii = std::pair<int, int>;
using pll = std::pair<long long, long long>;
const int maxn = 1e5 + 100;
std::vector<int> v[maxn];
int component[maxn];
int current_component = 0;
int farthest[maxn];
int component_diameter[maxn];
std::vector<int> in_component[maxn];
std::vector<int> prefix_sum[maxn];
int depth[maxn];
void calc_depth(int x, int p = -1) {
depth[x] = 1;
component[x] = current_component;
in_component[current_component].push_back(x);
for (auto y : v[x]) {
if (y == p) continue;
calc_depth(y, x);
depth[x] = std::max(depth[x], depth[y] + 1);
}
}
void dfs(int x, int p = -1, int par_ans = -1) {
pii best = {-1, -1};
for (auto y : v[x]) {
if (y == p) continue;
best = std::max({best, {best.first, depth[y]}, {depth[y], best.first}});
}
farthest[x] = std::max({par_ans, best.first, 0});
component_diameter[current_component] =
std::max(component_diameter[current_component], farthest[x]);
for (auto y : v[x]) {
if (y == p) continue;
int mpar = std::max(par_ans + 1, 1);
if (best.first != depth[y])
mpar = std::max(mpar, best.first + 1);
else
mpar = std::max(mpar, best.second + 1);
dfs(y, x, mpar);
}
}
int main() {
std::ios::sync_with_stdio(false);
int n, m, q;
std::cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
int x, y;
std::cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (component[i] == 0) {
++current_component;
calc_depth(i);
dfs(i);
int j = component[i];
std::sort(in_component[j].begin(), in_component[j].end(),
[](int a, int b) { return farthest[a] < farthest[b]; });
prefix_sum[j].resize(in_component[j].size() + 1);
prefix_sum[j][0] = 0;
for (int i = 0; i < (int)in_component[j].size(); i++) {
prefix_sum[j][i + 1] = prefix_sum[j][i] + farthest[in_component[j][i]];
}
}
}
std::map<pii, double> memo;
while (q-- > 0) {
int u, v;
std::cin >> u >> v;
u = component[u];
v = component[v];
if (u == v) {
std::cout << -1 << "\n";
continue;
}
if (in_component[u].size() > in_component[v].size()) std::swap(u, v);
if (memo.count({u, v})) {
std::cout << memo[{u, v}] << "\n";
continue;
}
long long count = 0;
long long total = in_component[u].size() * 1ll * in_component[v].size();
int maxdiameter = std::max(component_diameter[u], component_diameter[v]);
for (auto x : in_component[u]) {
int l = -1, r = in_component[v].size() - 1;
while (r - l > 1) {
int mid = (l + r) / 2;
if (farthest[in_component[v][mid]] + farthest[x] + 1 < maxdiameter)
l = mid;
else
r = mid;
}
count += maxdiameter * 1ll * r;
count += (farthest[x] + 1) * (in_component[v].size() - r) +
prefix_sum[v].back() - prefix_sum[v][r];
}
std::cout << std::fixed << std::setprecision(10) << "\n";
double ans = count * 1. / total;
std::cout << ans << "\n";
memo[{u, v}] = ans;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int INF = 1 << 30;
int dy[] = {-1, 0, 0, 1};
int dx[] = {0, -1, 1, 0};
int n, m;
string c[110];
void solve() {
c[0] = c[m + 1] = string(n + 2, '.');
for (int i = 1; i <= m; i++) {
cin >> c[i];
c[i] = "." + c[i] + ".";
}
n += 2, m += 2;
int dis[110][110];
fill_n((int*)dis, 110 * 110, INF);
dis[0][0] = 0;
deque<pii> deq = {{0, 0}};
while (!deq.empty()) {
int y, x;
tie(y, x) = deq.front(); deq.pop_front();
if (c[y][x] == '&') {
cout << dis[y][x] << endl;
return;
}
for (int i = 0; i < 4; i++) {
int ny = y + dy[i], nx = x + dx[i];
if (ny >= 0 && ny < m && nx >= 0 && nx < n) {
int cost = (c[y][x] == '.' && c[ny][nx] == '#');
if (dis[ny][nx] > dis[y][x] + cost) {
dis[ny][nx] = dis[y][x] + cost;
if (cost) deq.emplace_back(ny, nx);
else deq.emplace_front(ny, nx);
}
}
}
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
while (cin >> n >> m, n) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const char nl = '\n';
using namespace std;
using ll = long long;
using vi = vector<ll>;
using vl = vector<ll>;
using pii = pair<ll, ll>;
using pll = pair<ll, ll>;
using str = string;
str to_string(char c) { return str(1, c); }
str to_string(bool b) { return b ? "true" : "false"; }
str to_string(const char* second) { return (str)second; }
str to_string(str second) { return second; }
template <class A>
str to_string(complex<A> c) {
stringstream ss;
ss << c;
return ss.str();
}
str to_string(vector<bool> v) {
str res = "{";
for (ll i = 0; i < (ll)v.size(); i++) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
str to_string(bitset<SZ> b) {
str res = "";
for (ll i = 0; i < b.size(); i++) res += char('0' + b[i]);
return res;
}
template <class A, class B>
str to_string(pair<A, B> p);
template <class T>
str to_string(T v) {
bool fst = 1;
str res = "{";
for (const auto& x : v) {
if (!fst) res += ", ";
fst = 0;
res += to_string(x);
}
res += "}";
return res;
}
template <class A, class B>
str to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
ll n;
string c;
vector<vi> pref;
set<ll> vis;
bool notone = 0;
ll bruh(ll idx, char tr, ll len) {
vis.insert(idx);
ll amt =
pref[idx + len - 1][tr - 'a'] - ((idx > 0) ? pref[idx - 1][tr - 'a'] : 0);
0;
ll add = len - amt;
if (len == n / 2) {
return add;
} else {
if (len == 1 && notone) {
if ((idx + 1) / 2 == idx / 2) {
;
notone = 0;
add += bruh(idx + 1, tr - 1, len);
} else {
notone = 0;
add += bruh(idx - 1, tr - 1, len);
}
} else {
bool minus = 1;
if ((idx + len * 2) / (len * 2) * (len * 2) / (len * 4) ==
idx / (len * 4)) {
minus = 0;
}
if (!minus) {
add += bruh((idx + len * 2) / (len * 2) * (len * 2), tr - 1, len * 2);
} else {
add += bruh((idx - len * 2) / (len * 2) * (len * 2), tr - 1, len * 2);
}
}
}
return add;
}
void solve() {
cin >> n >> c;
if (n == 1) {
if (c[0] == 'a')
cout << 0 << nl;
else {
cout << 1 << nl;
}
return;
} else if (n == 2) {
sort(c.begin(), c.end());
ll ans = 0;
if (c[0] == 'a' && c[1] == 'b') {
cout << 0 << nl;
} else {
if (c[0] == 'a') {
cout << 1 << nl;
} else if (c[0] == 'b') {
cout << 1 << nl;
} else {
cout << 2 << nl;
}
}
return;
}
ll x = 1;
ll atharv = 0;
for (; x != n; atharv++) {
x *= 2;
}
ll amt = atharv + 1;
pref.resize(n);
for (ll i = 0; i < n; i++) {
pref[i].resize(26);
}
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < 26; j++) {
if (i) pref[i][j] = pref[i - 1][j];
}
pref[i][c[i] - 'a']++;
}
0;
ll ans = 1e9;
for (ll i = 0; i < n; i++) {
notone = 1;
vis.clear();
ans = min(bruh(i, 'a' + amt - 1, 1), ans);
0;
0;
}
cout << ans << nl;
pref.clear();
}
signed main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
ll t;
cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num;
cin >> num;
vector<long long int> vec;
vec.push_back(4);
vec.push_back(7);
int i = 0, j, k;
while (1) {
k = vec.size();
if (vec[k - 1] > 1000000000) break;
for (j = i; j < k; j++) {
vec.push_back(vec[j] * 10 + 4);
vec.push_back(vec[j] * 10 + 7);
}
i = k;
}
for (i = 0; i < vec.size(); i++) {
if (vec[i] == num) {
cout << i + 1 << endl;
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long n, q, tmp, x, pos, opt, l, r, flag[20], T[200005], f[20], g[20];
long long get(long long L, long long R) {
tmp = x;
for (long long i = 1; i <= min(n, 14ll); ++i) flag[i] = 0;
for (long long i = 1; i <= min(n, 14ll); ++i) {
pos = (tmp - 1) / f[min(n, 14ll) - i] + 1;
long long now = 0;
for (long long j = 1; j <= min(n, 14ll); ++j) {
if (!flag[j]) ++now;
if (now == pos) {
g[i] = j;
flag[j] = 1;
tmp = (tmp - 1) % f[min(n, 14ll) - i] + 1;
break;
}
}
}
if (n <= 14) {
long long sum = 0;
for (long long i = L; i <= R; ++i) sum += g[i];
return sum;
} else {
for (long long i = n - 13; i <= n; ++i)
T[i] = T[i - 1] + g[i - n + 14] + n - 14;
return T[R] - T[L - 1];
}
}
int main() {
n = read();
q = read();
x = 1;
f[0] = 1;
for (long long i = 1; i <= 14; ++i) f[i] = f[i - 1] * i;
T[1] = 1;
for (long long i = 2; i <= n; ++i) T[i] = T[i - 1] + i;
for (long long i = 1; i <= q; ++i) {
opt = read();
if (opt == 1) {
l = read();
r = read();
long long ans = get(l, r);
printf("%lld\n", ans);
} else
x += read();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4010;
const int inf = 99999999;
int ti, td, tr, te, i, j, l1, l2, t, t1, t2;
string s1, s2;
int f[MAXN][MAXN];
int ss1[MAXN][26], ss2[MAXN][26];
int main() {
cin >> ti >> td >> tr >> te;
cin >> s1 >> s2;
memset(f, 0, sizeof(f));
l1 = s1.size();
l2 = s2.size();
for (i = 0; i <= l1; i++)
for (j = 0; j <= l2; j++) f[i][j] = inf;
memset(ss1, 0, sizeof(ss1));
for (i = 0; i < l1; i++) {
for (j = 0; j < 26; j++) {
t1 = i;
while (t1 < l1 && s1[t1] != j + 'a') t1++;
ss1[i][j] = t1;
}
}
memset(ss2, 0, sizeof(ss2));
for (i = 0; i < l2; i++) {
for (j = 0; j < 26; j++) {
t2 = i;
while (t2 < l2 && s2[t2] != j + 'a') t2++;
ss2[i][j] = t2;
}
}
f[0][0] = 0;
for (i = 0; i <= l1; i++) {
for (j = 0; j <= l2; j++) {
if (i != l1) {
t = f[i][j] + td;
if (t < f[i + 1][j]) f[i + 1][j] = t;
}
if (j != l2) {
t = f[i][j] + ti;
if (t < f[i][j + 1]) f[i][j + 1] = t;
}
if (i != l1 && j != l2) {
if (s1[i] == s2[j])
t = f[i][j];
else
t = f[i][j] + tr;
if (t < f[i + 1][j + 1]) f[i + 1][j + 1] = t;
}
if (i < l1 - 1 && j < l2 - 1) {
t1 = ss1[i + 1][s2[j] - 'a'];
t2 = ss2[j + 1][s1[i] - 'a'];
if (t2 == l2) continue;
t = f[i][j] + (t1 - i - 1) * td + (t2 - j - 1) * ti + te;
if (t < f[t1 + 1][t2 + 1]) f[t1 + 1][t2 + 1] = t;
}
}
}
cout << f[l1][l2] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> p);
template <template <class...> class _TContainer, class... _T>
ostream& operator<<(ostream& out, _TContainer<_T...>& _Container);
struct graph {
public:
private:
int Vcnt;
vector<vector<pair<long long, int> > > _graph;
public:
inline int size() { return Vcnt; }
inline vector<pair<long long, int> >& adj(int node) { return _graph[node]; }
inline void addedge(int a, int b, long long w) {
addedge_onedir(a, b, w);
addedge_onedir(b, a, w);
}
inline void addedge_onedir(int a, int b, long long w) {
_graph[a].push_back({w, b});
}
inline graph(int V) {
_graph.resize(V);
Vcnt = V;
}
};
vector<bool> traversed(1010, 0);
vector<vector<int> > leaf;
vector<vector<int> > ans;
int root = 1;
graph g(1010);
inline void add(int toNode, int val) {
if (toNode == root) return;
if (leaf[toNode].size() == 1)
ans.push_back({root, toNode, val});
else {
ans.push_back({root, leaf[toNode][0], val / 2});
ans.push_back({root, leaf[toNode][1], val / 2});
ans.push_back({leaf[toNode][0], leaf[toNode][1], -val / 2});
}
}
inline void dfs(int node) {
traversed[node] = 1;
for (auto i : g.adj(node)) {
if (!traversed[i.second]) {
dfs(i.second);
leaf[node].push_back(leaf[i.second][0]);
traversed[i.second] = 0;
}
}
if (leaf[node].size() == 0) {
leaf[node].push_back(node);
return;
}
for (auto i : g.adj(node))
if (!traversed[i.second]) {
add(i.second, i.first);
add(node, -i.first);
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, w;
cin >> u >> v >> w;
g.addedge(u, v, w);
}
for (int i = 1; i <= n; i++)
if (g.adj(i).size() == 2) {
cout << "NO";
return 0;
}
cout << "YES"
<< "\n";
while (g.adj(root).size() != 1) root++;
leaf.resize(n + 10);
dfs(root);
cout << ans.size() << "\n";
for (auto i : ans) cout << i[0] << " " << i[1] << " " << i[2] << "\n";
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ',' << p.second << ')';
}
template <template <class...> class _TContainer, class... _T>
ostream& operator<<(ostream& out, _TContainer<_T...>& _Container) {
out << '[';
bool first = 1;
for (auto x : _Container) {
if (!first) out << ',';
out << x;
first = 0;
}
out << ']';
return out;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n, m, a, b, c;
cin >> n;
vector<ll> v;
for (ll i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
cin >> b >> c;
ll ans = 0;
for (ll i = 0; i < n; i++) {
ll t = v[i] / (b + c);
if (v[i] > b && t == 0) t++;
ans += t;
if (v[i] - t * (b + c) > b && t != 0) ans++;
}
cout << ans * c;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using std::cerr;
const int N = 1000005, mu = 1e9 + 7;
char s[N];
int a[N], n, lst[N], pre[N], dp[N];
int main() {
scanf("%s", s + 1);
int m = strlen(s + 1), cnt = 0;
for (int i = 1; i <= m; i++) {
if (s[i] == '1')
a[++n] = cnt, cnt = 0;
else
cnt++;
}
a[++n] = cnt;
if (cnt == m) return printf("%d\n", m), 0;
dp[1] = pre[1] = 1;
for (int i = 0; i <= m; i++) lst[i] = 1;
for (int i = 2; i < n; i++) {
for (int j = 0; j <= a[i]; j++)
dp[i] = ((long long)dp[i] + pre[i - 1] - pre[lst[j] - 1] + mu) % mu;
pre[i] = (pre[i - 1] + dp[i]) % mu;
for (int j = 0; j <= a[i]; j++) lst[j] = i;
}
int ans = pre[n - 1];
ans = (long long)ans * (a[1] + 1) % mu * (a[n] + 1) % mu;
printf("%d\n", ans);
}
| 5 |
#include <iostream>
using namespace std;
int main(){
const string TABLE[] = {".,!? ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
int n;
cin >> n;
for(int i=0;i<n;++i){
string s;
string ans;
int k=0,l=-1;
bool in = false;
cin >> s;
for(int j=0;j<s.size();++j){
if(s[j]=='0'){
if(in){
ans+=TABLE[k][l];
}
in = false;
k=0;
l=-1;
}else{
in = true;
l++;
k=s[j]-'1';
l%=TABLE[k].size();
}
}
cout << ans << "\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
const long long mod = 1e9 + 7;
long long gcd(long long a, long long b) { return (!b ? a : gcd(b, a % b)); }
long long exp(long long a, long long b) {
if (!b) return 1ll;
if (b == 1ll) return a;
long long p = exp(a, b >> 1);
if (b & 1) return a * p % mod * p % mod;
return p * p % mod;
}
char M[55][55];
int n, m;
string cm;
int i, j;
char mov[] = {'u', 'd', 'l', 'r'};
void go(int x) {
char c = mov[x];
if (c == 'u') i += -1;
if (c == 'd') i += 1;
if (c == 'r') j += 1;
if (c == 'l') j += -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int ans = 0;
cin >> n >> m;
int sti, stj;
for (int k = 1; k <= n; k++)
for (int l = 1; l <= m; l++) {
cin >> M[k][l];
if (M[k][l] == 'S') sti = k, stj = l;
}
cin >> cm;
sort(mov, mov + 4);
int cnt = 0;
do {
i = sti;
j = stj;
bool ok = false;
for (int k = 0; k < cm.size(); k++) {
go(cm[k] - '0');
if (M[i][j] == 'E') {
ok = true;
break;
}
if (M[i][j] == '#' || !i || !j || i > n || j > m) {
break;
}
}
if (ok) ans++;
} while (next_permutation(mov, mov + 4));
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class Fenwick {
private:
vector<int> arr;
const int size;
public:
Fenwick(int n) : arr(n + 1), size(n) {
for (int it = 0; it < arr.size(); ++it) arr[it] = 0;
}
void add(int v, int k) {
for (; k <= size; k += (k) & (-k)) {
arr[k] += v;
}
}
int get(int k) {
int total = 0;
for (; k > 0; k -= (k) & (-k)) {
total += arr[k];
}
return total;
}
};
template <typename U>
class Comparator {
public:
bool operator()(const U lhs, const U rhs) { return true; }
};
int main() {
int n;
scanf("%d", &n);
int first[n];
int total = 0;
for (int it = 0; it < n; ++it) {
scanf("%d", &first[it]);
total += first[it];
}
vector<int> ans;
for (int it = 0; it < n; ++it) {
if (((total - first[it]) % (n - 1) == 0) and
((total - first[it]) / (n - 1) == first[it]))
ans.push_back(it);
}
printf("%d\n", ans.size());
for (int it = 0; it < ans.size(); ++it) {
if (it) printf(" ");
printf("%d", ans[it] + 1);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[1009];
int n, p = 0;
;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
string x = s[i];
if (x[0] == 'O' && x[1] == 'O' && p == 0) {
x[0] = '+';
x[1] = '+';
p = 1;
}
if (x[3] == 'O' && x[4] == 'O' && p == 0) {
x[3] = '+';
x[4] = '+';
p = 1;
}
s[i] = x;
}
if (p == 0)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << s[i] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int f(int x) {
int i, sum = 0;
for (i = 1; i <= x; i++) {
sum += i;
}
return sum;
}
int main() {
int n, n1, i, b[70];
scanf("%d", &n);
for (i = 1; i <= 70; i++) {
if (n >= f(i) && n < f(i + 1)) {
n1 = i;
i = 71;
}
}
for (i = 1; i <= n1; i++) {
b[i] = i;
}
b[n1] += n - f(i - 1);
printf("%d\n%d", n1, b[1]);
for (i = 2; i <= n1; i++) {
printf(" %d", b[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct SegTree {
vector<int> node;
int n;
SegTree(int N) {
node.assign(N * 4, 0);
n = N;
}
long long get(int l, int r, int i, int lq, int rq) {
if (l > r || l > rq || r < lq) {
return INT_MAX / 2ll;
}
if (lq <= l && rq >= r) {
return node[i];
}
int mid = (l + r) / 2;
return min(get(l, mid, i * 2, lq, rq), get(mid + 1, r, i * 2 + 1, lq, rq));
}
void update(int l, int r, int i, int pos, int val) {
if (l > pos || r < pos || l > r) {
return;
}
if (l == r) {
node[i] += val;
return;
}
int mid = (l + r) / 2;
update(l, mid, i * 2, pos, val);
update(mid + 1, r, i * 2 + 1, pos, val);
node[i] = min(node[i * 2], node[i * 2 + 1]);
}
long long get(int l, int r) {
l = max(0, l);
r = min(n, r);
return get(0, n - 1, 1, l, r);
}
void update(int i, int val) { update(0, n - 1, 1, i, val); }
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int m = n * 3;
int a[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i + n + n] = a[i + n] = a[i];
}
SegTree tree(m);
for (int i = 0; i < m; i++) {
tree.update(i, a[i]);
}
int closest[m];
for (int i = 0; i < m; i++) {
closest[i] = INT_MAX / 2ll;
}
for (int i = 0; i < m; i++) {
int l = 1, r = m;
while (l < r) {
int mid = (l + r) / 2;
if (tree.get(i + 1, i + mid) * 2 < a[i]) {
r = mid;
} else {
l = mid + 1;
}
}
closest[i] = l;
}
set<pair<int, int> > s;
for (int i = 0; i < m; i++) {
if (closest[i] != m) {
s.insert({i + closest[i], i});
}
}
int ans[n];
int did = 0;
fill(ans, ans + n, INT_MAX / 2ll);
for (int i = 0; i < m; i++) {
if (i > 0) {
s.erase({i - 1 + closest[i - 1], i - 1});
}
if (s.size()) ans[i % n] = min(ans[i % n], s.begin()->first - i);
}
for (int i = 0; i < n; i++) {
cout << (ans[i] == INT_MAX / 2ll ? -1 : ans[i]) << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int DD, MM, YY;
int leap[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int normal[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool f(int bd, int bm, int by) {
if (bm > 12 || bm == 0) return 0;
if (by % 4 == 0) {
if (bd == 0 || bd > leap[bm - 1]) return 0;
} else {
if (bd == 0 || bd > normal[bm - 1]) return 0;
}
if (by + 18 > YY) return 0;
if (by + 18 < YY) return 1;
if (MM < bm) return 0;
if (MM > bm) return 1;
if (DD < bd) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
int bd, bm, by;
char s;
cin >> DD >> s >> MM >> s >> YY;
cin >> bd >> s >> bm >> s >> by;
if (f(bd, bm, by) || f(bd, by, bm) || f(by, bd, bm) || f(by, bm, bd) ||
f(bm, by, bd) || f(bm, bd, by))
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define LOG(...) fprintf(stderr, __VA_ARGS__)
//#define LOG(...)
#define FOR(i, a, b) for(int i=(int)(a); i<(int)(b); ++i)
#define REP(i, n) for(int i=0; i<(int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e)!=(s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SQ(n) (n) * (n)
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
struct Rect {
int l, t, r, b;
};
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void dfs(int y, int x, int h, int w, vvi &field){
field[y][x] = 2;
REP(i, 4){
int sx = x + dx[i];
int sy = y + dy[i];
if(sx < 0 || w <= sx || sy < 0 || h <= sy) continue;
if(field[sy][sx] == 0) {
dfs(sy, sx, h, w, field);
}
}
}
int main() {
int n;
while(cin >> n, n) {
vector<Rect> rect(n);
vi hol, ver;
map<int, int> hol_map, ver_map;
REP(i, n){
cin >> rect[i].l >> rect[i].t >> rect[i].r >> rect[i].b;
hol.push_back(rect[i].l);
hol.push_back(rect[i].r);
ver.push_back(rect[i].t);
ver.push_back(rect[i].b);
}
SORT(hol);
SORT(ver);
vvi field((ver.size()) * 2 + 1, vi((hol.size()) * 2 + 1, 0));
REP(i, n){
int l = (find(ALL(hol), rect[i].l) - hol.begin()) * 2 + 1;
int r = (find(ALL(hol), rect[i].r) - hol.begin()) * 2 + 1;
int t = (find(ALL(ver), rect[i].t) - ver.begin()) * 2 + 1;
int b = (find(ALL(ver), rect[i].b) - ver.begin()) * 2 + 1;
// LOG("%d %d %d %d\n", l, r, t, b);
FOR(x, l, r + 1){
field[t][x] = true;
field[b][x] = true;
}
FOR(y, b, t + 1){
field[y][l] = true;
field[y][r] = true;
}
}
int h = field.size(), w = field[0].size();
int cnt = 0;
REP(y, h){
REP(x, w){
if(field[y][x] == 0) {
cnt++;
dfs(y, x, h, w, field);
}
}
}
cout << cnt << endl;
// REP(y, h){
// REP(x, w){
// LOG("%d", field[y][x] & 1);
// }
// LOG("\n");
// }
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long dp[2000 + 5][2000 + 5], k[2000 + 5][2000 + 5],
c[2000 + 5][2 * 2000 + 5];
void init() {}
void Time_decreasing() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void enter() { scanf("%d %d", &n, &m); }
void Combinatoric() {
for (int i = 0; i <= max(m, n); i++) c[0][i] = 1, c[i][i] = 1;
for (int i = 1; i <= max(m, n); i++) {
for (int j = i + 1; j <= n + m; j++) {
c[i][j] =
(c[i - 1][j - 1] % 998244853 + c[i][j - 1] % 998244853) % 998244853;
}
}
}
void solve() {
for (int x = 0; x <= n; x++) {
for (int y = 0; y <= m; y++) {
if (x == 0) {
k[x][y] = 1;
} else if (x > y) {
k[x][y] = 0;
} else {
k[x][y] = (k[x - 1][y] + k[x][y - 1]) % 998244853;
}
}
}
for (int x = 0; x <= n; x++) {
for (int y = 0; y <= m; y++) {
if (y == 0) {
dp[x][y] = x;
} else if (x == 0) {
dp[x][y] = 0;
} else {
dp[x][y] = (c[y][x + y - 1] % 998244853 + dp[x - 1][y] % 998244853 +
dp[x][y - 1] % 998244853 + k[x][y - 1] % 998244853 -
(c[x][x + y - 1] % 998244853)) %
998244853;
}
}
}
printf("%lld\n", (dp[n][m] + 998244853) % 998244853);
}
int main() {
init();
Time_decreasing();
enter();
Combinatoric();
solve();
}
| 5 |
#include <bits/stdc++.h>
struct {
inline operator int() {
int x;
return scanf("%d", &x), x;
}
inline operator long long() {
long long x;
return scanf("%lld", &x), x;
}
template <class T>
inline void operator()(T &x) {
x = *this;
}
template <class T, class... A>
inline void operator()(T &x, A &...a) {
x = *this;
this->operator()(a...);
}
} read;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
int n = read, m = read;
if (n == 1 and m == 1) return puts("0"), 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
long long x = i, y = n + j;
if (m == 1) x = m + i, y = j;
printf("%lld ", x * y / gcd(x, y));
}
puts("");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
int cnt = 0, x;
bool vis[n];
memset(vis, 0, sizeof(vis));
vector<int> v;
for (int i = 0; i < m; i++) {
cnt = 0;
for (int j = 0; j < n; j++) {
if (a[j][i] == '1') {
x = j;
cnt++;
}
}
if (cnt == 1 && !vis[x]) {
v.push_back(x);
vis[x] = true;
}
}
sort(v.begin(), v.end());
bool f = 0;
if (v.size() != n)
cout << "YES";
else {
for (int i = 0; i < n; i++)
if (v[i] != i) f = 1;
if (!f)
cout << "NO";
else
cout << "YES";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, ex, ey;
cin >> x >> y;
cin >> ex >> ey;
cout << max(abs(x - ex), abs(y - ey));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, l, A, B, C, ans;
int main() {
cin >> a >> b >> c >> l;
l -= (!a + !b + !c);
a += !a;
b += !b;
c += !c;
for (long long i = 0; i <= l; i++)
A = max(min(l - i, a + i - b - c), -1ll) + 2,
B = max(min(l - i, b + i - a - c), -1ll) + 2,
C = max(min(l - i, c + i - b - a), -1ll) + 2,
ans -= A * (A - 1) + B * (B - 1) + C * (C - 1);
cout << (ans / 2 + ((l + 3) * (l + 2) * (l + 1)) / 6) * (l >= 0) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 3e5 + 5;
int fa[maxm << 1], cnt[maxm << 1], n, k, state[maxm][2];
int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]); }
void Union(int x, int y) {
x = Find(x), y = Find(y);
if (y == 0) swap(x, y);
fa[y] = x;
if (x) cnt[x] += cnt[y];
}
int calc(int x) {
int y = x <= k ? x + k : x - k;
x = Find(x), y = Find(y);
if (x == 0 || y == 0) return cnt[x + y];
return min(cnt[x], cnt[y]);
}
void run_case() {
cin >> n >> k;
string str;
cin >> str;
for (int i = 1; i <= k; ++i) {
int num, lamp;
cin >> num;
while (num--) {
cin >> lamp;
if (!state[lamp][0])
state[lamp][0] = i;
else
state[lamp][1] = i;
}
fa[i] = i, fa[i + k] = i + k, cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (!state[i][1]) {
int x = state[i][0];
if (x) {
ans -= calc(x);
if (str[i - 1] == '0') {
fa[Find(x)] = 0;
} else
fa[Find(x + k)] = 0;
ans += calc(x);
}
} else {
int x = state[i][0], y = state[i][1];
if (str[i - 1] == '0') {
if (Find(x + k) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Union(x, y + k), Union(x + k, y);
ans += calc(x);
}
} else {
if (Find(x) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Union(x, y), Union(x + k, y + k);
ans += calc(x);
}
}
}
cout << ans << "\n";
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
run_case();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int m = 1e9 + 7;
const int N = 3e5 + 10;
const int64_t INF = 100000000000000018LL;
vector<vector<long long>> graph(N);
vector<long long> collect;
long long odd = 0, even = 0;
long long pow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
bool checkbipartite(vector<long long> &visited, long long col, long long ind) {
visited[ind] = 1 - col;
bool t = true;
for (auto &it : graph[ind]) {
if (visited[it] == -1)
t = t && checkbipartite(visited, 1 - col, it);
else if (visited[it] == 1 - col)
return false;
}
return t;
}
bool isPrime(long long x) {
long long i;
for (i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
long long mini = INT_MAX;
void dfs(vector<vector<long long>> &graph, vector<bool> &visited, long long ind,
vector<long long> &v) {
if (visited[ind]) return;
visited[ind] = true;
mini = min(mini, v[ind]);
for (auto &it : graph[ind]) {
if (!visited[it]) {
dfs(graph, visited, it, v);
}
}
return;
}
bool isPowerOfTwo(long long n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
void solve() {
long long a[26], i, sum = 0, j;
for (i = 0; i < 26; i++) {
cin >> a[i];
}
string s;
cin >> s;
long long pref[(long long)s.size()];
for (i = 0; i < (long long)s.size(); i++) {
sum += a[s[i] - 'a'];
pref[i] = sum;
}
long long ans = 0;
for (i = 0; i < 26; i++) {
map<long long, long long> bac;
for (j = 0; j < (long long)s.size(); j++) {
if (s[j] - 'a' == i) {
if (j != 0) {
ans += bac[pref[j - 1]];
bac[pref[j]]++;
} else
bac[pref[j]]++;
}
}
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
int T, N;
int onxt[500202];
int nnxt[500202];
int a[500202];
bool check() {
map<int, int> mi;
mi[N + 1] = N + 1;
for (int i = ((N)-1); i >= (int)(0); i--) {
auto it = mi.lower_bound(a[i]);
if (onxt[i] == -1 || it->second == onxt[i]) {
} else
return false;
while (!mi.empty()) {
if (mi.begin()->first < a[i])
mi.erase(mi.begin());
else
break;
}
mi[a[i]] = i + 1;
}
return true;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &N);
for (int i = (0); i < (int)(N); i++)
scanf("%d", onxt + i), nnxt[i] = onxt[i];
set<int> si;
for (int i = (0); i < (int)(N); i++) {
if (onxt[i] == -1) {
nnxt[i] = N + 1;
auto it = si.upper_bound(i + 1);
if (it != si.end()) checkmin(nnxt[i], *it);
} else {
si.insert(onxt[i]);
}
}
vector<pair<int, int> > vp;
for (int i = (0); i < (int)(N); i++) vp.push_back(make_pair(-nnxt[i], i));
sort((vp).begin(), (vp).end());
int t = N;
for (auto &it : vp) {
a[it.second] = t--;
}
if (check()) {
for (int i = (0); i < (int)(N - 1); i++) printf("%d ", a[i]);
printf("%d\n", a[N - 1]);
} else {
printf("-1\n");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char mapp[2333][2333];
int dist[4][2333][2333];
typedef int arr[2333][2333];
template <class T, int siz>
struct fdeque {
T st[siz + 3];
int head, tail, fsiz;
void clr() { head = tail = fsiz = 0; }
bool empty() { return fsiz == 0; }
int size() { return fsiz; }
T front() { return st[head]; }
T back() { return st[(tail - 1 + siz) % siz]; }
void push_back(T x) {
st[tail] = x;
tail = (tail + 1) % siz;
++fsiz;
}
void push_front(T x) {
head = (head - 1 + siz) % siz;
st[head] = x;
++fsiz;
}
void pop_front() {
if (fsiz) {
head = (head + 1) % siz;
--fsiz;
}
}
void pop_back() {
if (fsiz) {
tail = (tail - 1 + siz) % siz;
--fsiz;
}
}
};
fdeque<pair<int, int>, 2333333> s;
int dx[4] = {0, 0, -1, 1}, dy[4] = {-1, 1, 0, 0};
void gd(int c, arr& arrr) {
s.clr();
memset(arrr, -1, sizeof(arrr));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mapp[i][j] == c) {
arrr[i][j] = 0;
s.push_back(make_pair(i, j));
}
}
}
while (!s.empty()) {
pair<int, int> f = s.front();
s.pop_front();
int x = f.first, y = f.second;
for (int i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (xx >= 0 && xx < n && yy >= 0 && yy < m && mapp[xx][yy] != '#')
;
else
continue;
int curd = arrr[x][y] + (mapp[xx][yy] == '.');
if (arrr[xx][yy] == -1 || arrr[xx][yy] > curd) {
arrr[xx][yy] = curd;
s.push_back(make_pair(xx, yy));
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", mapp[i]);
for (int i = '1'; i <= '3'; i++) gd(i, dist[i - '0']);
int ans = 2000000001;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dist[1][i][j] >= 0 && dist[2][i][j] >= 0 && dist[3][i][j] >= 0)
;
else
continue;
int hh = dist[1][i][j] + dist[2][i][j] + dist[3][i][j];
if (mapp[i][j] == '.') hh -= 2;
ans = min(ans, hh);
}
}
if (ans < 2000000000)
cout << ans << "\n";
else
cout << -1 << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100010];
bool f(int bit) {
bool flag = 0;
int lim = 1 << bit;
for (int i = 0; i < bit; i++) {
int j;
for (j = 0; j < n; j++) {
if (a[j] >= lim) {
flag = 1;
if ((a[j] & (1 << bit) && (a[j] & (1 << i)) == 0)) {
break;
}
}
}
if (j >= n) return 0;
}
return flag;
}
void print(int bit) {
int lim = 1 << bit;
set<int> v;
for (int i = 0; i < bit; i++) {
int j;
for (j = 0; j < n; j++) {
if (a[j] >= lim && (a[j] & (1 << bit))) {
if ((a[j] & (1 << i)) == 0) {
v.insert(j);
}
}
}
}
for (int j = 0; j < n; j++) {
if (a[j] & (1 << bit)) v.insert(j);
}
cout << v.size() << "\n";
for (auto it : v) {
cout << a[it] << " ";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int i;
for (i = 30; i >= 0; i--) {
if (f(i)) {
print(i);
break;
}
}
if (i < 0) {
cout << n << "\n";
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string int2str(int i) {
if (i == 0) return "";
string a = "1";
a[0] = '0' + (i % 10);
return int2str(i / 10) + a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<string> s(n);
vector<int> t(n), c(2, 0);
for (int i = 0; i < n; ++i) {
cin >> s[i] >> t[i];
++c[t[i]];
}
map<string, int> m;
for (int i = 1; i <= c[1]; ++i) m[int2str(i)] = 1;
for (int i = c[1] + 1; i <= n; ++i) m[int2str(i)] = 0;
queue<string> corra, corrb, oppa, oppb, rana, ranb, fria, frib;
for (int i = 0; i < n; ++i) {
if (t[i] == 0) {
if (m.count(s[i]) > 0) {
if (m[s[i]] == 0)
corra.push(s[i]);
else
oppa.push(s[i]);
m[s[i]] = 1337;
} else
rana.push(s[i]);
} else {
if (m.count(s[i]) > 0) {
if (m[s[i]] == 1)
corrb.push(s[i]);
else
oppb.push(s[i]);
m[s[i]] = 1337;
} else
ranb.push(s[i]);
}
}
for (int i = 1; i <= c[1]; ++i)
if (m[int2str(i)] < 2) frib.push(int2str(i));
for (int i = c[1] + 1; i <= n; ++i)
if (m[int2str(i)] < 2) fria.push(int2str(i));
if (corra.size() == c[0] && corrb.size() == c[1]) {
cout << 0 << endl;
return 0;
}
vector<string> ret;
if (rana.empty() && ranb.empty()) {
string q = oppa.front();
oppa.pop();
ret.push_back("move " + q + " bajs");
rana.push("bajs");
frib.push(q);
}
if (!fria.empty()) {
string old = fria.front();
fria.pop();
while (true) {
if (oppa.empty()) {
fria.push(old);
break;
}
string q = oppa.front();
oppa.pop();
ret.push_back("move " + q + " " + old);
old = q;
if (oppb.empty()) {
frib.push(old);
break;
}
q = oppb.front();
oppb.pop();
ret.push_back("move " + q + " " + old);
old = q;
}
} else {
string old = frib.front();
frib.pop();
while (true) {
if (oppb.empty()) {
frib.push(old);
break;
}
string q = oppb.front();
oppb.pop();
ret.push_back("move " + q + " " + old);
old = q;
if (oppa.empty()) {
fria.push(old);
break;
}
q = oppa.front();
oppa.pop();
ret.push_back("move " + q + " " + old);
old = q;
}
}
while (!oppa.empty()) {
string a = oppa.front(), b = fria.front();
oppa.pop();
fria.pop();
ret.push_back("move " + a + " " + b);
frib.push(a);
}
while (!oppb.empty()) {
string a = oppb.front(), b = frib.front();
oppb.pop();
frib.pop();
ret.push_back("move " + a + " " + b);
fria.push(a);
}
while (!rana.empty()) {
string a = rana.front(), b = fria.front();
rana.pop();
fria.pop();
ret.push_back("move " + a + " " + b);
}
while (!ranb.empty()) {
string a = ranb.front(), b = frib.front();
ranb.pop();
frib.pop();
ret.push_back("move " + a + " " + b);
}
cout << ret.size() << endl;
for (int i = 0; i < ret.size(); ++i) cout << ret[i] << endl;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.