solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 20;
const long long mod = 1e9 + 7;
long long k, a[N];
long long powmod(long long x, long long n) {
long long s = 1;
while (n) {
if (n & 1) s = (s * x) % mod;
n >>= 1, x = (x * x) % mod;
}
return s;
}
int main() {
while (cin >> k) {
long long n = 2;
long long flag = -1;
for (int i = 1; i <= k; i++) {
scanf("%I64d", &a[i]);
n = powmod(n, a[i]);
if (a[i] % 2 == 0) flag = 1;
}
long long q = n * powmod(2ll, mod - 2) % mod;
long long p = ((q + flag + mod) % mod * powmod(3ll, mod - 2) % mod) % mod;
cout << p << '/' << q << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int> > m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n, a;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
m[x].push_back(y);
m[y].push_back(x);
}
for (auto i : m)
if (i.second.size() == 1) a = i.first;
cout << a;
int p = -1;
for (int i = 0; i < n; i++) {
if (m[a][0] != p)
a = m[p = a][0];
else
a = m[p = a][1];
cout << ' ' << a;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void fst() {
ios::sync_with_stdio(0);
cin.tie(0);
}
int nxt() {
int x;
cin >> x;
return x;
}
int nex_l() {
long long x;
cin >> x;
return x;
}
int main() {
fst();
int tc;
cin >> tc;
while (tc--) {
int n = nxt(), m = nxt(), k = nxt();
if (n / k >= m) {
cout << m << "\n";
} else {
int ans = n / k - ((m - (n / k)) / (k - 1) +
(((m - (n / k)) % (k - 1) != 0) ? 1 : 0));
cout << ans << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
const long long int mod = 998244353;
const long long int big = 2.19e15 + 1;
const long double pai = 3.141592653589793238462643383279502884197;
const long double eps = 1e-15;
template <class T, class U>
bool mineq(T& a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T, class U>
bool maxeq(T& a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
long long int gcd(long long int a, long long int b) {
if (a % b == 0) {
return b;
} else
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
if (a == 0) {
return b;
}
return a / gcd(a, b) * b;
}
template <class T>
void SO(T& ve) {
sort(ve.begin(), ve.end());
}
template <class T>
void REV(T& ve) {
reverse(ve.begin(), ve.end());
}
template <class T>
long long int LBI(vector<T>& ar, T in) {
return lower_bound(ar.begin(), ar.end(), in) - ar.begin();
}
template <class T>
long long int UBI(vector<T>& ar, T in) {
return upper_bound(ar.begin(), ar.end(), in) - ar.begin();
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, i, j;
cin >> n;
vector<int> r(n);
for (i = 0; i < n; i++) {
cin >> r[i];
r[i]--;
}
vector<int> c(n);
for (i = 0; i < n; i++) {
cin >> c[i];
c[i]--;
}
vector<tuple<int, int, int, int>> ans;
for (i = 0; i < n; i++) {
if (r[i] == i && c[i] == i) {
continue;
}
int gr, gc;
for (j = i; j < n; j++) {
if (r[j] == i) {
swap(r[i], r[j]);
gr = j;
break;
}
}
for (j = i; j < n; j++) {
if (c[j] == i) {
swap(c[i], c[j]);
gc = j;
break;
}
}
ans.push_back(make_tuple(gr + 1, i + 1, i + 1, gc + 1));
}
cout << ans.size() << endl;
for (auto it : ans) {
int q, w, e, r;
tie(q, w, e, r) = it;
cout << q << " " << w << " " << e << " " << r << endl;
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10;
int vis[maxn][maxn];
string s;
map<string, int> m;
int p[maxn];
int score[maxn], got[maxn];
string name[10];
inline bool cmp(int i1, int i2) {
if (p[i1] != p[i2]) return p[i1] > p[i2];
int m1 = score[i1] - got[i1];
int m2 = score[i2] - got[i2];
if (m1 != m2) return m1 > m2;
if (score[i1] != score[i2]) return score[i1] > score[i2];
return name[i1] < name[i2];
}
inline bool is_ok() {
int p_[10];
for (int i = 1; i <= 4; ++i) p_[i] = i;
sort(p_ + 1, p_ + 1 + 4, cmp);
int me = m["BERLAND"];
if (p_[1] == me || p_[2] == me) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
int cur = 1;
for (int i = 0; i < 5; ++i) {
string k1, k2;
cin >> k1 >> k2;
int fi, se;
char g;
cin >> fi >> g >> se;
if (m[k1] == 0) m[k1] = cur++;
if (m[k2] == 0) m[k2] = cur++;
name[m[k1]] = k1;
name[m[k2]] = k2;
score[m[k1]] += fi;
score[m[k2]] += se;
got[m[k2]] += fi;
got[m[k1]] += se;
if (fi == se) {
p[m[k1]]++;
p[m[k2]]++;
} else if (fi > se)
p[m[k1]] += 3;
else if (fi < se)
p[m[k2]] += 3;
vis[m[k1]][m[k2]] = 1;
vis[m[k2]][m[k1]] = 1;
}
int me = m["BERLAND"];
p[me] += 3;
int t = 0;
for (int i = 1; i <= 4; ++i)
if (p[i] > p[me]) t++;
if (t >= 2) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
int op = 0;
for (int i = 1; i <= 4; ++i)
if (i != me && vis[me][i] == 0) op = i;
int m1 = 1000000, m2 = 1000000;
int dif = 1000000;
for (int i = 1; i <= 100; ++i)
for (int j = i - 1; j >= 0; --j) {
score[me] += i;
got[me] += j;
got[op] += i;
score[op] += j;
if (is_ok()) {
if (dif > i - j) {
dif = i - j;
m1 = i;
m2 = j;
} else if (dif == i - j && i < m1) {
m1 = i;
m2 = j;
}
}
score[me] -= i;
got[me] -= j;
got[op] -= i;
score[op] -= j;
}
cout << m1 << ":" << m2 << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (1e9) + 7;
const long long INF = (1e10) + 10;
struct edge {
int u, v, nxt;
long long cap, flow;
} e[2010];
struct Dic {
int head[410], en;
int q[410];
int dep[410], cur[410], sta[410];
void init() {
memset(head, -1, sizeof(head));
en = 0;
}
void adde1(int u, int v, long long w) {
e[en].v = v;
e[en].u = u;
e[en].cap = w;
e[en].flow = 0;
e[en].nxt = head[u];
head[u] = en++;
}
void adde2(int u, int v, long long w) {
adde1(u, v, w);
adde1(v, u, 0);
}
bool bfs(int s, int t, int n) {
int frt = 0, tal = 0;
memset(dep, -1, sizeof(dep[0]) * (n + 1));
dep[s] = 0;
q[tal++] = s;
while (frt < tal) {
int u = q[frt++];
for (int i = head[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (e[i].cap > e[i].flow && dep[v] == -1) {
dep[v] = dep[u] + 1;
if (v == t) return true;
q[tal++] = v;
}
}
}
return false;
}
long long dinic(int s, int t, int n) {
long long maxf = 0;
while (bfs(s, t, n)) {
for (int i = 0; i < n; i++) cur[i] = head[i];
int u = s, tal = 0;
while (cur[s] != -1) {
if (u == t) {
long long tp = INF;
for (int i = tal - 1; i >= 0; i--) {
tp = min(tp, e[sta[i]].cap - e[sta[i]].flow);
}
maxf += tp;
for (int i = tal - 1; i >= 0; i--) {
e[sta[i]].flow += tp;
e[sta[i] ^ 1].flow -= tp;
if (e[sta[i]].cap == e[sta[i]].flow) tal = i;
}
u = e[sta[tal] ^ 1].v;
} else if (cur[u] != -1 && e[cur[u]].cap > e[cur[u]].flow &&
dep[u] + 1 == dep[e[cur[u]].v]) {
sta[tal++] = cur[u];
u = e[cur[u]].v;
} else {
while (u != s && cur[u] == -1) u = e[sta[--tal] ^ 1].v;
cur[u] = e[cur[u]].nxt;
}
}
}
return maxf;
}
bool vis[410];
void cols(int ss) {
memset(vis, false, sizeof(vis));
dfs(ss);
}
void dfs(int x) {
vis[x] = true;
for (int i = head[x]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (!vis[v] && abs(e[i].cap) != abs(e[i].flow)) {
dfs(v);
}
}
}
};
int a[110], b[110];
int mp[110][110], mv[110][110];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int cntb = 0, cnta = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), cnta += a[i];
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), cntb += b[i];
if (cnta != cntb) {
printf("NO\n");
return 0;
}
Dic ans;
int ss = 0, tt = n * 4 + 1;
ans.init();
for (int i = 1; i <= n; i++) {
ans.adde2(ss, i, INF);
ans.adde2(i + n * 3, tt, INF);
ans.adde2(i, i + n, a[i]);
ans.adde2(i + n * 2, i + n * 3, b[i]);
mp[i][i] = ans.en;
ans.adde2(i + n, i + n * 2, INF);
}
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
mp[u][v] = ans.en;
ans.adde2(u + n, v + n * 2, INF);
mp[v][u] = ans.en;
ans.adde2(v + n, u + n * 2, INF);
}
long long mxf = ans.dinic(ss, tt, tt + 1);
if (mxf == cnta) {
printf("YES\n");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int id = mp[i][j];
long long cnt;
if (id == 0)
cnt = 0;
else
cnt = e[id].flow;
printf("%lld%c", cnt, j == n ? '\n' : ' ');
}
}
} else
printf("NO\n");
return 0;
}
| 13 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:25600000")
using namespace std;
const double pi = acos(-1.0);
const int MAXN = 9 * 1024000;
bool pres[MAXN];
int a[MAXN];
int ans[MAXN];
int n;
int main() {
for (long long i = 0; i < MAXN; i++) ans[i] = -1;
cin >> n;
for (long long i = 0; i < n; i++) {
scanf("%d", &a[i]);
pres[a[i]] = true;
}
for (long long i = 0; i < MAXN; i++) {
if (pres[i]) {
ans[i] = i;
continue;
}
for (long long pw = 0; pw < 23; pw++)
if (i & (1 << pw)) {
int t = i - (1 << pw);
if (ans[t] != -1) {
ans[i] = ans[t];
break;
}
}
}
for (long long i = 0; i < n; i++) {
int t = (1 << 23) - 1;
t ^= a[i];
if (i) cout << " ";
printf("%d", ans[t]);
}
cout << endl;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
const int INF = 0x3f3f3f3f;
int n;
struct edge {
int ne, to;
} e[MAXN << 1];
int fir[MAXN], num = 0, d[MAXN];
inline void join(int a, int b) {
e[++num].ne = fir[a];
fir[a] = num;
e[num].to = b;
}
int f[MAXN][MAXN][2], siz[MAXN];
void pre(int u, int fa) {
siz[u] = 1;
for (int i = fir[u]; i; i = e[i].ne) {
int v = e[i].to;
if (v == fa) continue;
pre(v, u);
siz[u] += siz[v];
}
}
int tmp[2];
void dfs(int u, int fa) {
if (d[u] == 1) {
f[u][1][1] = 0;
f[u][0][0] = 0;
} else {
f[u][0][0] = 0;
f[u][0][1] = 0;
}
for (int i = fir[u]; i; i = e[i].ne) {
int v = e[i].to;
if (v == fa) continue;
dfs(v, u);
for (int j = siz[u]; j >= 0; j--) {
for (int col = 0; col < 2 && (tmp[col] = INF); col++) {
for (int k = 0; k <= min(siz[v], j); k++) {
tmp[col] = min(tmp[col], f[u][j - k][col] +
min(f[v][k][col], f[v][k][col ^ 1] + 1));
}
f[u][j][col] = tmp[col];
}
}
}
}
int main() {
scanf("%d", &n);
memset(f, INF, sizeof(f));
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
join(a, b);
join(b, a);
++d[a];
++d[b];
}
int rt = 0, cnt = 0;
for (int i = n; i >= 1; i--)
if (d[i] == 1)
++cnt;
else
rt = i;
pre(rt, 0);
dfs(rt, 0);
printf("%d\n", min(f[rt][cnt / 2][0], f[rt][cnt / 2][1]));
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
double x = log(m) / log(n);
int jj = (int)(x + 1e-12);
if (abs(jj - x) < 1e-12)
cout << "YES"
<< "\n"
<< x - 1;
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, s = 0;
int c[55], d[55][55];
int temp[2501][2] = {0}, v = 1;
int res[2501][4];
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> c[i];
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < c[i]; ++j) {
cin >> d[i][j];
temp[v][0] = i + 1, temp[v][1] = j + 1;
v++;
s++;
}
}
int num = 1;
int count = 0;
while (1) {
for (int i = 0; i < m; ++i) {
for (int j = 0; j < c[i]; ++j) {
if (d[i][j] == num && num != s) {
swap(d[i][j], d[temp[num][0] - 1][temp[num][1] - 1]);
if (!(i == temp[num][0] - 1 && j == temp[num][1] - 1)) {
res[count][0] = i + 1;
res[count][1] = j + 1;
res[count][2] = temp[num][0];
res[count][3] = temp[num][1];
count++;
}
num++;
}
}
}
if (num == s) break;
}
cout << count << endl;
for (int i = 0; i < count; ++i) {
cout << res[i][0] << " " << res[i][1] << " " << res[i][2] << " "
<< res[i][3] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> k;
bool flag = 0;
long long p = 1, i;
if (n <= 2 && k == 3) {
puts("NO");
continue;
}
for (i = 0; i < n; i++) {
p = (1 << i);
p = p * p;
if (k <= p) {
flag = 1;
break;
}
k -= p;
}
if (flag) {
printf("YES");
} else {
puts("NO");
continue;
}
p = (1 << i);
if (k >= (p + p - 1))
printf(" %lld\n", n - i - 1);
else
printf(" %lld\n", n - i);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
double iszero(double x) { return fabs(x) < 1e-4; }
double dist(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
double gcd(double x, double y) {
if (iszero(y))
return x;
else
return gcd(y, fmod(x, y));
}
int main() {
double ax, ay, bx, by, cx, cy;
cin >> ax >> ay;
cin >> bx >> by;
cin >> cx >> cy;
double a = dist(ax, ay, bx, by), b = dist(bx, by, cx, cy),
c = dist(cx, cy, ax, ay);
double p = (a + b + c) / 2;
double S = sqrt(p * (p - a) * (p - b) * (p - c));
double R = a * b * c / (4 * S);
double A = acos((b * b + c * c - a * a) / (2 * b * c));
double B = acos((c * c + a * a - b * b) / (2 * c * a));
double C = acos((a * a + b * b - c * c) / (2 * a * b));
double angle = gcd(gcd(A, B), C);
double n = pi / angle;
double ret = n * R * R * sin(2 * pi / n) / 2;
printf("%.6f\n", ret);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int modP = 1e9 + 7;
const long long oo = 1000000000000000LL;
const int maxN = 999999;
long long g[maxN + 10];
int k, F[6];
void knapsack() {
fill(g, g + maxN + 10, -1);
g[0] = 0;
for (auto i = 0, d = 1; i < 6; ++i, d *= 10)
for (int p = 1, left = 3 * k; left > 0; p *= 2) {
auto t = min(p, left);
auto w = 1ll * t * d * 3, v = 1ll * t * F[i];
for (auto s = maxN; s >= w; s -= 3) {
if (g[s - w] != -1) g[s] = max(g[s], g[s - w] + v);
}
left -= t;
}
for (auto i = 0, d = 1; i < 6; ++i, d *= 10)
for (auto s = maxN; s >= 1; --s)
for (auto j = 0; j * d <= min(9 * d, s); ++j) {
auto tmp = (j % 3) ? 0ll : 1ll * (j / 3) * F[i];
if (g[s - j * d] != -1) {
g[s] = max(g[s], g[s - j * d] + tmp);
}
}
}
int main() {
cin >> k;
--k;
for (auto i = 0; i < 6; ++i) cin >> F[i];
knapsack();
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
cout << g[n] << endl;
}
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000009, inf, DP[2][2][32][32][32], N, H;
int fix(int x) { return min(inf, x); }
int main() {
cin >> N >> H;
inf = H + 1;
DP[0][0][1][1][1] = 1;
for (int rem = 0; rem < N; rem++) {
for (int d1 = 0; d1 <= 1; d1++)
for (int d2 = 1; d2 <= inf; d2++)
for (int d3 = 1; d3 <= inf; d3++)
for (int d4 = 1; d4 <= inf; d4++) {
DP[(rem + 1) & 1][d1][d2][d3][d4] = 0;
}
for (int d2 = 1; d2 <= inf; d2++)
for (int d3 = 1; d3 <= inf; d3++)
for (int d4 = 1; d4 <= inf; d4++) {
DP[(rem + 1) & 1][0][fix(d2 + 1)][fix(d3 + 1)][fix(d4 + 1)] +=
DP[rem & 1][0][d2][d3][d4];
DP[(rem + 1) & 1][0][fix(d2 + 1)][fix(d3 + 1)][fix(d4 + 1)] %= mod;
DP[(rem + 1) & 1][d2 == inf ? 1 : 0][2][fix(d3 + 1)][fix(d4 + 1)] +=
DP[rem & 1][0][d2][d3][d4];
DP[(rem + 1) & 1][d2 == inf ? 1 : 0][2][fix(d3 + 1)][fix(d4 + 1)] %=
mod;
DP[(rem + 1) & 1][d3 == inf ? 1 : 0][fix(d2 + 1)][2][fix(d4 + 1)] +=
DP[rem & 1][0][d2][d3][d4];
DP[(rem + 1) & 1][d3 == inf ? 1 : 0][fix(d2 + 1)][2][fix(d4 + 1)] %=
mod;
DP[(rem + 1) & 1][d4 == inf ? 1 : 0][fix(d2 + 1)][fix(d3 + 1)][2] +=
DP[rem & 1][0][d2][d3][d4];
DP[(rem + 1) & 1][d4 == inf ? 1 : 0][fix(d2 + 1)][fix(d3 + 1)][2] %=
mod;
DP[(rem + 1) & 1][1][fix(d2 + 1)][fix(d3 + 1)][fix(d4 + 1)] +=
DP[rem & 1][1][d2][d3][d4];
DP[(rem + 1) & 1][1][fix(d2 + 1)][fix(d3 + 1)][fix(d4 + 1)] %= mod;
DP[(rem + 1) & 1][d2 == inf ? 1 : 0][inf][fix(d3 + 1)][fix(d4 + 1)] +=
DP[rem & 1][1][d2][d3][d4];
DP[(rem + 1) & 1][d2 == inf ? 1 : 0][inf][fix(d3 + 1)][fix(d4 + 1)] %=
mod;
DP[(rem + 1) & 1][d3 == inf ? 1 : 0][fix(d2 + 1)][inf][fix(d4 + 1)] +=
DP[rem & 1][1][d2][d3][d4];
DP[(rem + 1) & 1][d3 == inf ? 1 : 0][fix(d2 + 1)][inf][fix(d4 + 1)] %=
mod;
DP[(rem + 1) & 1][d4 == inf ? 1 : 0][fix(d2 + 1)][fix(d3 + 1)][inf] +=
DP[rem & 1][1][d2][d3][d4];
DP[(rem + 1) & 1][d4 == inf ? 1 : 0][fix(d2 + 1)][fix(d3 + 1)][inf] %=
mod;
}
}
int ret = 0;
for (int d1 = 0; d1 <= 1; d1++)
for (int d2 = 1; d2 <= inf; d2++)
for (int d3 = 1; d3 <= inf; d3++)
for (int d4 = 1; d4 <= inf; d4++) {
ret = (ret + DP[N & 1][d1][d2][d3][d4]) % mod;
}
cout << (ret - DP[N & 1][1][inf][inf][inf] + mod) % mod << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int a[N], b[N], top;
int T, n, G, v, ans[N];
map<int, int> mp;
pair<int, int> q[N];
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
void exgcd(int x, int y, int &a, int &b) {
if (!y) {
a = 1;
b = 0;
return;
}
exgcd(y, x % y, b, a);
b -= x / y * a;
}
int getinv(int x, int y) {
int a, b;
exgcd(x, y, a, b);
return (a % y + y) % y;
}
void solve(int l, int r) {
if (!v) {
for (int i = (int)(l); i <= (int)(r); i++) ans[q[i].second] = 1;
return;
}
int iv = getinv(v / G, T / G);
for (int i = (int)(l); i <= (int)(r); i++)
q[i].first = 1ll * iv * (b[q[i].second] / G) % (T / G);
sort(q + l, q + r + 1);
for (int i = (int)(l); i <= (int)(r - 1); i++)
ans[q[i].second] = q[i + 1].first - q[i].first;
ans[q[r].second] = T / G + q[l].first - q[r].first;
}
int main() {
scanf("%d%d", &T, &n);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &a[i]);
for (int i = (int)(2); i <= (int)(n); i++) b[i] = (b[i - 1] + a[i]) % T;
v = (a[1] + b[n]) % T;
G = gcd(v, T);
for (int i = (int)(1); i <= (int)(n); i++) {
if (!mp[b[i]]) q[++top] = pair<int, int>(b[i] % G, i);
mp[b[i]] = 1;
}
sort(q + 1, q + top + 1);
int l = 1;
for (int i = (int)(2); i <= (int)(n + 1); i++)
if (i == n + 1 || q[i].first != q[i - 1].first) solve(l, i - 1), l = i;
for (int i = (int)(1); i <= (int)(n); i++) printf("%d ", ans[i]);
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210;
pair<long long, long long> pt[MAXN];
long long a[MAXN];
long long g[MAXN][MAXN];
int main() {
int n;
cin >> n;
long long d;
cin >> d;
for (int i = 1; i < n - 1; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> pt[i].first >> pt[i].second;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
g[i][j] = -d * (abs(pt[i].first - pt[j].first) +
abs(pt[i].second - pt[j].second));
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (i != k && j != k) {
long long pik = g[i][k];
long long pkj = g[i][k] + a[k] + g[k][j];
g[i][j] = max(g[i][j], min(pik, pkj));
}
long long res = max(0LL, -g[0][n - 1]);
cout << res << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void myassert(bool expr) {
if (!expr) abort();
}
const int64_t posinf = 9223372036854775807LL;
const int64_t neginf = 9223372036854775808LL;
const int64_t bigprime = (1LL << 61) - 1LL;
const int64_t mult = 199;
const int64_t mult2 = 3571;
const int64_t mod = 1000000007LL;
const int64_t mod2 = 1000000009LL;
const long double pi = 3.1415926535897932384626433832795L;
template <typename T>
T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
int a, b;
cin >> a >> b;
if (a >= 2400 && b > a) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
int n, m, i, j, k;
deque<char> a[N];
string s;
vector<pair<pair<int, int>, pair<int, int> > > ans, s1, s2;
inline void wk(vector<pair<pair<int, int>, pair<int, int> > >& v, bool fl) {
static int b[N], c[N];
memset(b, 0, sizeof b);
memset(c, 0, sizeof c);
for (i = 1; i <= n; ++i) a[i].clear();
for (i = 1; i <= n; ++i) {
cin >> s;
if (fl) reverse(s.begin(), s.end());
for (j = 0; j < s.size(); ++j) a[i].push_back(s[j]);
for (j = 2; j <= m; ++j) {
cin >> s;
if (fl) reverse(s.begin(), s.end());
for (k = s.size() - 1; k >= 0; --k) {
if (i == 1) {
if (s[k] == '0')
v.push_back(make_pair(pair<int, int>(1, j), pair<int, int>(1, 1)));
else
v.push_back(make_pair(pair<int, int>(1, j), pair<int, int>(n, j))),
++c[j];
} else if (i == n) {
if (s[k] == '1')
v.push_back(make_pair(pair<int, int>(n, j), pair<int, int>(n, 1)));
else
v.push_back(make_pair(pair<int, int>(n, j), pair<int, int>(1, j))),
++b[j];
} else
v.push_back(make_pair(pair<int, int>(i, j), pair<int, int>(i, 1))),
a[i].push_front(s[k]);
}
}
}
for (i = 2; i <= m; ++i) {
for (; b[i]--;)
v.push_back(make_pair(pair<int, int>(1, i), pair<int, int>(1, 1)));
for (; c[i]--;)
v.push_back(make_pair(pair<int, int>(n, i), pair<int, int>(n, 1)));
}
for (i = 2; i < n; ++i)
for (j = a[i].size() - 1; j >= 0; --j)
if (a[i][j] == '0')
v.push_back(make_pair(pair<int, int>(i, 1), pair<int, int>(1, 1)));
else
v.push_back(make_pair(pair<int, int>(i, 1), pair<int, int>(n, 1)));
for (i = 0; i < a[1].size(); ++i)
if (a[1][i] == '1') break;
int z = 0;
for (j = a[1].size() - 1; j >= i; --j)
if (a[1][j] == '1')
v.push_back(make_pair(pair<int, int>(1, 1), pair<int, int>(n, 1)));
else
v.push_back(make_pair(pair<int, int>(1, 1), pair<int, int>(1, 2))), ++z;
for (; z--;)
v.push_back(make_pair(pair<int, int>(1, 2), pair<int, int>(1, 1)));
for (i = 0; i < a[n].size(); ++i)
if (a[n][i] == '0') break;
z = 0;
for (j = a[n].size() - 1; j >= i; --j)
if (a[n][j] == '0')
v.push_back(make_pair(pair<int, int>(n, 1), pair<int, int>(1, 1)));
else
v.push_back(make_pair(pair<int, int>(n, 1), pair<int, int>(n, 2))), ++z;
for (; z--;)
v.push_back(make_pair(pair<int, int>(n, 2), pair<int, int>(n, 1)));
std::cerr << v.size() << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
wk(s1, 0);
wk(s2, 1);
ans = s1;
for (i = s2.size() - 1; i >= 0; --i)
ans.push_back(make_pair(s2[i].second, s2[i].first));
cout << ans.size() << '\n';
for (i = 0; i < ans.size(); ++i) {
cout << ans[i].first.first << ' ' << ans[i].first.second << ' ';
cout << ans[i].second.first << ' ' << ans[i].second.second << '\n';
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int tot, n, m, ll, rr, aa, w, rt[100005];
struct que {
int h, i;
} p[100005];
bool cmp(que a, que b) { return b.h < a.h; }
struct node {
int mx, l, r, ls, rs;
bool tag;
} t[3000005], ans;
void merge(node &a, node b, node c) {
a.tag = (b.tag && c.tag);
if (b.tag)
a.l = b.l + c.l;
else
a.l = b.l;
if (c.tag)
a.r = b.r + c.r;
else
a.r = c.r;
a.mx = max(max(max(b.mx, c.mx), max(a.l, a.r)), max(b.r + c.l, a.mx));
}
void ins(int &k, int lst, int l, int r) {
if (!k) k = ++tot;
if (l == r) {
t[k].mx = t[k].l = t[k].r = t[k].tag = 1;
return;
}
int md = (l + r) / 2;
if (aa <= md) {
ins(t[k].ls, t[lst].ls, l, md);
t[k].rs = t[lst].rs;
} else {
ins(t[k].rs, t[lst].rs, md + 1, r);
t[k].ls = t[lst].ls;
}
merge(t[k], t[t[k].ls], t[t[k].rs]);
}
void build(int &k, int l, int r) {
k = ++tot;
if (l == r) return;
int md = (l + r) / 2;
build(t[k].ls, l, md);
build(t[k].rs, md + 1, r);
}
void fnd(int k, int l, int r) {
if (ll <= l && r <= rr) {
merge(ans, ans, t[k]);
return;
}
int md = (l + r) / 2;
if (ll <= md) fnd(t[k].ls, l, md);
if (md < rr) fnd(t[k].rs, md + 1, r);
}
bool chk(int k) {
ans = (node){0, 0, 0, 0, 0};
fnd(rt[k], 1, n);
return w <= ans.mx;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i].h), p[i].i = i;
sort(p + 1, p + n + 1, cmp);
build(rt[0], 1, n);
for (int i = 1; i <= n; i++) aa = p[i].i, ins(rt[i], rt[i - 1], 1, n);
scanf("%d", &m);
while (m--) {
scanf("%d%d%d", &ll, &rr, &w);
int l = 1, r = n;
for (int md = (l + r) / 2; l < r; md = (l + r) / 2)
if (chk(md))
r = md;
else
l = md + 1;
printf("%d\n", p[l].h);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 5;
int n, a[MAXN];
int cnt[MAXN];
int c1[MAXN], c2, c3, k;
inline long long solve() {
long long res = 0;
int p = n >> 1;
while (a[p] == a[n - p + 1]) --p;
memset(c1, 0, sizeof(c1));
memset(c1, 0, sizeof(c1));
c2 = c3 = 0;
auto add1 = [&](int x, int d) {
if (c1[x]) --c2;
if (c1[x] < 0) --c3;
c1[x] += d;
if (c1[x]) ++c2;
if (c1[x] < 0) ++c3;
};
for (int i = k; i <= p - 1; ++i) add1(a[i], 1), add1(a[n - i + 1], -1);
for (int i = p; i <= (n >> 1); ++i) {
add1(a[i], 1);
add1(a[n - i + 1], -1);
if (!c2) {
return 1ll * k * (n - i + 1);
}
}
if (n & 1) {
int p = (n + 1) >> 1;
add1(a[p], 1);
if (c2 == 1) return 1ll * k * (n - p + 1);
}
for (int i = ((n + 1) >> 1) + 1; i <= n - k + 1; ++i) {
add1(a[i], 2);
if (!c3) {
return 1ll * k * (n - i + 1);
}
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), cnt[a[i]] ^= 1;
int sm = 0;
for (int i = 1; i <= n; ++i) sm += cnt[i];
if (sm > 1) {
puts("0");
return 0;
}
bool flag = 1;
for (int i = 1; i <= n; ++i) flag &= (a[i] == a[n - i + 1]);
if (flag) {
printf("%lld\n", 1ll * n * (n + 1) / 2);
return 0;
}
k = 1;
while (a[k] == a[n - k + 1]) ++k;
long long ans = solve();
std::reverse(a + 1, a + n + 1);
ans += solve();
ans -= 1ll * k * k;
printf("%lld\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)3e5 + 100;
const int mod = (int)1e9 + 7;
int n, q, tot, d[maxn], ans[maxn];
vector<int> g[maxn];
void calcSz(int v) {
d[v] = 1;
for (int to : g[v]) {
calcSz(to);
d[v] += d[to];
}
}
set<pair<int, int> > second[maxn];
void dfs(int v) {
int ch = -1;
for (int to : g[v]) {
dfs(to);
if (ch == -1 || d[ch] < d[to]) ch = to;
}
if (ch == -1) {
second[v].insert(make_pair(d[v], v));
ans[v] = v;
return;
} else {
swap(second[v], second[ch]);
second[v].insert(make_pair(d[v], v));
for (int to : g[v])
if (to != ch)
for (auto x : second[to]) second[v].insert(x);
auto x = second[v].lower_bound(make_pair(d[v] / 2, mod));
ans[v] = x->second;
}
}
int main() {
scanf("%d%d", &n, &q);
for (int i = (2); i <= (n); ++i) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
calcSz(1);
dfs(1);
while (q--) {
int v;
scanf("%d", &v);
printf("%d\n", ans[v]);
}
}
| 11 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while(t--){
int n;
cin >> n;
if(n%2){
for(int i = 1; i <= n; i++){
for(int j = i+1; j <= n; j++){
if((i+j)%2){
cout << 1 <<' ';
}
else{
cout << -1 << ' ';
}
}
}
}
else{
for(int i = 1; i < n; i++){
for(int j = i+1; j <= n; j++){
if((i%2) && (j==i+1)){
cout << 0 << ' ' ;
}
else{
if((i+j)%2){
cout << 1 <<' ';
}
else{
cout << -1 << ' ';
}
}
}
}
}
cout << endl;
}
} | 7 |
#include <bits/stdc++.h>
using namespace std;
istream& operator>>(istream& in, __int128& a) {
int64_t b;
in >> b;
a = b;
return in;
}
ostream& operator<<(ostream& out, const __int128 a) {
unsigned __int128 b = a < 0 ? -a : a;
char buf[128];
char* c = end(buf);
do {
--c;
*c = "0123456789"[b % 10];
b /= 10;
} while (b);
if (a < 0) {
--c;
*c = '-';
}
int64_t len = end(buf) - c;
out.rdbuf()->sputn(c, len);
return out;
}
template <class T>
void mini(T& a, T b) {
a = min(a, b);
}
template <class T>
void maxi(T& a, T b) {
a = max(a, b);
}
template <class T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <class T1, class T2>
ostream& operator<<(ostream& os, pair<T1, T2> const& a) {
return os << "[" << a.first << ", " << a.second << "]";
}
template <class Ch, class Tr, class Container>
basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& os,
Container const& a) {
os << "{ ";
for (auto& i : a) os << i << " ";
return os << "}";
}
template <class T>
void out(T a) {
cout << a << endl;
}
template <class T, class... Args>
void out(T a, Args... args) {
cout << a << " ";
out(args...);
}
template <class T>
void out(std::initializer_list<T> a) {
for (auto i : a) {
cout << i << " ";
}
cout << endl;
}
template <class T>
void out(vector<vector<T>> a) {
for (vector<T> i : a) out(i);
}
template <class T>
void out_(T a[], int l, int r) {
for (int i = l; i <= r; i++) cout << a[i] << " ";
cout << endl;
}
void out() { cout << "OK" << endl; }
template <class T>
void sort(vector<T>& a) {
sort(a.begin(), a.end());
}
template <class T>
void rever(vector<T>& a) {
reverse(a.begin(), a.end());
}
template <class T>
void uniq(vector<T>& a) {
sort(a);
a.erase(unique(a.begin(), a.end()), a.end());
}
template <class T>
vector<T> set_int(vector<T> a, vector<T> b) {
sort(a);
sort(b);
vector<T> res;
set_intersection(a.begin(), a.end(), b.begin(), b.end(), back_inserter(res));
return res;
}
clock_t start_time;
void start_timer() { start_time = clock(); }
double get_time() { return (double)(clock() - start_time) / CLOCKS_PER_SEC; }
template <class T>
using min_pque = priority_queue<T, vector<T>, greater<T>>;
void Solve() {
int n, k;
cin >> n >> k;
vector<int> a = {1};
while (a.back() * k < n) {
a.push_back(a.back() * k);
}
cout << a.size() << "\n";
for (int i = 0; i <= n - 1; i++) {
for (int j = i + 1; j <= n - 1; j++) {
for (int t = a.size() - 1; t >= 0; t--) {
if (i / a[t] != j / a[t]) {
cout << t + 1 << " ";
break;
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
start_timer();
Solve();
return 0;
}
| 17 |
///****In the name of ALLAH, most Gracious, most Compassionate****//
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <int, int> pii;
#define ALL(a) a.begin(), a.end()
#define FastIO ios::sync_with_stdio(false); cin.tie(0);cout.tie(0)
#define IN freopen("input.txt","r+",stdin)
#define OUT freopen("output.txt","w+",stdout)
#define DBG(a) cerr<< "line "<<__LINE__ <<" : "<< #a <<" --> "<<(a)<<endl
#define NL cout<<endl
template < class T1,class T2>
ostream &operator <<(ostream &os,const pair < T1,T2 > &p)
{
os<<"{"<<p.first<<","<<p.second<<"}";
return os;
}
const int N=3e5+5;
const int oo=1e9+7;
int c[N];
int a[505][505];
int now ;
vector<pii> g;
int sol(vector<int > &idx)
{
if(idx.size() == 1)
return idx[0];
int mx = 0;
for(int i=0;i<idx.size();i++)
{
for(int j=i+1;j<idx.size();j++)
mx=max(mx,a[idx[i]][idx[j]]);
}
vector< vector<int > > v;
for(int i=0;i<idx.size();i++)
{
int ii = -1;
for(int j=0;j<v.size();j++)
if(a[idx[i]][v[j].back()] != mx)
{
ii=j;
break;
}
if(ii==-1)
v.push_back({idx[i]});
else v[ii].push_back(idx[i]);
}
// DBG(mx);
int ret = ++now;
c[ret] = mx;
for(auto i: v) {
g.push_back({sol(i) ,ret });
}
return ret;
}
int32_t main()
{
FastIO;
int n;
cin>>n;
for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) cin>>a[i][j];
now = n;
vector<int > x;
for(int i=1;i<=n;i++) x.push_back(i);
int r = sol(x);
cout<<now<<"\n";
for(int i=1;i<=n;i++) cout<<a[i][i]<<" ";
for(int i=n+1;i<=now;i++) cout<<c[i]<<" ";
cout<<"\n";
cout<<r<<"\n";
for(auto i: g)
cout<<i.first<<" "<<i.second<<"\n";
}
| 15 |
#include <bits/stdc++.h>
const long long INF = 4e18L + 1;
const int IINF = 2e9 + 1;
const int limit = 1048576;
using namespace std;
template <class F>
struct mat {
long long n;
vector<vector<F> > tab;
mat(long long n1) : n{n1}, tab(vector<vector<F> >(n, vector<F>(n, 0))) {
for (long long i = (long long)0; i < (long long)n; i++) {
tab[i][i] = 1;
}
}
mat(long long n1, F val)
: n{n1}, tab(vector<vector<F> >(n, vector<F>(n, val))) {}
mat operator*(const mat& other) {
mat res(n, 0);
for (long long k = (long long)0; k < (long long)n; k++) {
for (long long j = (long long)0; j < (long long)n; j++) {
for (long long i = (long long)0; i < (long long)n; i++) {
res.tab[k][i] += tab[k][j] * other.tab[j][i];
}
}
}
return res;
}
mat pow(long long p) {
mat self = *this;
if (p == 0) {
return mat(n);
} else {
mat temp = (self * self).pow(p / 2);
if (p & 1) {
return temp * self;
} else {
return temp;
}
}
}
vector<F> operator*(const vector<F>& v) {
vector<F> res(n, 0);
for (long long k = (long long)0; k < (long long)n; k++) {
for (long long i = (long long)0; i < (long long)n; i++) {
res[k] += v[i] * tab[k][i];
}
}
return res;
}
};
long long n, x, l;
vector<long double> P;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> x;
l = (1 << (32 - __builtin_clz(x)));
P.resize(l, 0.0);
for (long long i = (long long)0; i < (long long)x + 1; i++) {
cin >> P[i];
}
mat<long double> trans(l, 0.0);
for (long long i = (long long)0; i < (long long)l; i++) {
for (long long j = (long long)0; j < (long long)l; j++) {
trans.tab[i][j] = P[i ^ j];
if (0) cout << trans.tab[i][j] << " ";
}
if (0) cout << "\n";
}
mat<long double> temp = trans.pow(n - 1);
for (long long i = (long long)0; i < (long long)l; i++) {
for (long long j = (long long)0; j < (long long)l; j++) {
if (0) cout << temp.tab[i][j] << " ";
}
if (0) cout << "\n";
}
auto res = trans.pow(n - 1) * P;
for (auto& i : res) {
if (0) cout << i << " ";
}
if (0) cout << "\n";
cout << 1.0 - res[0] << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
long gcd(long x, long y);
int main() {
long x, y, l, p, q;
long a, b;
scanf("%ld%ld%ld%ld", &x, &y, &a, &b);
l = (x * y) / gcd(x, y);
p = a / l;
q = b / l;
if (a % l == 0) q++;
printf("%ld", q - p);
return (0);
}
long gcd(long x, long y) {
if (y > x)
return gcd(y, x);
else if (y == 0)
return x;
else
return gcd(y, x % y);
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
const int maxn = 200003, INF = 0x3f3f3f3f;
int n, m;
int bl[maxn];
struct Q {
int l, r, id, tim;
bool operator<(const Q& b) const {
return bl[l] == bl[b.l]
? (bl[r] == bl[b.r] ? (bl[r] & 1 ? tim < b.tim : tim > b.tim)
: (bl[l] & 1 ? r < b.r : r > b.r))
: l < b.l;
}
} q[maxn];
struct C {
int pos, now;
} c[maxn];
int L = 1, R, T, col[maxn], vis[maxn], ans[maxn];
int a[maxn], qcnt, Time;
inline void Upd(int x, int d) { --vis[col[x]], col[x] += d, ++vis[col[x]]; }
inline void Chg(int pos, int& x) {
if (L <= pos && pos <= R) Upd(a[pos], -1), Upd(x, 1);
std::swap(a[pos], x);
}
void Mo() {
for (int i = (1); i <= (qcnt); ++i) {
while (T < q[i].tim) ++T, Chg(c[T].pos, c[T].now);
while (T > q[i].tim) Chg(c[T].pos, c[T].now), --T;
int l = q[i].l, r = q[i].r;
while (l < L) Upd(a[--L], 1);
while (l > L) Upd(a[L++], -1);
while (r < R) Upd(a[R--], -1);
while (r > R) Upd(a[++R], 1);
int res = 1;
while (vis[res]) ++res;
ans[q[i].id] = res;
}
}
std::unordered_map<int, int> ha;
int tot;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
const int sz = pow(n, 2.0 / 3);
for (int i = (1); i <= (n); ++i) {
cin >> a[i], bl[i] = (i - 1) / sz + 1;
if (ha[a[i]])
a[i] = ha[a[i]];
else
a[i] = ha[a[i]] = ++tot;
}
for (int i = (1); i <= (m); ++i) {
int opt, x, y;
cin >> opt >> x >> y;
if (opt & 1)
q[++qcnt] = (Q){x, y, qcnt, Time};
else {
if (ha[y])
y = ha[y];
else
y = ha[y] = ++tot;
c[++Time] = (C){x, y};
}
}
std::sort(q + 1, q + qcnt + 1);
Mo();
for (int i = (1); i <= (qcnt); ++i) cout << ans[i] << '\n';
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int a = 0, d = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'A') {
a++;
} else {
d++;
}
}
if (a > d) {
cout << "Anton" << endl;
} else if (a < d) {
cout << "Danik" << endl;
} else {
cout << "Friendship" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long double eps = 1e-8;
struct Point {
long long x, y;
Point(long long _x = 0, long long _y = 0) : x(_x), y(_y) {}
};
bool cmp1(const Point a, const Point b) {
return a.x == b.x ? a.y > b.y : a.x < b.x;
}
bool cmp2(const Point a, const Point b) {
return (long double)a.y * b.x > (long double)a.x * b.y;
}
Point operator-(const Point a, const Point b) {
return Point(a.x - b.x, a.y - b.y);
}
Point operator+(const Point a, const Point b) {
return Point(a.x + b.x, a.y + b.y);
}
long double cross(const Point a, const Point b) {
return (long double)a.x * b.y - (long double)a.y * b.x;
}
vector<Point> p[3], res;
struct Edge {
int u, v, id, nxt;
} E[N << 1];
int tot = 0, head[N];
int n, m, idn, idm;
int a[N], b[N], vis[N];
long long suma[N], sumb[N];
vector<Edge> e[N];
void addedge(int u, int v, int id) {
E[++tot] = (Edge){u, v, id, head[u]};
head[u] = tot;
}
void rebuild(int u, int fa) {
int last = u, cnt = 0;
for (auto cur : e[u]) {
int v = cur.v;
if (v == fa) continue;
++cnt;
if (cnt == 1) {
addedge(u, v, cur.id);
addedge(v, u, cur.id);
last = u;
} else if (cnt == ((signed)e[u].size() - (u != 1))) {
addedge(last, v, cur.id);
addedge(v, last, cur.id);
} else {
++idn, ++idm;
addedge(last, idn, idm);
addedge(idn, last, idm);
addedge(idn, v, cur.id);
addedge(v, idn, cur.id);
last = idn;
}
}
for (auto cur : e[u]) {
int v = cur.v;
if (v == fa) continue;
rebuild(v, u);
}
}
int siz[N], val, edge, siz_all;
void dfs(int u, int fa, vector<Point> &cur) {
cur.emplace_back(Point(suma[u], sumb[u]));
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].v;
if (v == fa || vis[E[i].id]) continue;
suma[v] = suma[u] + a[E[i].id];
sumb[v] = sumb[u] + b[E[i].id];
dfs(v, u, cur);
}
}
void dfs_siz(int u, int fa) {
siz[u] = 1;
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].v;
if (v == fa || vis[E[i].id]) continue;
dfs_siz(v, u);
siz[u] += siz[v];
}
}
void dfs_edge(int u, int fa) {
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].v;
if (v == fa || vis[E[i].id]) continue;
if (val > max(siz_all - siz[v], siz[v])) {
val = max(siz_all - siz[v], siz[v]);
edge = i;
}
dfs_edge(v, u);
}
}
Point st[N];
int tp;
void build(vector<Point> &p) {
tp = 0;
sort(p.begin(), p.end(), cmp1);
for (auto x : p) {
while (tp > 1 && cross(st[tp] - x, st[tp - 1] - x) <= 0) tp--;
st[++tp] = x;
}
p.clear();
for (int i = 1; i <= tp; i++) p.emplace_back(st[i]);
}
void merge(vector<Point> &p1, vector<Point> &p2, vector<Point> &p3) {
build(p1), build(p2);
Point cur = p1[0] + p2[0];
for (int i = 1; i < (signed)p1.size(); i++)
p3.emplace_back(p1[i] - p1[i - 1]);
for (int i = 1; i < (signed)p2.size(); i++)
p3.emplace_back(p2[i] - p2[i - 1]);
sort(p3.begin(), p3.end(), cmp2);
st[tp = 1] = cur;
for (auto x : p3) {
cur = cur + x;
while (tp > 1 && fabs(cross(cur - st[tp], cur - st[tp - 1])) <= eps) tp--;
st[++tp] = cur;
}
p3.clear();
for (int i = 1; i <= tp; i++) p3.emplace_back(st[i]);
}
void tree_devide(int x) {
if (!x) return;
vis[E[x].id] = 1;
p[0].clear(), p[1].clear(), p[2].clear();
suma[E[x].u] = suma[E[x].v] = 0;
sumb[E[x].u] = sumb[E[x].v] = 0;
dfs(E[x].u, 0, p[0]);
dfs(E[x].v, 0, p[1]);
merge(p[0], p[1], p[2]);
for (auto cur : p[2]) {
res.emplace_back(cur + Point(a[E[x].id], b[E[x].id]));
}
edge = 0;
dfs_siz(E[x].u, 0);
edge = 0, val = siz_all = siz[E[x].u];
dfs_edge(E[x].u, 0);
tree_devide(edge);
edge = 0;
dfs_siz(E[x].v, 0);
edge = 0, val = siz_all = siz[E[x].v];
dfs_edge(E[x].v, 0);
tree_devide(edge);
}
long long calc(Point a, int cur) { return 1ll * cur * a.x + a.y; }
int main() {
scanf("%d %d", &n, &m);
idn = n, idm = n - 1;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d %d %d", &u, &v, &a[i], &b[i]);
e[u].emplace_back((Edge){u, v, i, 0});
e[v].emplace_back((Edge){v, u, i, 0});
}
rebuild(1, 0);
tree_devide(1);
build(res);
int cur = 0;
for (int i = 0; i < m; i++) {
while (cur + 1 < (signed)res.size() &&
calc(res[cur], i) <= calc(res[cur + 1], i))
cur++;
printf("%lld ", (long long)calc(res[cur], i));
}
return 0;
}
| 24 |
#include <bits/stdc++.h>
const int maxn = 210;
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 0;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return f ? x : -x;
}
struct point {
int x, y;
long long operator*(const point &A) const {
return (long long)x * A.y - (long long)y * A.x;
}
point operator-(const point &A) const { return (point){x - A.x, y - A.y}; }
} a[maxn], p[maxn];
queue<int> q[maxn];
vector<int> G[maxn], E[maxn];
long long f[maxn][maxn][55], mx[55];
void add(int x, int y) {
while (!q[x].empty() && (p[q[x].front()] - p[x]) * (p[y] - p[x]) < 0) {
add(q[x].front(), y);
q[x].pop();
}
G[x].push_back(y);
E[y].push_back(x);
q[y].push(x);
}
int main() {
int n = read(), m = read();
for (int i = 1; i <= n; ++i) a[i].x = read(), a[i].y = read();
long long ans = 0;
for (int s = 1; s <= n; ++s) {
int tot = 0;
for (int i = 1; i <= n; ++i)
if (a[i].x > a[s].x || (a[i].x == a[s].x && a[i].y > a[s].y))
p[++tot] = a[i] - a[s];
sort(p + 1, p + tot + 1,
[&](const point &A, const point &B) { return A * B > 0; });
for (int i = 1; i <= tot; ++i) {
E[i].clear(), G[i].clear();
while (!q[i].empty()) q[i].pop();
}
for (int i = 1; i < tot; ++i) add(i, i + 1);
memset(f, -0x3f, sizeof(f));
for (int i = tot; i >= 0; --i) {
memset(mx, -0x3f, sizeof(mx));
reverse(E[i].begin(), E[i].end());
int cur = G[i].size() - 1;
for (auto j : E[i]) {
f[i][j][1] = p[j] * p[i];
while (~cur && (p[j] - p[i]) * (p[G[i][cur]] - p[i]) < 0) {
for (int k = 1; k < m; ++k) mx[k] = max(mx[k], f[G[i][cur]][i][k]);
--cur;
}
for (int k = 1; k < m; ++k) f[i][j][k + 1] = mx[k] + p[j] * p[i];
}
}
for (int i = 1; i <= tot; ++i)
for (auto j : E[i]) ans = max(ans, f[i][j][m - 2]);
}
printf("%.2lf\n", (double)ans / 2.);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int n, q, f, s;
int a[5005], l[5005], r[5005], qz[5005];
int main() {
cin >> n >> q;
int nn = 0;
for (int i = 0; i < q; ++i) {
cin >> l[i] >> r[i];
a[l[i]]++;
a[r[i] + 1]--;
}
for (int i = 1; i <= n; ++i) {
a[i] += a[i - 1];
if (a[i]) nn++;
}
int ans = 1000000;
for (int i = 0; i < q - 1; ++i) {
int summ = 0;
for (int j = 1; j <= n; ++j) {
if (j >= l[i] && j <= r[i]) {
summ += (a[j] == 1);
qz[j] = qz[j - 1] + (a[j] == 2);
} else
qz[j] = qz[j - 1] + (a[j] == 1);
}
for (int j = i + 1; j < q; ++j) {
int aa = qz[r[j]] - qz[l[j] - 1];
ans = summ + aa < ans ? summ + aa : ans;
}
}
cout << nn - ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
constexpr long long MAX = 5100000;
constexpr long long INF = 1LL << 62;
constexpr int inf = 1000000007;
constexpr long long mod = 1000000007LL;
const long double PI = acos(-1);
using namespace std;
long long f(long long n, long long k) {
if (k == 0) return n - 1;
return n - k + min(k * (k - 1) / 2, n - k);
}
void suzuken() {
long long n;
scanf("%lld", &n);
long long left = 0;
long long right = n;
while (right - left > 5) {
long long lmid = (left * 2 + right) / 3;
long long rmid = (left + right * 2) / 3;
if (f(n, lmid) > f(n, rmid))
right = rmid;
else
left = lmid;
}
long long res = 0;
for (long long i = left; i <= right; i++) chmax(res, f(n, i));
printf("%lld\n", res);
}
int main() {
int kkt;
scanf("%d", &kkt);
while (kkt--) {
suzuken();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
const int MOD = 1E9 + 7;
const long long N = 1e5 + 15;
const int maxn = 5e5 + 15;
const int letter = 130;
const int INF = 1e17;
const double pi = acos(-1.0);
const double eps = 1e-10;
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;
}
int n, m, ps[maxn];
double laz[maxn << 2], ans[maxn << 2];
int pp[maxn << 2];
struct node {
int zb, h, l, r;
int l1, r1, l2, r2;
} que[N], mg[10015];
bool fb(double x) {
if (x <= eps) return 1;
return 0;
}
void pushdown(int lr) {
if (pp[lr]) {
laz[lr << 1] *= laz[lr];
laz[lr << 1 | 1] *= laz[lr];
laz[lr] = 1;
pp[lr << 1] = pp[lr << 1 | 1] = 1;
pp[lr] = 0;
}
}
void build(int lr, int l, int r) {
if (l > r) return;
pp[lr] = 0;
ans[lr] = laz[lr] = 1.0;
if (l == r) return;
int mid = (l + r) >> 1;
build(lr << 1, l, mid);
build(lr << 1 | 1, mid + 1, r);
}
void update(int ll, int rr, double v, int lr, int l, int r) {
if (ll <= l && r <= rr) {
laz[lr] *= v;
pp[lr] = 1;
return;
}
pushdown(lr);
int mid = (l + r) >> 1;
if (ll <= mid) update(ll, rr, v, lr << 1, l, mid);
if (rr > mid) update(ll, rr, v, lr << 1 | 1, mid + 1, r);
}
double query(int id, int lr, int l, int r) {
if (l == r) return laz[lr];
pushdown(lr);
int mid = (l + r) >> 1;
if (id <= mid)
return query(id, lr << 1, l, mid);
else
return query(id, lr << 1 | 1, mid + 1, r);
}
int main() {
scanf("%d%d", &n, &m);
int cnt = 0;
for (int i = 0; i < n; i++) {
que[i].zb = read(), que[i].h = read(), que[i].l = read(), que[i].r = read();
ps[++cnt] = que[i].zb - 1;
ps[++cnt] = que[i].zb - que[i].h;
ps[++cnt] = que[i].zb + 1;
ps[++cnt] = que[i].zb + que[i].h;
}
for (int i = 0; i < m; i++) {
mg[i].zb = read(), mg[i].h = read();
ps[++cnt] = mg[i].zb;
}
sort(ps + 1, ps + cnt + 1);
cnt = unique(ps + 1, ps + cnt + 1) - (ps + 1);
for (int i = 0; i < n; i++) {
que[i].l1 = lower_bound(ps + 1, ps + cnt + 1, que[i].zb - que[i].h) - ps;
que[i].r1 = lower_bound(ps + 1, ps + cnt + 1, que[i].zb - 1) - ps;
que[i].l2 = lower_bound(ps + 1, ps + cnt + 1, que[i].zb + 1) - ps;
que[i].r2 = lower_bound(ps + 1, ps + cnt + 1, que[i].zb + que[i].h) - ps;
}
for (int i = 0; i < m; i++) {
mg[i].zb = lower_bound(ps + 1, ps + cnt + 1, mg[i].zb) - ps;
}
build(1, 1, cnt);
for (int i = 0; i < n; i++) {
update(que[i].l1, que[i].r1, 1.0 * (100 - que[i].l) / 100, 1, 1, cnt);
update(que[i].l2, que[i].r2, 1.0 * (100 - que[i].r) / 100, 1, 1, cnt);
}
double sum = 0;
for (int i = 0; i < m; i++) {
sum += 1.0 * mg[i].h * query(mg[i].zb, 1, 1, cnt);
}
printf("%.10f\n", sum);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
int n, k, a[1000010];
int gra(int n) {
if (k & 1) {
if (n < 4) return n & 1;
if (n == 4) return 2;
if (n == 5) return 0;
if (n & 1) return 0;
int d = gra(n / 2);
if (d == 1)
return 2;
else
return 1;
} else {
if (n == 0 || n == 3) return 0;
if (n == 1) return 1;
if (n == 2) return 2;
return (n + 1) & 1;
}
}
int main() {
gn(n, k);
for (int i = 0; i < n; i++) gn(a[i]);
int ans = 0;
for (int i = 0; i < n; i++) ans ^= gra(a[i]);
if (ans != 0)
puts("Kevin");
else
puts("Nicky");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void upmax(T& a, T b) {
if (a < b) a = b;
}
template <class T>
inline void upmin(T& a, T b) {
if (a > b) a = b;
}
const int maxn = 10007;
const int maxm = 200007;
const int mod = 1000000007;
const long long inf = 1ll << 62;
const double eps = 1e-7;
typedef int arr[maxn];
typedef int adj[maxm];
inline int fcmp(double a, double b) {
if (fabs(a - b) <= eps) return 0;
if (a < b - eps) return -1;
return 1;
}
inline int add(int a, int b) { return ((long long)a + b) % mod; }
inline int mul(int a, int b) { return ((long long)a * b) % mod; }
inline int dec(int a, int b) { return add(a, mod - b % mod); }
inline int Pow(int a, int b) {
int t = 1;
while (b) {
if (b & 1) t = mul(t, a);
a = mul(a, a), b >>= 1;
}
return t;
}
template <typename Type>
inline Type RD() {
Type x = 0;
int flag = 0;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
(c == '-') ? (flag = 1) : (x = c - '0');
while (isdigit(c = getchar())) x = x * 10 + c - '0';
return flag ? -x : x;
}
inline char rdch() {
char c = getchar();
while (!isalpha(c)) c = getchar();
return c;
}
int n, c;
arr p, s;
long long f[2][maxn];
void input() {
n = RD<int>(), c = RD<int>();
for (int i = 1, _ = n; i <= _; i++) p[i] = RD<int>();
for (int i = 1, _ = n; i <= _; i++) s[i] = RD<int>();
}
void solve() {
int cur = 0, pre = 1;
f[cur][0] = p[n], f[cur][1] = s[n];
for (int i = ((int)n) - 1, _ = (1); i >= _; i--) {
cur ^= 1, pre ^= 1;
int x = n - i + 1;
for (int j = 0, _ = x; j <= _; j++) {
f[cur][j] = inf;
if (j) upmin(f[cur][j], f[pre][j - 1] + 1ll * (x - j) * c + s[i]);
if (j < x) upmin(f[cur][j], f[pre][j] + p[i]);
}
}
long long ans = inf;
for (int i = 0, _ = n; i <= _; i++) upmin(ans, f[cur][i]);
cout << ans << "\n";
}
int main() {
input();
solve();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
set<string> s;
pair<string, string> p[305];
vector<int> v;
int dp[605][605];
bool cmp(int x, int y) { return x > y; }
int main() {
int n, a, b, k, f;
cin >> n >> a >> b >> k >> f;
for (int i = 1; i <= n; i++) {
cin >> p[i].first >> p[i].second;
s.insert(p[i].first);
s.insert(p[i].second);
}
set<string>::iterator itr;
int t = 1;
for (itr = s.begin(); itr != s.end(); ++itr) {
m[*itr] = t;
t++;
}
dp[m[p[1].first]][m[p[1].second]] = a;
for (int i = 2; i <= n; i++) {
if (p[i].first == p[i - 1].second)
dp[m[p[i].first]][m[p[i].second]] += b;
else
dp[m[p[i].first]][m[p[i].second]] += a;
}
for (int i = 1; i <= t; i++)
for (int j = i; j <= t; j++) {
v.push_back(dp[i][j] + dp[j][i]);
}
long long ans = 0;
sort(v.begin(), v.end(), cmp);
for (int i = 0; i < v.size(); i++) {
if (v[i] > f && k)
ans += f, k--;
else
ans += v[i];
}
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100010];
int a[100010];
int main() {
int n, m;
cin >> n >> m;
long long ans = 0LL, res = 0LL;
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; i++) {
if (i > 1 && a[i - 1] != a[i]) G[a[i]].push_back(a[i - 1]);
if (i < m && a[i + 1] != a[i]) G[a[i]].push_back(a[i + 1]);
}
for (int i = 1; i <= n; i++) {
if (G[i].size() == 0) continue;
sort(G[i].begin(), G[i].end());
int x = G[i][G[i].size() / 2];
long long ttmp = 0LL;
long long tmp = 0LL;
for (int j = 0; j < G[i].size(); j++) {
ttmp += abs(i - G[i][j]);
}
for (int j = 0; j < G[i].size(); j++) {
tmp += abs(G[i][j] - x);
}
res = max(res, ttmp - tmp);
ans += ttmp;
}
printf("%I64d\n", ans / 2 - res);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int arr[n + 1];
for (long long int i = 1; i < n + 1; i++) {
cin >> arr[i];
}
long long int a = arr[1];
long long int ai = 1;
long long int b, bi = -1;
for (long long int i = 2; i < n + 1; i++) {
if (arr[i] != a) {
b = arr[i];
bi = i;
break;
}
}
if (bi == -1)
cout << "NO" << endl;
else {
cout << "YES" << endl;
cout << ai << " " << bi << endl;
for (long long int i = 2; i < n + 1; i++) {
if (i != bi) {
if (arr[i] != a)
cout << ai << " " << i << endl;
else
cout << bi << " " << i << endl;
}
}
}
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const double eps = 1e-9;
template <typename T>
typename enable_if<!is_integral<T>::value, void>::type read(T &x) {
cin >> x;
}
long long read() {
char c;
long long out = 0, f = 1;
for (c = getchar(); !isdigit(c) && c != '-'; c = getchar())
;
if (c == '-') {
f = -1;
c = getchar();
}
for (; isdigit(c); c = getchar()) out = (out << 3) + (out << 1) + c - '0';
return out * f;
}
template <typename T>
typename enable_if<is_integral<T>::value, T>::type read(T &x) {
char c;
T f = 1;
x = 0;
for (c = getchar(); !isdigit(c) && c != '-'; c = getchar())
;
if (c == '-') {
f = -1;
c = getchar();
}
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
return x *= f;
}
char read(char &x) {
for (x = getchar(); isspace(x); x = getchar())
;
return x;
}
double read(double &x) {
scanf("%lf", &x);
return x;
}
void read(char *x) { scanf("%s", x); }
template <typename T>
typename enable_if<!is_integral<T>::value, void>::type write(const T &x) {
cout << x;
}
template <typename T>
typename enable_if<is_integral<T>::value, void>::type write(const T &x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void write(const char &x) { putchar(x); }
void write(const double &x) { printf("%.10lf", x); }
void write(const char *x) { printf("%s", x); }
template <typename T, typename... Args>
void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <typename... Args>
void read(char *x, Args &...args) {
read(x);
read(args...);
}
template <
typename OutputIt,
typename = typename enable_if<
is_same<output_iterator_tag,
typename iterator_traits<OutputIt>::iterator_category>::value ||
(is_base_of<forward_iterator_tag, typename iterator_traits<OutputIt>::
iterator_category>::value &&
!is_const<OutputIt>::value)>::type>
void read(OutputIt __first, OutputIt __last) {
for (; __first != __last; ++__first) read(*__first);
}
template <
typename InputIt,
typename = typename enable_if<is_base_of<
input_iterator_tag,
typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wts(InputIt __first, InputIt __last) {
for (; __first != __last; ++__first) {
write(*__first);
putchar(' ');
}
}
template <
typename InputIt,
typename = typename enable_if<is_base_of<
input_iterator_tag,
typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wtb(InputIt __first, InputIt __last) {
for (; __first != __last; ++__first) {
write(*__first);
putchar('\n');
}
}
void wts(const char *x) {
write(x);
putchar(' ');
}
void wtb(const char *x) {
write(x);
putchar('\n');
}
template <typename T>
void wts(const T &x) {
write(x);
putchar(' ');
}
template <typename T>
void wtb(const T &x) {
write(x);
putchar('\n');
}
template <typename... Args>
void wts(const char *x, Args... args) {
wts(x);
wts(args...);
}
template <typename... Args>
void wtb(const char *x, Args... args) {
wts(x);
wtb(args...);
}
template <typename T, typename... Args>
void wts(const T &x, Args... args) {
wts(x);
wts(args...);
}
template <typename T, typename... Args>
void wtb(const T &x, Args... args) {
wts(x);
wtb(args...);
}
template <typename T>
inline bool up(T &x, const T &y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
inline bool dn(T &x, const T &y) {
return y < x ? x = y, 1 : 0;
}
const long long N = 110;
const long long K = 1010;
const long long S = 100010;
const long long mod = 1000000007;
struct Node {
long long x, a, f, p, type, id;
bool operator<(const Node &b) const {
return a == b.a ? type > b.type : a < b.a;
}
} a[S << 1];
queue<long long> q;
bool xianzhi[S];
long long head[S], cur[S], nxt[K << 4], to[K << 4], edge[K << 4], cnt = 1;
long long n, m, c, b, k, ans, mxp[N], g[S], dis[N][N], dep[S], s = S - 2,
t = S - 1;
void add(long long u, long long v, long long w) {
nxt[++cnt] = head[u];
head[u] = cnt;
to[cnt] = v;
edge[cnt] = w;
}
void Add(long long u, long long v, long long w) {
add(u, v, w);
add(v, u, 0);
}
long long dfs(long long u, long long flow) {
if (dep[u] == dep[t]) return u == t ? flow : 0;
long long v, w, f, out = 0;
for (long long &i = cur[u]; i && flow - out; i = nxt[i]) {
v = to[i];
w = edge[i];
if (w > 0 && dep[v] == dep[u] + 1) {
f = dfs(v, min(w, flow - out));
edge[i] -= f;
edge[i ^ 1] += f;
out += f;
}
}
return out;
}
bool bfs() {
memset(dep, -1, sizeof(dep));
dep[s] = 0;
q.push(s);
while (!q.empty()) {
long long u = q.front();
q.pop();
for (long long i = head[u]; i; i = nxt[i]) {
long long v = to[i];
long long w = edge[i];
if (w > 0 && dep[v] == -1) {
dep[v] = dep[u] + 1;
q.push(v);
}
}
}
return dep[t] > 0;
}
long long dinic() {
long long out = 0;
while (bfs()) {
memcpy(cur, head, sizeof(cur));
out += dfs(s, INF);
}
return out;
}
signed main() {
read(n, m);
memset(dis, 0x3f, sizeof(dis));
for (long long i = (1), iend = (m); i <= iend; ++i) {
long long u, v;
read(u, v);
dis[u][v] = dis[v][u] = 1;
}
for (long long i = (1), iend = (n); i <= iend; ++i) dis[i][i] = 0;
for (long long k = (1), kend = (n); k <= kend; ++k)
for (long long i = (1), iend = (n); i <= iend; ++i)
for (long long j = (1), jend = (n); j <= jend; ++j)
dn(dis[i][j], dis[i][k] + dis[k][j]);
read(c, b, k);
for (long long i = (1), iend = (c); i <= iend; ++i) {
read(a[i].x, a[i].a, a[i].f, a[i].p);
a[i].type = 1;
a[i].id = i;
}
for (long long i = (1), iend = (b); i <= iend; ++i) {
read(a[i + c].x, a[i + c].a, a[i + c].p);
a[i + c].type = 2;
}
sort(a + 1, a + c + b + 1);
for (long long i = (1), iend = (n); i <= iend; ++i) mxp[i] = -INF;
for (long long i = (1), iend = (c); i <= iend; ++i) g[i] = -INF;
for (long long i = (1), iend = (c + b); i <= iend; ++i) {
if (a[i].type == 1) {
for (long long j = (1), jend = (n); j <= jend; ++j)
if (dis[a[i].x][j] <= a[i].f) up(g[a[i].id], mxp[j] - a[i].p);
} else
up(mxp[a[i].x], a[i].p);
}
for (long long i = (1), iend = (k); i <= iend; ++i) {
long long u, v;
read(u, v);
Add(u, v, INF);
xianzhi[u] = xianzhi[v] = true;
}
for (long long i = (1), iend = (c); i <= iend; ++i) {
if (xianzhi[i]) {
if (g[i] >= 0) {
ans += g[i];
Add(s, i, g[i]);
} else
Add(i, t, -g[i]);
} else if (g[i] > 0)
ans += g[i];
}
wtb(ans - dinic());
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
_T GCD(const _T &a, const _T &b) {
return b ? GCD(b, a % b) : a;
}
const int N = 2e5 + 10;
int n;
int T[N];
bool vis[N];
vector<int> V, V2;
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> T[i];
vis[T[i]] = 1;
if (T[i] == 0) V2.push_back(i);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) V.push_back(i);
sort((V).begin(), (V).end());
for (int i = 0, sz = V2.size(); i < sz; i++) {
if (i < sz - 1) {
T[V2[i]] = V[i + 1];
} else {
T[V2[i]] = V[0];
}
}
for (int i = 0, sz = V2.size(); i < sz; i++) {
if (T[V2[i]] == V2[i]) {
if (i < sz - 1) {
swap(T[V2[i]], T[V2[i + 1]]);
} else {
swap(T[V2[i]], T[V2[0]]);
}
}
}
for (int i = 1; i <= n; i++) cout << T[i] << " ";
cout << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string Pangram(string input, int size_Input) {
if (size_Input >= 26) {
int Count[26] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
for (int i = 0; i < size_Input; i++) {
if (isupper(input[i])) {
input[i] = tolower(input[i]);
}
Count[input[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (Count[i] == 0) return "No";
}
return "Yes";
} else {
return "No";
}
}
int main() {
int n;
string input;
cin >> n;
cin >> input;
cout << Pangram(input, n) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void fft(vector<complex<double>>& a) {
long long n = (long long)(a).size(), L = 31 - __builtin_clz(n);
static vector<complex<long double>> R(2, 1);
static vector<complex<double>> rt(2, 1);
for (static long long k = 2; k < n; k *= 2) {
R.resize(n);
rt.resize(n);
auto x = polar(1.0L, acos(-1.0L) / k);
for (long long i = k; i < (2 * k); ++i)
rt[i] = R[i] = i & 1 ? R[i / 2] * x : R[i / 2];
}
vector<long long> rev(n);
for (long long i = 0; i < (n); ++i) rev[i] = (rev[i / 2] | (i & 1) << L) / 2;
for (long long i = 0; i < (n); ++i)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (long long k = 1; k < n; k *= 2)
for (long long i = 0; i < n; i += 2 * k)
for (long long j = 0; j < (k); ++j) {
auto x = (double*)&rt[j + k], y = (double*)&a[i + j + k];
complex<double> z(x[0] * y[0] - x[1] * y[1], x[0] * y[1] + x[1] * y[0]);
a[i + j + k] = a[i + j] - z;
a[i + j] += z;
}
}
vector<double> conv(const vector<double>& a, const vector<double>& b) {
if (a.empty() || b.empty()) return {};
vector<double> res((long long)(a).size() + (long long)(b).size() - 1);
long long L = 32 - __builtin_clz((long long)(res).size()), n = 1 << L;
vector<complex<double>> in(n), out(n);
copy(begin(a), end(a), begin(in));
for (long long i = 0; i < ((long long)(b).size()); ++i) in[i].imag(b[i]);
fft(in);
for (complex<double>& x : in) x *= x;
for (long long i = 0; i < (n); ++i) out[i] = in[-i & (n - 1)] - conj(in[i]);
fft(out);
for (long long i = 0; i < ((long long)(res).size()); ++i)
res[i] = imag(out[i]) / (4 * n);
return res;
}
const long long N = 2e5 + 5;
long long n, x, y, q;
long long solveTestCase() {
cin >> n >> x >> y;
vector<double> a(x + 1), b(x + 1);
for (long long i = 0; i < n + 1; i++) {
long long temp;
cin >> temp;
a[temp] = 1.0;
b[x - temp] = 1.0;
}
vector<double> c = conv(a, b);
cin >> q;
while (q--) {
long long l, ans = -1;
cin >> l;
{
long long temp = l / 2 - y;
if (temp > 0 && temp + x < c.size() && c[temp + x] > 1e-1) {
ans = l;
goto label;
}
}
for (long long i = 1; i * i <= l; i++) {
if (l % i) continue;
long long i_ = l / i;
if (i_ % 2) continue;
long long temp = i_ / 2 - y;
if (temp <= 0) continue;
if (temp + x < c.size() && c[temp + x] > 1e-1) {
ans = 2 * (temp + y);
goto label;
}
}
for (long long i = ceil(sqrt(l)); i >= 1; i--) {
if (l % i || i % 2) continue;
long long temp = i / 2 - y;
if (temp <= 0) continue;
if (temp + x < c.size() && c[temp + x] > 1e-1) {
ans = 2 * (temp + y);
break;
}
}
label:;
cout << ans << " ";
}
return 0;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(12);
long long t = 1;
while (t--) solveTestCase();
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n == 1) {
cout << 0 << '\n';
return 0;
}
vector<int> primes;
vector<int> mark(1001);
for (int i = 2; i <= 1000; i++) {
if (mark[i] == 1) continue;
for (int j = i * i; j <= 1000; j += i) mark[j] = 1;
}
for (int i = 2; i < mark.size(); i++) {
if (mark[i] == 0) primes.push_back(i);
}
vector<int> ctr(primes.size());
vector<int> ret;
for (int i = 2; i <= n; i++) {
int x = i;
for (int j = 0; j < primes.size(); j++) {
int temp = 0;
if (primes[j] >= i) break;
while (temp < ctr[j] && x % primes[j] == 0) {
x /= primes[j];
temp++;
}
}
if (x > 1) {
ret.push_back(i);
for (int j = 0; j < primes.size(); j++) {
if (primes[j] == x) {
ctr[j]++;
break;
}
}
}
}
cout << ret.size() << '\n';
for (int i = 0; i < ret.size(); i++) {
cout << ret[i] << ' ';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a, x, b, y;
bool solve() {
int count = 0;
while (a != x && b != y) {
count++;
if (a == n)
a = 1;
else
a++;
if (b == 1)
b = n;
else
b--;
if (a == b) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> a >> x >> b >> y;
if (solve())
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int k;
scanf("%d", &k);
int tot = 0;
for (int i = 1; i <= 7; ++i) {
scanf("%d", a + i);
tot += a[i];
}
int ans = 7 * k;
int btot = tot;
if (k <= tot) {
for (int i = 1; i <= 7; ++i) {
for (int j = i; j <= 7; ++j) {
int res = 0;
for (int m = i; m <= j; ++m) {
res += a[m];
}
if (res >= k) ans = min(ans, j - i + 1);
}
}
}
for (int i = 1; i <= 7; ++i) {
int atot = 0;
for (int j = 0; j <= 7; ++j) {
atot += a[j];
int rest = k - btot - atot;
if (rest < 0) break;
int tans = 7 - i + 1 + j;
tans += 7 * (rest / tot + (rest % tot != 0));
ans = min(ans, tans);
}
btot -= a[i];
}
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y, z, w, d, k, t, p, ans, r, l, a[1000100];
bool h[1000100];
set<long long> s[2];
int main() {
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> y;
if (a[y] >= a[x]) a[y]++;
if (y == x) {
if (a[z] < a[y]) p = 1;
} else {
if (a[y] >= a[z]) {
z = y;
}
}
}
if (p == 1) return cout << -1, 0;
cout << z;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> prime;
const int N = 1e6 + 5;
bool notp[2 * N];
int cnt[2 * N];
long long cnt2[2 * N];
int query(int ta[], int l, int r) {
int res = ta[r];
if (l - 1 >= 0) res -= ta[l - 1];
return res;
}
long long query(long long ta[], int l, int r) {
long long res = ta[r];
if (l - 1 >= 0) res -= ta[l - 1];
return res;
}
int main() {
for (int i = 2; i < N; i++)
if (!notp[i]) {
prime.push_back(i);
for (long long j = 1LL * i * i; j < N; j += i) notp[j] = true;
}
int n;
long long up, del;
cin >> n >> del >> up;
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
cnt[t]++;
cnt2[t] += t;
}
for (int i = 1; i < 2 * N; i++) {
cnt[i] += cnt[i - 1];
cnt2[i] += cnt2[i - 1];
}
long long ans = LLONG_MAX;
for (int i : prime) {
long long res = 0;
for (int j = i; j < N + i; j += i) {
pair<int, int> t(max(j - i + 1LL, j - del / up), j - 1);
if (t.first <= t.second) {
res += (1LL * query(cnt, t.first, t.second) * j -
query(cnt2, t.first, t.second)) *
up;
}
if (t.first - 1 >= j - i + 1) {
res += del * query(cnt, j - i + 1, t.first - 1);
}
}
ans = min(ans, res);
}
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_L = 1e5;
char buf[MAX_L + 1], s1[MAX_L + 1], s2[MAX_L + 1], t1[MAX_L + 1], t2[MAX_L + 1];
int ds[10], ts[2][10];
void init() { scanf("%[^\n]%*c", buf); }
void prn(int key) {
const int L = strlen(buf);
for (int i = 0; i < 10; i++) {
ts[0][i] = ds[i];
ts[1][i] = ds[i];
}
int p = 0;
ts[0][key]--;
ts[1][(10 - key) % 10]--;
s1[p] = key + '0';
s2[p++] = (10 - key) % 10 + '0';
for (int i = 0; i < L; i++) {
bool update = false;
for (int i = 0; i < 10; i++) {
if (ts[0][i] > 0 && ts[1][9 - i] > 0) {
ts[0][i]--;
ts[1][9 - i]--;
s1[p] = i + '0';
s2[p++] = 9 - i + '0';
update = true;
break;
}
}
if (!update) {
break;
}
}
int q = 0;
for (; ts[0][0] > 0 && ts[1][0] > 0;) {
ts[0][0]--;
ts[1][0]--;
t1[L - 1 - q] = t2[L - 1 - q] = '0';
q++;
}
for (int i = 0; i < p; i++) {
t1[L - 1 - q] = s1[i];
t2[L - 1 - q++] = s2[i];
}
while (q < L) {
for (int i = 9; i >= 0; i--) {
if (ts[0][i] > 0) {
ts[0][i]--;
t1[L - 1 - q] = i + '0';
break;
}
}
for (int i = 9; i >= 0; i--) {
if (ts[1][i] > 0) {
ts[1][i]--;
t2[L - 1 - q++] = i + '0';
break;
}
}
}
puts(t1);
puts(t2);
}
int check(int x) {
const int L = strlen(buf);
for (int i = 0; i < 10; i++) {
ts[0][i] = ds[i];
ts[1][i] = ds[i];
}
int ans = 1;
if (--ts[0][x] < 0) {
return -1;
}
if (--ts[1][(10 - x) % 10] < 0) {
return -1;
}
for (int i = 0; i < L; i++) {
bool update = false;
for (int i = 0; i < 10; i++) {
if (ts[0][i] > 0 && ts[1][9 - i] > 0) {
ts[0][i]--;
ts[1][9 - i]--;
update = true;
ans++;
break;
}
}
if (!update) {
break;
}
}
return ans + min(ts[0][0], ts[1][0]);
}
void solve() {
for (int i = 0; buf[i]; i++) {
ds[buf[i] - '0']++;
}
if (0)
for (int i = 0; i < 10; i++) {
printf("%d\n", ds[i]);
}
int best = -1, key = -1;
for (int i = 1; i < 10; i++) {
int score = check(i);
if (best < score) {
best = score;
key = i;
}
}
if (key > 0) {
prn(key);
} else {
const int L = strlen(buf);
sort(buf, buf + L);
reverse(buf, buf + L);
puts(buf);
puts(buf);
}
}
int main() {
init();
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, i, j;
cin >> n;
long long a[n][2], b[n][2];
for (long long i = 0; i < n; i++)
for (long long j = 0; j < 2; j++) {
cin >> a[i][j];
b[i][j] = n - 1;
}
map<long long, long long> m;
for (long long i = 0; i < n; i++) {
m[a[i][0]]++;
}
for (long long i = 0; i < n; i++) {
b[i][1] -= m[a[i][1]];
b[i][0] += m[a[i][1]];
}
for (long long i = 0; i < n; i++)
for (long long j = 0; j < 2; j++) {
cout << b[i][j] << " ";
if (j == 1) cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int &a, int &b) { return a > b ? true : false; }
long long com(long long a, long long b) {
if (a % b == 0) return b;
return com(b, a % b);
}
int main() {
int n;
int a[100000 + 9];
while (1 == scanf("%d", &n)) {
long long sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += (long long)a[i];
}
sort(a, a + n, cmp);
long long tmp = a[0] - a[1];
long long sigma = tmp;
for (int i = 2; i < n; i++) {
tmp += (long long)i * (a[i - 1] - a[i]);
sigma += tmp;
}
sigma *= (long long)2;
sigma += sum;
long long c = com(sigma, n);
printf("%I64d %I64d\n", sigma / c, (long long)n / c);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, l, sum = 0, flag = 0, t, a[1000000], ans = 0;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long double summ = 0.0;
cin >> n >> ans;
for (int i = 0; i < (1 << n); i++) {
cin >> a[i];
summ += a[i];
}
cout << fixed << setprecision(9) << (1.0l * summ / (1LL << n)) << '\n';
while (ans--) {
cin >> j >> k;
summ -= a[j];
a[j] = k;
summ += a[j];
cout << fixed << setprecision(9) << (1.0l * summ / (1LL << n)) << '\n';
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long int ans = 0;
int n, l, dp[105][3105][5];
vector<pair<int, int> > boards;
long long int solve(int prevIndex, int currTotalLength, int isRotated);
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
boards.push_back(make_pair(a, b));
}
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
if (boards[i].first != boards[i].second) {
ans += solve(i, boards[i].first, 0);
ans += solve(i, boards[i].second, 1);
} else
ans += solve(i, boards[i].first, 0);
}
cout << ans % 1000000007 << endl;
return 0;
}
long long int solve(int currIndex, int currTotalLength, int isRotated) {
if (currTotalLength > l) return 0;
if (currTotalLength == l) return 1;
if (dp[currIndex][currTotalLength][isRotated] != -1) {
return dp[currIndex][currTotalLength][isRotated];
}
long long int counter = 0;
for (int i = 0; i < n; i++) {
if (i != currIndex) {
if (boards[i].first != boards[i].second) {
if (isRotated == 0) {
if (boards[i].first == boards[currIndex].second)
counter += solve(i, currTotalLength + boards[i].first, 0);
else if (boards[i].second == boards[currIndex].second)
counter += solve(i, currTotalLength + boards[i].second, 1);
} else {
if (boards[i].first == boards[currIndex].first)
counter += solve(i, currTotalLength + boards[i].first, 0);
else if (boards[i].second == boards[currIndex].first)
counter += solve(i, currTotalLength + boards[i].second, 1);
}
} else {
if (isRotated == 0) {
if (boards[i].first == boards[currIndex].second)
counter += solve(i, currTotalLength + boards[i].first, 0);
} else {
if (boards[i].first == boards[currIndex].first)
counter += solve(i, currTotalLength + boards[i].first, 0);
}
}
}
}
return dp[currIndex][currTotalLength][isRotated] = counter % 1000000007;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 + 1000;
const int MAXT = MAXN * MAXN;
const long long MOD = 998244353LL;
int arr[MAXN][MAXN], N, M, sz;
pair<int, pair<int, int>> all[MAXT];
long long mul(long long a, long long b) { return (a * b) % MOD; }
void add(long long& a, long long b) {
a += b;
while (a >= MOD) a -= MOD;
while (a < 0) a += MOD;
}
long long fpow(long long base, long long exp) {
long long ans = 1LL, power = base;
while (exp) {
if (exp & 1) ans = mul(ans, power);
power = mul(power, power);
exp >>= 1;
}
return ans;
}
long long pre[MAXT];
long long solve(int r, int c) {
long long tot = 0LL;
long long xsq = 0LL, ysq = 0LL, xs = 0LL, ys = 0LL, x, y;
for (int j, i = 0; i < sz; i = j) {
long long fp = fpow(i, MOD - 2LL);
for (j = i; j < sz && all[j].first == all[i].first; ++j) {
tie(x, y) = all[j].second;
if (i) {
pre[j] = tot;
add(pre[j], xsq);
add(pre[j], ysq);
add(pre[j], mul(mul(-2LL, x), xs));
add(pre[j], mul(mul(-2LL, y), ys));
pre[j] = mul(pre[j], fp);
add(pre[j], mul(x, x));
add(pre[j], mul(y, y));
} else
pre[j] = 0LL;
if (x == r && y == c) return pre[j];
}
for (int k = i; k < j; ++k) {
tie(x, y) = all[k].second;
add(xs, x);
add(ys, y);
add(xsq, mul(x, x));
add(ysq, mul(y, y));
add(tot, pre[k]);
}
}
assert(false);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
sz = 0;
cin >> N >> M;
for (int i = (int)0; i < (int)N; ++i)
for (int j = (int)0; j < (int)M; ++j) {
cin >> arr[i][j];
all[sz++] = {arr[i][j], {i, j}};
}
int R, C;
cin >> R >> C;
sort(all, all + sz,
[](const pair<int, pair<int, int>>& p,
const pair<int, pair<int, int>>& q) -> bool {
return p.first < q.first;
});
cout << solve(R - 1, C - 1);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 5;
int a[maxn];
int low[maxn], has[maxn];
int ans[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
low[i] = n - i;
has[i] = a[i] - low[i];
}
sort(has, has + n);
for (int i = 0; i < n; i++) {
ans[i] = low[i] + has[i];
if (i > 0 && ans[i] < ans[i - 1]) {
printf(":(\n");
return 0;
}
}
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
bool arr[1000009] = {0};
void sieve() {
arr[0] = 1;
arr[1] = 1;
for (int i = 2; i < 1000009; i++) {
if (arr[i] == 0) {
for (int j = i * 2; j < 1000009; j += i) {
arr[j] = 1;
}
}
}
}
int main() {
int n, m, index = 1;
cin >> n >> m;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
for (int j = 0; j < m; j++) {
cout << '#';
}
} else {
if (index == i || i == index + 4) {
for (int j = 0; j < m; j++) {
if (j == m - 1) {
cout << '#';
} else {
cout << '.';
}
}
index = i;
} else {
for (int j = 0; j < m; j++) {
if (j == 0) {
cout << '#';
} else {
cout << '.';
}
}
}
}
cout << endl;
}
}
| 0 |
//CLOCKS_PER_SEC
using namespace std;
#include<bits/stdc++.h>
#define sqr(x) 1ll*(x)*(x)
//#define sort stable_sort
#define ll long long
#define mk make_pair
#define pb push_back
#define in insert
#define mtr(x,y,z) mk(mk(x,y),z)
#define fi first
#define se second
#define lch(x) ((x)<<1)
#define rch(x) (((x)<<1)|1)
#define all(x) (x).begin(),(x).end()
#define titose CLOCKS_PER_SEC
#define fpi(x) freopen(x,"r",stdin);
#define fpo(x) freopen(x,"w",stdout);
#define fprio fpi("in.txt");fpo("out.txt");
#define fast ios_base::sync_with_stdio(false);
inline void read(int &x){int v=0,f=1;char c=getchar();while (!isdigit(c)&&c!='-') c=getchar();if (c=='-') f=-1; else v=(c&15);while (isdigit(c=getchar())) v=(v<<1)+(v<<3)+(c&15);x=v*f;}
inline void read(ll &x){ll v=0ll,f=1ll;char c=getchar();while (!isdigit(c)&&c!='-') c=getchar();if (c=='-') f=-1; else v=(c&15);while (isdigit(c=getchar())) v=(v<<1)+(v<<3)+(c&15);x=v*f;}
inline void readc(char &x){char c;while (((c=getchar())==' ')||c=='\n');x=c;}
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vl vector<ll>
#define si set<int>
//#define sl set<ll>
#define mii map<int,int>
#define mll map<ll,ll>
#define msi map<string,int>
#define msl map<string,ll>
#define piii pair<int,pii >
#define piipi pair<pii,int>
#define plll pair<ll,pll >
#define pllpl pair<pll,ll>
#define pqi priority_queue<int>
#define pql priority_queue<ll>
#define npqi priority_queue<int,vector<int>,greater<int> >
#define npql priority_queue<ll,vector<ll>,greater<ll> >
#define forup(i,a,b) for ((i)=(a);(i)<=(b);(i)++)
#define fordo(i,a,b) for ((i)=(a);(i)>=(b);(i)--)
#define rep(i,x) forup ((i),1,(x))
#define repd(i,x) fordo ((i),(x),1)
#define rep0(i,x) forup ((i),0,((int)(x))-1)
#define rep0d(i,x) fordo ((i),((int)(x))-1,0)
#define itr iterator
#define fe(itcalc,c) for(__typeof((c).begin()) itcalc=(c).begin();itcalc!=(c).end();itcalc++)
#define NO {cout<<"NO";return 0;}
#define YES {cout<<"YES";return 0;}
#define y0 y000000000000000000000000000
#define y1 y111111111111111111111111111
#define j0 j000000000000000000000000000
#define j1 j111111111111111111111111111
#define cl0(a) memset((a),(0),(sizeof((a))))
#define clz(a) memset((a),(0x16),(sizeof((a))))
#define clf(a) memset((a),(-(0x16)),(sizeof((a))))
#define inf 0x3bbbbbbb
#define lnf 0x2bbbbbbbbbbbbbbbll
//#define sqrt divi
#define p2(i) (1ll<<(i))
#define readi read
#define readll read
/*************************************************/
int n,m,i,j,a[1005][1005];
int s1[1005];ll s2[1005];
pair<int,int> d[1005];
int main()
{
read(n);read(m);rep(i,m)rep(j,n)read(a[i][j]);
rep(i,m)rep(j,n){s1[i]+=a[i][j];s2[i]+=1ll*a[i][j]*a[i][j];}
rep(i,m-1)d[i]=mk(s1[i+1]-s1[i],i);sort(d+1,d+m);
int pos=max(d[1].se,d[m-1].se),dlt=(pos==d[1].se?d[1].fi-d[2].fi:d[m-1].fi-d[2].fi);
rep(i,m-2) if(i!=pos&&i+1!=pos&&i+2!=pos) break;
int x1=i,x2=i+1,x3=i+2;
ll excpt=(s2[x1]*(pos-x2)*(pos-x3)-2*s2[x2]*(pos-x1)*(pos-x3)+s2[x3]*(pos-x1)*(pos-x2))/2;
int val=-(s2[pos]-excpt-1ll*dlt*dlt)/dlt/2;
cout<<pos-1<<' '<<val<<endl;
return 0;
} | 22 |
#include <bits/stdc++.h>
using namespace std;
long long* reverse(long long* b, int n) {
long long* b2 = new long long[n];
for (int i = 0; i < n; i++) b2[i] = b[n - 1 - i];
return b2;
}
void print(vector<char> v) {
cout << "SMALL" << endl << v.size() << endl;
char s[200000 + 1];
int n = v.size();
for (int i = n - 1; i >= 0; i--) s[n - 1 - i] = v[i];
s[n] = '\0';
printf("%s\n", s);
return;
}
bool increasing(long long* b, int n) {
for (int i = 1; i < n; i++)
if (b[i] <= b[i - 1]) return false;
return true;
}
void f(long long* a, long long* b, int n) {
vector<char> v;
while (true) {
long long* b2 = reverse(b, n);
if (memcmp(a, b, n * sizeof(long long)) == 0) {
delete[] b2;
print(v);
return;
}
if (memcmp(a, b2, n * sizeof(long long)) == 0) {
delete[] b2;
v.push_back('R');
print(v);
return;
}
if (increasing(b2, n)) {
memcpy(b, b2, n * sizeof(long long));
v.push_back('R');
} else if (!increasing(b, n)) {
cout << "IMPOSSIBLE" << endl;
delete[] b2;
return;
}
delete[] b2;
for (int i = n - 1; i >= 1; i--) b[i] -= b[i - 1];
v.push_back('P');
}
}
void f2(long long* a, long long* b) {
long long cont = 0;
long long A[2];
long long B[2];
A[0] = a[0];
A[1] = a[1];
B[0] = b[0];
B[1] = b[1];
sort(a, a + 2);
while (true) {
long long* b2 = reverse(b, 2);
if (memcmp(a, b, 2 * sizeof(long long)) == 0 ||
memcmp(a, b2, 2 * sizeof(long long)) == 0) {
delete[] b2;
if (cont > 200000)
cout << "BIG" << endl << cont << endl;
else
f(A, B, 2);
return;
}
delete[] b2;
sort(b, b + 2);
if (b[0] == b[1] || a[1] > b[1]) {
cout << "IMPOSSIBLE" << endl;
return;
}
if (a[0] == b[0]) {
long long x = (b[1] - a[1]) / b[0];
if (b[1] == a[1] + b[0] * x) {
cont += x;
b[1] = a[1];
continue;
} else {
cout << "IMPOSSIBLE" << endl;
return;
}
}
cont += b[1] / b[0];
b[1] = b[1] % b[0];
if (b[1] == 0) {
cout << "IMPOSSIBLE" << endl;
return;
}
}
}
void f3(long long* a, long long* b) {
long long cont = 0;
long long A[3];
long long B[3];
A[0] = a[0];
A[1] = a[1];
A[2] = a[2];
B[0] = b[0];
B[1] = b[1];
B[2] = b[2];
while (true) {
long long* b2 = reverse(b, 3);
if (memcmp(a, b, 3 * sizeof(long long)) == 0 ||
memcmp(a, b2, 3 * sizeof(long long)) == 0) {
delete[] b2;
if (cont > 200000)
cout << "BIG" << endl << cont << endl;
else
f(A, B, 3);
return;
}
delete[] b2;
if (b[0] > b[1] && b[1] > b[2]) swap(b[0], b[2]);
if (b[0] >= b[1] || b[1] >= b[2] || a[1] > b[1]) {
cout << "IMPOSSIBLE" << endl;
return;
}
long long x = (b[1] - a[1]) / b[0];
if (x == 0 || 2 * b[2] / x < 2 * b[1] - b[0] * (x - 1)) {
cout << "IMPOSSIBLE" << endl;
return;
}
cont += x;
b[2] -= b[1] * x - b[0] * x * (x - 1) / 2;
b[1] -= b[0] * x;
if (b[2] == 0) {
cout << "IMPOSSIBLE" << endl;
return;
}
}
}
int main() {
int n;
long long a[200000];
long long b[200000];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
if (n == 1) {
if (a[0] == b[0])
cout << "SMALL" << endl << 0 << endl << endl;
else
cout << "IMPOSSIBLE" << endl;
} else if (n == 2)
f2(a, b);
else if (n == 3)
f3(a, b);
else
f(a, b, n);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long int tt;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
long long int l1, r1, l2, r2;
cin >> l1 >> r1 >> l2 >> r2;
if (l2 < l1) {
swap(l1, l2);
swap(r1, r2);
}
long long int ans = 1e18;
for (long long int i = 1; i <= n; i++) {
if (r1 >= l2) {
if (r2 <= r1) {
long long int ans1 = 0;
long long int x = (r2 - l2) * i;
long long int k1 = k;
k1 = max(0LL, k1 - x);
x = ((l2 - l1) + (r1 - r2)) * i;
ans1 = ans1 + min(k1, x);
k1 = k1 - min(k1, x);
ans1 = ans1 + k1 * 2;
ans = min(ans, ans1);
} else {
long long int ans1 = 0;
long long int x = (r1 - l2) * i;
long long int k1 = k;
k1 = max(0LL, k1 - x);
x = ((l2 - l1) + (r2 - r1)) * i;
ans1 = ans1 + min(k1, x);
k1 = k1 - min(k1, x);
ans1 = ans1 + k1 * 2;
ans = min(ans, ans1);
}
} else {
long long int ans1 = 0;
ans1 = ans1 + (l2 - r1) * i;
long long int k1 = k;
long long int x;
x = (r2 - l1) * i;
ans1 = ans1 + min(x, k1);
k1 = k1 - min(k1, x);
ans1 = ans1 + k1 * 2;
ans = min(ans, ans1);
}
}
cout << ans << endl;
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long int po(long long int n, long long int k) {
long long int ans = 1;
for (int i = 0; i < k; i++) ans *= n;
return ans;
}
int dp[1000006], prs[1000006];
int main() {
int n, k, t;
cin >> t;
while (t--) {
string s;
cin >> n >> k >> s;
int f = min(n + k, 1000000);
vector<int> v(n + 1);
for (int i = 0; i <= f; i++) prs[i] = dp[i] = 0;
for (int i = 1; i <= n; i++) {
v[i] = s[i - 1] - '0';
prs[i] += prs[i - 1] + v[i];
}
int mn = 1000000007;
for (int i = n; i >= 1; i--) {
int ans1, ans2;
if (i + k > n) {
ans1 = prs[n] - prs[i];
} else {
ans1 = prs[i + k - 1] - prs[i];
}
if (i + k <= n) ans1 += dp[i + k];
ans2 = prs[n] - prs[i] + v[i];
dp[i] = min(ans1 + abs(v[i] - 1), ans2);
}
for (int i = 1; i <= n; i++) {
dp[i] += prs[i - 1];
mn = min(mn, dp[i]);
}
printf("%d", mn);
printf("\n");
}
}
| 11 |
#include <bits/stdc++.h>
long long min(long long a, long long b) {
if (a < b) {
return (a);
} else {
return (b);
}
}
long long h[110000];
long long l[110000];
long long r[110000];
int main() {
long long a, b, c, d, M = 0, can;
scanf("%lld", &a);
for (b = 0; b < a; b++) {
scanf("%lld", &h[b]);
}
l[0] = 1;
for (b = 1; b < a; b++) {
l[b] = min(h[b], l[b - 1] + 1);
}
r[a - 1] = 1;
for (b = a - 2; b >= 0; b--) {
r[b] = min(h[b], r[b + 1] + 1);
}
for (b = 0; b < a; b++) {
can = min(r[b], l[b]);
if (can > M) {
M = can;
}
}
printf("%lld\n", M);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const int MOD = 998244353;
int n, ans;
int c[N], p[N];
int dp[N][N], sm[N][N];
int dfs(int x, int y) {
int C = sm[x][y];
if (dp[x][y] != -1) return dp[x][y];
if (x == y) return dp[x][y] = 1;
if (x > y) return dp[x][y] = 0;
dp[x][y] = 0ll;
int lft = 2ll * dfs(x, p[C] - 1), rht = 2ll * dfs(p[C] + 1, y);
for (int i = x + 1; i <= p[C] - 1; i++)
lft = (1ll * lft + 1ll * dfs(i, p[C] - 1) * dfs(x, i - 1) % MOD) % MOD;
for (int i = p[C] + 1; i <= y - 1; i++)
rht = (1ll * rht + 1ll * dfs(p[C] + 1, i) * dfs(i + 1, y) % MOD) % MOD;
if (!lft) lft++;
if (!rht) rht++;
ans = (1ll * lft * rht) % MOD;
return dp[x][y] = ans;
}
int main() {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) dp[i][j] = -1;
scanf("%d%d", &n, &n);
for (int i = 1; i <= n; i++) scanf("%d", c + i);
for (int i = 1; i <= n; i++) {
int mn = c[i];
p[c[i]] = i;
for (int j = i; j <= n; j++) {
mn = min(mn, c[j]);
sm[i][j] = mn;
}
}
printf("%d\n", dfs(1, n));
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int INF = 1e9;
int main() {
int T = read();
while (T--) {
int N = read(), R = INF, L = -INF;
for (int i = 1; i <= N; ++i) {
int l = read(), r = read();
R = min(R, r);
L = max(L, l);
}
printf("%d\n", R <= L ? L - R : 0);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
string s;
cin >> m >> s;
n = s.size();
vector<int> vi(26, 0);
for (int i = 0; i < n; ++i) {
s[i] -= 'a';
++vi[s[i]];
}
for (int i = 0; i < 26; ++i) {
int tcnt = 0;
map<int, int> mp;
for (int j = 0; j < m; ++j) {
if (s[j] <= i) {
mp[s[j]] = j;
}
}
int mx = 0;
for (int j = 0; j + m - 1 < n; ++j) {
if (mp.size() == 0) {
tcnt = -1;
break;
}
if (j >= mx) {
if (mp.begin()->first == i) {
++tcnt;
}
mx = mp.begin()->second + 1;
}
if (mp.count(s[j]) && mp[s[j]] == j) {
mp.erase(s[j]);
}
if (j + m < n && s[j + m] <= i) {
mp[s[j + m]] = j + m;
}
}
if (tcnt != -1) {
while (tcnt--) {
cout << (char)('a' + i);
}
break;
} else {
while (vi[i]--) {
cout << (char)('a' + i);
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string code;
cin >> code;
string table[10];
for (int i = 0; i < 10; i++) cin >> table[i];
for (int i = 0; i < 8; i++) {
char temp[11];
code.copy(temp, 10, i * 10);
temp[10] = 0;
for (int j = 0; j < 10; j++)
if (table[j] == (string)temp) {
cout << j;
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long add(long long a, long long b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
inline long long sub(long long a, long long b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
inline long long mul(long long a, long long b) {
return (long long)((long long)a * b % 1000000007);
}
long long min(long long a, long long b) { return a > b ? b : a; }
long long max(long long a, long long b) { return a > b ? a : b; }
long long n, a[200000], x, y;
long long val(long long ind) {
if (ind >= n || ind < 0) return 2e9;
return a[ind];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> x >> y;
for (int i = 0; i < n; i += 1) cin >> a[i];
for (int i = 0; i < n; i += 1) {
bool b = 1;
for (int j = -x; j <= y; j++) {
if (!j) continue;
if (val(i + j) <= val(i)) {
b = 0;
break;
}
}
if (b) {
cout << i + 1 << "\n";
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int mx = 0;
int px, nx;
int x;
int l = 0, r = 0;
cin >> n;
cin >> x;
n--;
px = x;
r++;
while (n--) {
cin >> x;
if (x == px) {
r++;
} else {
px = x;
l = r;
r = 1;
}
if (r <= l && r > mx) mx = r;
}
cout << mx * 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, ans = 0;
char c1, c2;
bool opp(char c1, char c2) {
return (c1 + c2 == 'R' + 'L' || c1 + c2 == 'D' + 'U');
}
int main() {
cin >> n >> s;
c1 = ' ', c2 = ' ';
for (int i = 0; i < n; i++) {
if (s[i] == c1 || s[i] == c2) continue;
if (c1 == ' ')
c1 = s[i];
else if (c2 == ' ') {
if (opp(c1, s[i])) {
ans++;
c1 = s[i];
} else
c2 = s[i];
} else {
ans++;
c1 = s[i];
c2 = ' ';
}
}
cout << ans + 1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void Read(T &x) {
int f = 1;
char t = getchar();
while (t < '0' || t > '9') {
if (t == '-') f = -1;
t = getchar();
}
x = 0;
while (t >= '0' && t <= '9') {
x = x * 10 + t - '0';
t = getchar();
}
x *= f;
}
const int modulo = 1000000007;
const int maxn = 55;
int n, k;
long long f[maxn][maxn][2], c[maxn][maxn];
void input() { Read(n), Read(k); }
void solve() {
f[1][0][0] = f[0][0][1] = c[0][0] = 1;
for (register int i = 1; i <= n; i++) {
c[i][0] = 1;
for (register int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % modulo;
}
}
for (register int i = 2; i <= n; i++) {
for (register int ls = 0, rs = i - 1; ls <= rs; ls++, rs--) {
for (register int p = 0; p <= k; p++) {
for (register int q = 0; q <= k; q++) {
if (p + q > k) break;
long long mult = (ls == rs) ? c[i - 2][ls - 1] : c[i - 1][ls];
if (ls > 0)
mult = mult * ls % modulo * rs % modulo;
else
mult = mult * rs % modulo;
f[i][p + q][0] = (f[i][p + q][0] + f[ls][p][1] * f[rs][q][1] %
modulo * mult % modulo) %
modulo;
if (p + q + 1 <= k) {
f[i][p + q + 1][1] =
(f[i][p + q + 1][1] +
f[ls][p][1] * f[rs][q][0] % modulo * mult % modulo) %
modulo;
f[i][p + q + 1][1] =
(f[i][p + q + 1][1] +
f[ls][p][0] * f[rs][q][1] % modulo * mult % modulo) %
modulo;
f[i][p + q + 1][1] =
(f[i][p + q + 1][1] +
f[ls][p][0] * f[rs][q][0] % modulo * mult % modulo) %
modulo;
}
}
}
}
}
cout << (f[n][k][0] + f[n][k][1]) % modulo << endl;
}
int main() {
input();
solve();
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v);
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream &operator>>(istream &cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
mt19937 rng(61378913);
void usaco(string filename) {
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
const long double pi = 3.14159265358979323846;
const long long mod = 1000000007;
long long n, m, k, q, l, r, x, y, z;
long long a[1000005];
long long b[1000005];
long long c[1000005];
string second, t;
long long ans = 0;
long long dp[2][10005];
long long iv[5005][2];
set<long long> pts;
long long pt[10005];
void solve(int tc) {
cin >> n;
++n;
cin >> x;
iv[0][0] = iv[0][1] = x;
pts.insert(x);
for (long long i = (1); i < (n); ++i) {
cin >> iv[i][0] >> iv[i][1];
pts.insert(iv[i][0]);
pts.insert(iv[i][1]);
}
int sz = 0;
for (long long x : pts) pt[sz++] = x;
for (long long i = 0; i < (sz); ++i) dp[0][i] = abs(x - pt[i]);
for (long long i = (1); i < (n); ++i) {
int last = (i - 1) % 2, cur = i % 2;
long long rmn = mod * mod, off = 0;
for (long long j = 0; j < (sz); ++j) dp[cur][j] = mod * mod;
for (long long j = 0; j < (sz); ++j) {
if (j) off += pt[j] - pt[j - 1];
rmn = min(rmn, dp[last][j] - off);
dp[cur][j] = min(dp[cur][j], rmn + off);
}
rmn = mod * mod, off = 0;
for (long long j = (sz - 1); j >= 0; --j) {
if (j != sz - 1) off += pt[j + 1] - pt[j];
rmn = min(rmn, dp[last][j] - off);
dp[cur][j] = min(dp[cur][j], rmn + off);
}
for (long long j = 0; j < (sz); ++j) {
long long p = pt[j];
if (p > iv[i][1] || p < iv[i][0]) {
dp[cur][j] += min(abs(p - iv[i][1]), abs(p - iv[i][0]));
}
}
}
ans = mod * mod;
for (long long i = 0; i < (sz); ++i) ans = min(ans, dp[(n - 1) % 2][i]);
cout << ans << '\n';
}
int main() {
{ ios_base::sync_with_stdio(false); }
{
cin.tie(NULL);
cout.tie(NULL);
}
int tc;
tc = 1;
for (int t = 0; t < tc; t++) solve(t);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string ToString(T t) {
stringstream s;
s << t;
return s.str();
}
template <class T>
void ToOther(T& t, string a) {
stringstream s(a);
s >> t;
}
int d, n, m;
vector<pair<int, int> > v;
int main() {
cin >> d >> n >> m;
v.resize(m);
for (int i = 0; i < m; i++) scanf("%d%d", &v[i].first, &v[i].second);
sort((v).begin(), (v).end());
deque<pair<int, int> > q;
long long r = 0;
int gas = n, pos = 0, idx = 0;
v.push_back(pair<int, int>(d, 0));
while (idx < v.size()) {
int before = idx;
while (idx < v.size() && v[idx].first - pos <= gas) {
while (q.size() && q.back().second >= v[idx].second) q.pop_back();
q.push_back(v[idx]);
idx++;
}
if (idx == v.size()) break;
if (idx == before) q.pop_front();
if (q.size() == 0) {
cout << -1 << endl;
return 0;
}
int npos = q.front().first;
int cost = q.front().second;
gas -= (npos - pos);
pos = npos;
int dis = v[idx].first - pos;
int need = min(n - gas, max(0, dis - gas));
r += (long long)need * cost;
gas += need;
}
cout << r << endl;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long m, k;
cin >> n >> m >> k;
long long min = 999999;
for (int i = 1, y; i <= n; i++) {
scanf("%d", &y);
if (min >= y && i % 2 == 1) min = y;
}
if (n % 2 == 0)
cout << 0 << endl;
else if (m < n / 2 + 1)
cout << 0 << endl;
else {
m = m / (n / 2 + 1);
if (min > m * k)
cout << m * k << endl;
else
cout << min << endl;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int k, lvl[100005], viss[100005], dpp[100005], dp[100005],
vis[100005], p[100005], en, st;
vector<long long int> adj[100005], vv;
void dfs(long long int n, long long int kkk) {
vis[n] = 1;
for (auto x : adj[n]) {
if (kkk == x) continue;
if (vis[x] == 1) {
if (lvl[n] - lvl[x] + 1 <= k && lvl[n] >= lvl[x]) {
st = n;
en = x;
}
} else {
p[x] = n;
lvl[x] = lvl[n] + 1;
dfs(x, n);
}
}
}
void dfs1(long long int n, long long int p) {
viss[n] = 1;
for (auto x : adj[n]) {
if (viss[x] == 0) dfs1(x, n);
dp[n] |= dpp[x];
}
if (dp[n] == 0) {
vv.push_back(n);
dpp[n] = 1;
}
}
long long int mm[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, i, a, b, kk, j;
vector<pair<long long int, long long int> > v;
cin >> n >> m >> k;
for (i = 0; i < m; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs1(1, 1);
if (vv.size() >= (k + 1) / 2) {
cout << 1 << endl;
for (j = 0; j < (k + 1) / 2; j++) {
cout << vv[j] << " ";
}
cout << endl;
return 0;
}
cout << 2 << endl;
p[1] = 1;
dfs(1, 1);
kk = st;
cout << lvl[st] - lvl[en] + 1 << endl;
while (1) {
if (kk == en) {
cout << kk;
return 0;
}
cout << kk << " ";
kk = p[kk];
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans = 1, p, z = 0;
int n, pos[105], s = 0, i, t;
cin >> n;
for (i = 0; i < n; i++) {
cin >> t;
if (t == 1) {
pos[s] = i;
s++;
z++;
}
}
if (z == 0)
cout << "0\n";
else if (z == 1)
puts("1");
else {
for (i = 0; i < s - 1; i++) {
p = pos[i + 1] - pos[i];
ans *= p;
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int q, t, x, y;
int a[500000 + 5];
int f[710][710];
void init() {}
void Time_decreasing() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void enter() { scanf("%d\n", &q); }
void solve() {
while (q--) {
scanf("%d %d %d", &t, &x, &y);
if (t == 1) {
a[x] = a[x] + y;
for (int i = 1; i <= 707; i++) {
f[i][x % i] = f[i][x % i] + y;
}
} else {
int res = 0;
if (x > 707) {
for (int i = y; i <= 500000; i = i + x) {
res = res + a[i];
}
printf("%d\n", res);
} else {
printf("%d\n", f[x][y]);
}
}
}
}
int main() {
init();
Time_decreasing();
enter();
solve();
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int k;
char s[110];
bool was[30];
void init() {
scanf("%d", &k);
scanf(" %s ", s);
}
void solve() {
int len = strlen(s);
for (int i = 0; i < (len + 1) / 2; i++)
if (s[i] != '?' && s[len - i - 1] != '?' && s[i] != s[len - i - 1]) {
printf("IMPOSSIBLE");
return;
} else if (s[i] == '?' && s[len - i - 1] != '?')
s[i] = s[len - i - 1];
else if (s[i] != '?' && s[len - i - 1] == '?')
s[len - i - 1] = s[i];
for (int i = 0; i < (len + 1) / 2; i++)
if (s[i] != '?') was[s[i] - 'a'] = true;
int cnt = k - 1;
for (int i = (len + 1) / 2 - 1; i >= 0; i--) {
if (s[i] == '?') {
while (cnt >= 0 && was[cnt]) cnt--;
if (cnt >= 0)
s[i] = s[len - i - 1] = cnt + 'a', cnt--;
else
s[i] = s[len - i - 1] = 'a';
}
}
while (cnt >= 0 && was[cnt]) cnt--;
if (cnt >= 0)
printf("IMPOSSIBLE");
else
printf("%s\n", s);
}
int main() {
init();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int arr[111];
int main() {
int n;
scanf("%d", &n);
arr[0] = 0;
for (int i = (1); i < (n + 1); ++i) scanf("%d", &arr[i]);
int ans = 0;
if (n % 2 == 0 || n == 1) {
printf("-1\n");
return 0;
}
for (int i = n; i >= 1; i -= 2) {
int tmp = max(arr[i], arr[i - 1]);
ans += tmp;
arr[i] = arr[i - 1] = 0;
arr[(i - 1) / 2] = max(0, arr[(i - 1) / 2] - tmp);
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int MAX = 1e5 + 5;
const int MAX_V = 1e3 + 5;
const long long INF = 4e18 + 5;
const double M = 4e18;
using namespace std;
const int MOD = 1e9 + 7;
const double eps = 0.000000001;
int n, m, k, q, idx;
int fa[MAX], who[MAX], in[MAX], out[MAX];
vector<int> edge[MAX];
void dfs(int x) {
in[x] = ++idx;
for (int i = 0; i < edge[x].size(); i++) dfs(edge[x][i]);
out[x] = idx;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (who[y]) fa[x] = who[y];
who[y] = x;
}
for (int i = 1; i <= n; i++) edge[fa[i]].push_back(i);
for (int i = 1; i <= n; i++)
if (!in[i]) dfs(i);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
y = who[y];
if (in[x] <= in[y] && out[x] >= in[y])
printf("%d\n", out[x] - in[x] + 1);
else
printf("0\n");
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = (int)s.size();
if (n <= 3) {
cout << "YES\n" << s;
return 0;
}
int m[26] = {0};
for (int i = 0; i < n; i++) m[s[i] - 'a']++;
int u = 0;
for (int i = 1; i < 26; i++)
if (m[i] > m[u]) u = i;
bool p[1001] = {0};
for (int i = 2; i * i <= 1000; i++)
if (p[i] == false)
for (int j = i * i; j <= 1000; j += i) p[j] = true;
char t[1001];
t[n] = 0;
int q = 0;
for (int i = 1; i <= n; i++) {
if (i == 1 || (i > n / 2 && !p[i])) {
while (q < 26 && (m[q] == 0 || q == u)) q++;
if (q == 26) {
m[u]--;
t[i - 1] = u + 'a';
} else {
m[q]--;
t[i - 1] = q + 'a';
}
} else {
if (m[u] == 0) {
cout << "NO";
return 0;
} else {
m[u]--;
t[i - 1] = u + 'a';
}
}
}
cout << "YES\n" << t;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
long long sgn(double a) { return a < -eps ? -1 : a < eps ? 0 : 1; }
double dis(double x1, double x2, double y1, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
void solve(double a, double b, double c, double &x1, double &x2) {
x1 = (-b + sqrt(b * b - 4.0 * a * c)) / (2.0 * a);
x2 = (-b - sqrt(b * b - 4.0 * a * c)) / (2.0 * a);
}
int main() {
long long R, x1, y1, x2, y2;
cin >> R >> x1 >> y1 >> x2 >> y2;
if (sgn(dis((double)x1, (double)x2, (double)y1, (double)y2) - (double)R) >=
0) {
cout << x1 << " " << y1 << " " << R << endl;
} else {
if (x1 - x2 != 0) {
double k = (double)(y1 - y2) / (double)(x1 - x2);
double b = (double)(x1 * y2 - x2 * y1) / (double)(x1 - x2);
double a1;
double a2;
solve(k * k + 1.0, (2.0 * k * b - 2.0 * x1 - 2.0 * k * y1),
x1 * x1 + b * b - 2 * b * y1 + y1 * y1 - (double)R * R, a1, a2);
double ansa;
if ((x1 > x2 && (double)x1 > a2) || (x2 > x1 && a2 > (double)x1))
ansa = a1;
else
ansa = a2;
double ansb = k * ansa + b;
double ansr;
ansa = (ansa + x2) / 2;
ansb = (ansb + y2) / 2;
ansr = dis(ansa, x2, ansb, y2);
printf("%.12f %.12f %.12f\n", ansa, ansb, ansr);
} else {
if (y1 < y2) {
double ansa = x1;
double ansb = ((double)y1 - (double)R + (double)y2) / 2;
double ansr = y2 - ansb;
printf("%.12f %.12f %.12f\n", ansa, ansb, ansr);
} else if (y1 > y2) {
double ansa = x1;
double ansb = ((double)y1 + (double)R + (double)y2) / 2;
double ansr = ansb - y2;
printf("%.12f %.12f %.12f\n", ansa, ansb, ansr);
} else {
printf("%.12f %.12f %.12f\n", (double)x1, (double)(2.0 * y1 - R) / 2.0,
(double)R / 2.0);
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int result = 6;
for (int i = 0; i < (1000 * 1000); ++i) {
string now;
int x = i;
int a = 0, b = 0;
for (int j = 0; j < (6); ++j) {
now += char(x % 10 + '0');
if (j < 3)
a += x % 10;
else
b += x % 10;
x /= 10;
}
reverse(now.begin(), now.end());
if (a == b) {
int cnt = 0;
for (int j = 0; j < (6); ++j) cnt += now[j] != s[j];
result = min(result, cnt);
}
}
cout << result << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char board[55][55];
void copy(char a[55][55], int row, int col, char b[55][55]) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
a[i][j] = b[i][j];
}
}
}
void dfs(char a[55][55], int row, int col) {
if (a[row][col] != '#')
return;
else {
a[row][col] = '.';
dfs(a, row - 1, col);
dfs(a, row + 1, col);
dfs(a, row, col - 1);
dfs(a, row, col + 1);
}
}
bool check(char b[55][55], int row, int col) {
int count = 0;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (board[i][j] == '#') {
count++;
}
}
}
if (count < 3) {
return false;
}
char a[55][55];
copy(a, row, col, b);
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (a[i][j] == '#') {
dfs(a, i, j);
bool f = true;
for (int m = 0; m < row; m++) {
for (int n = 0; n < col; n++) {
if (a[m][n] == '#') {
f = false;
}
}
}
if (f)
return true;
else
copy(a, row, col, b);
}
}
}
return false;
}
int main() {
int row, col;
cin >> row >> col;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
cin >> board[i][j];
}
}
if (!check(board, row, col)) {
cout << "-1" << endl;
return 0;
}
char a[55][55];
copy(a, row, col, board);
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (a[i][j] == '#') {
a[i][j] = '.';
if (!check(a, row, col)) {
cout << "1" << endl;
return 0;
}
a[i][j] = '#';
}
}
}
cout << "2" << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
inline int in() {
int k = 0;
char ch = getchar();
bool p = 1;
while (ch < '-') ch = getchar();
if (ch == '-') ch = getchar(), p = 0;
while (ch > '-') k = k * 10 + ch - '0', ch = getchar();
return p ? k : -k;
}
const int N = 5e5 + 5;
std::vector<int> G[N << 1];
int tot, o[N];
char s[N];
inline void add(int u, int v) { G[u].push_back(v), G[v].push_back(u); }
void work() {
for (int i = 1; i <= tot; ++i) G[i].clear();
int n = tot = in(), le = 0;
for (int i = 2; i <= n; ++i) add(in(), in());
scanf("%s", s + 1);
for (int i = 1; i <= n; ++i)
if (s[i] == 'W')
add(i, tot + 1), add(tot + 1, tot + 2), add(tot + 1, tot + 3), tot += 3;
for (int i = 1; i <= tot; ++i)
if (G[i].size() >= 4)
return puts("White"), void();
else if (G[i].size() == 1)
++le;
for (int i = 1; i <= tot; ++i)
if (G[i].size() == 3) {
int cnt = 0;
for (int j = 0; j < 3; ++j) cnt += G[G[i][j]].size() >= 2;
if (cnt >= 2) return puts("White"), void();
}
if (le <= 3) return puts("Draw"), void();
puts(tot & 1 ? "White" : "Draw");
}
int main() {
for (int t = in(); t; --t) work();
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
char ch[4507][4507];
const int N = 4507;
bool prime[N];
int p[N], tot;
void init() {
for (int i = 2; i < N; i++) prime[i] = true;
for (int i = 2; i < N; i++) {
if (prime[i]) p[tot++] = i;
for (int j = 0; j < tot && i * p[j] < N; j++) {
prime[i * p[j]] = false;
if (i % p[j] == 0) break;
}
}
}
int sum[4507][4507];
int n, m;
int ac(int k) {
memset(sum, 0, sizeof sum);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum[i / k][j / k] += ch[i][j] - '0';
}
}
int ret = 0;
for (int i = 0; i <= (n - 1) / k; i++) {
for (int j = 0; j <= (m - 1) / k; j++) {
ret += min(sum[i][j], k * k - sum[i][j]);
}
}
return ret;
}
int main() {
init();
scanf("%d%d", &n, &m);
int ans = n * m;
for (int i = 0; i < n; i++) {
scanf("%s", ch[i]);
for (int j = 0; j < m; j++) {
}
}
for (int i = 0; i < 8; i++) {
ans = min(ans, ac(p[i]));
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
void smin(long long &x, long long y) { x = min(x, y); }
void smax(long long &x, long long y) { x = max(x, y); }
const long long MAXN = 1e5 + 100;
long long n, m;
vector<long long> adj[MAXN];
vector<pair<long long, pair<long long, long long> > > res;
vector<long long> can[MAXN];
long long h[MAXN];
bool mark[MAXN];
void dfs(long long v, long long par = -1, long long he = 0) {
mark[v] = true;
h[v] = he;
if (par > -1) can[v].push_back(par);
for (auto u : adj[v]) {
if (u == par) continue;
if (!mark[u])
dfs(u, v, ++he);
else if (h[u] < h[v])
can[v].push_back(u);
}
while (can[v].size() >= 2) {
long long first = can[v].back();
can[v].pop_back();
long long sec = can[v].back();
can[v].pop_back();
res.push_back({first, {v, sec}});
}
if (can[v].size() && par > -1) can[v].pop_back(), can[par].push_back(v);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
adj[--u].push_back(--v), adj[v].push_back(u);
}
if (m & 1) return cout << "No solution", 0;
dfs(0);
for (auto x : res)
cout << ++x.first << " " << ++x.second.first << " " << ++x.second.second
<< endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int i, i0, n, m;
char s[5005], t[5005];
bool chk(int x) {
for (int i = 1; i <= x; i++) t[n - x + i] = s[i];
for (int i = x + 1; i <= n; i++) t[i - x] = s[i];
bool f = 0;
for (int i = 1; i <= n; i++) {
if (s[i] != t[i]) f = 1;
}
if (!f) return 0;
for (int i = 1; i <= n / 2; i++) {
if (t[i] != t[n - i + 1]) return 0;
}
return 1;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
if (n % 2) {
for (i = 1; i <= n; i++) {
if (i == n / 2 + 1) continue;
if (s[i] != s[1]) {
for (i = 2; i < n; i++) {
if (chk(i)) {
printf("1\n");
return 0;
}
}
printf("2\n");
return 0;
}
}
printf("Impossible\n");
return 0;
} else {
for (i = 1; i <= n; i++) {
if (s[i] != s[1]) {
for (i = 2; i < n; i++) {
if (chk(i)) {
printf("1\n");
return 0;
}
}
printf("2\n");
return 0;
}
}
printf("Impossible\n");
return 0;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long inff = 0x3f3f3f3f3f3f3f3f;
long long n, a[200008], mi = 1, x, y, z, m, ans;
struct as {
long long u, v, d;
} b[500008];
int fa[200008];
bool cmp(as a, as b) { return a.d < b.d; }
int fid(int x) {
int a = x, b;
while (fa[a] != a) a = fa[a];
while (x != a) b = fa[x], fa[x] = a, x = b;
return a;
}
int main() {
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i(1); i <= (n); ++i) {
scanf("%lld", &a[i]), fa[i] = i;
if (a[i] < a[mi]) mi = i;
}
for (int i(1); i <= (m); ++i)
scanf("%lld", &b[i].u), scanf("%lld", &b[i].v), scanf("%lld", &b[i].d);
for (int i(1); i <= (n); ++i)
b[++m].u = i, b[m].v = mi, b[m].d = a[mi] + a[i];
sort(b + 1, b + m + 1, cmp);
for (int i(1); i <= (m); ++i) {
x = fid(b[i].u), y = fid(b[i].v);
if (x != y) fa[x] = y, ans += b[i].d;
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int ar[100100];
int din[100100];
int ifpoeifoprfirofi[400100];
int jfdslkgjlkfdgjdl[400100];
int n;
void build_min(int v, int l, int r) {
if (l == r)
ifpoeifoprfirofi[v] = l;
else {
int m = (l + r) / 2;
build_min((v << 1), l, m);
build_min((v << 1) + 1, m + 1, r);
if (ar[ifpoeifoprfirofi[v << 1]] < ar[ifpoeifoprfirofi[(v << 1) + 1]])
ifpoeifoprfirofi[v] = ifpoeifoprfirofi[v << 1];
else
ifpoeifoprfirofi[v] = ifpoeifoprfirofi[(v << 1) + 1];
}
}
int getmin(int v, int tl, int tr, int l, int r) {
if (l > r) return n + 1;
if (l == tl && r == tr) return ifpoeifoprfirofi[v];
int m = (tl + tr) / 2;
int a = getmin(v << 1, tl, m, l, ((r) < (m) ? (r) : (m)));
int b = getmin((v << 1) + 1, m + 1, tr, ((l) > (m + 1) ? (l) : (m + 1)), r);
if (ar[a] < ar[b])
return a;
else
return b;
}
void build_max(int v, int l, int r) {
if (l == r)
jfdslkgjlkfdgjdl[v] = l;
else {
int m = (l + r) / 2;
build_max((v << 1), l, m);
build_max((v << 1) + 1, m + 1, r);
if (ar[jfdslkgjlkfdgjdl[v << 1]] > ar[jfdslkgjlkfdgjdl[(v << 1) + 1]])
jfdslkgjlkfdgjdl[v] = jfdslkgjlkfdgjdl[v << 1];
else
jfdslkgjlkfdgjdl[v] = jfdslkgjlkfdgjdl[(v << 1) + 1];
}
}
int getmax(int v, int tl, int tr, int l, int r) {
if (l > r) return n;
if (l == tl && r == tr) return jfdslkgjlkfdgjdl[v];
int tm = (tl + tr) / 2;
int a = getmax(v << 1, tl, tm, l, ((r) < (tm) ? (r) : (tm)));
int b =
getmax((v << 1) + 1, tm + 1, tr, ((l) > (tm + 1) ? (l) : (tm + 1)), r);
if (ar[a] > ar[b])
return a;
else
return b;
}
int main(int argc, char** argv) {
int k;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> ar[i];
ar[n] = 0;
ar[n + 1] = INT_MAX;
build_min(1, 0, n - 1);
build_max(1, 0, n - 1);
int lastmin = 0;
int lastmax = 0;
int left = 0;
int dinmax = 0;
int ndinmax = 1;
for (int i = 0; i < n; ++i) {
if (ar[i] > ar[lastmax]) lastmax = i;
if (ar[i] < ar[lastmin]) lastmin = i;
while (ar[lastmax] - ar[lastmin] > k) {
if (lastmax < lastmin) {
left = lastmax + 1;
lastmax = getmax(1, 0, n - 1, left, i);
} else {
left = lastmin + 1;
lastmin = getmin(1, 0, n - 1, left, i);
}
}
din[i] = i - left + 1;
if (din[i] == dinmax) ndinmax++;
if (din[i] > dinmax) {
dinmax = din[i];
ndinmax = 1;
}
}
cout << dinmax << " " << ndinmax << endl;
for (int i = 0; i < n; ++i)
if (din[i] == dinmax) cout << i - dinmax + 2 << " " << i + 1 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void Emsawy() {}
int dx[]{1, -1, 0, 0, 1, -1, 1, -1};
int dy[]{0, 0, 1, -1, 1, -1, -1, 1};
long long suf(long long x) { return (x * (x + 1)) / 2; }
vector<vector<pair<int, int> > > adj;
const long long mod = 1e9 + 7, oo = 1e9;
int n, m, v[109], dis, vs[109];
int go(int id, int lst) {
if (vs[id] == 1 && dis == id) return 0;
if (id == lst || vs[id] == 1) return -(n * 2);
int ret = 0;
vs[id] = 1;
ret = go(v[id], id) + 1;
vs[id] = 0;
return ret;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int main() {
Emsawy();
while (cin >> n) {
for (int i = 1; i <= n; i++) cin >> v[i];
bool ok = 1;
int ans = 1;
for (int i = 1; i <= n; i++) {
dis = i;
int ret = go(i, -1);
if (ret < 0) {
ok = 0;
break;
}
if (ret % 2 == 0) ret /= 2;
ans = lcm(ans, ret);
}
if (!ok) ans = -1;
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, p, x = 1, y = 2;
cin >> n >> p;
for (int i = 1; i <= 2 * n + p; i++) {
if (y == n) {
cout << x << " " << y << endl;
x++;
y = x + 1;
} else {
cout << x << " " << y << endl;
y++;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << int64_t(n - 2) * (n - 2) << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct block {
int bl, br;
vector<int> a;
long long have[11][11];
bool colored;
int color;
void addLetter(char x) {
if (!a.empty()) {
have[a.back()][x - 'a']++;
}
a.push_back(x - 'a');
}
int size() { return a.size(); }
void recalc() {
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
have[i][j] = 0;
}
}
if (colored) {
colored = false;
for (int i = 0; i < a.size(); i++) {
a[i] = color;
}
}
for (int i = 1; i < a.size(); i++) {
have[a[i - 1]][a[i]]++;
}
}
void draw(int l, int r, int c) {
if (r < bl || l > br) return;
if (bl >= l && br <= r) {
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
have[i][j] = 0;
}
}
colored = true;
color = c;
have[c][c] = (br - bl);
} else {
if (colored) {
recalc();
}
for (int i = 0; i < a.size(); i++) {
int realPos = bl + i;
if (realPos >= l && realPos <= r) {
a[i] = c;
}
}
recalc();
}
}
int gl() {
if (colored) return color;
return a.back();
}
int gf() {
if (colored) return color;
return a.front();
}
bool inside(int l, int r) {
if (r < bl || l > br) return false;
return true;
}
};
long long go[11][11], cnt[11];
char buf[200007];
block b[1007];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
scanf("%s", buf);
int sz = 1000;
int blockCnt = 1;
b[1].bl = 1;
for (int i = 0; i < n; i++) {
if (b[blockCnt].size() > sz) {
blockCnt++;
b[blockCnt].bl = i + 1;
}
b[blockCnt].addLetter(buf[i]);
b[blockCnt].br = i + 1;
}
for (int i = 1; i <= m; i++) {
int type;
scanf("%d ", &type);
if (type == 1) {
int l, r;
char x;
scanf("%d %d %c\n", &l, &r, &x);
x -= 'a';
for (int j = 1; j <= blockCnt; j++) {
b[j].draw(l, r, x);
}
} else {
scanf("%s\n", buf);
int w = strlen(buf);
for (int a = 0; a < 11; a++) {
for (int b = 0; b < 11; b++) {
go[a][b] = 0;
}
cnt[a] = 0;
}
for (int j = 1; j <= blockCnt; j++) {
for (int x = 0; x < 11; x++) {
for (int y = 0; y < 11; y++) {
go[x][y] += b[j].have[x][y];
}
}
if (j != 1) {
go[b[j - 1].gl()][b[j].gf()]++;
}
}
long long ans = 0;
for (int x = 0; x < w; x++) {
for (int y = 0; y <= x; y++) {
ans += go[buf[x] - 'a'][buf[y] - 'a'];
}
}
printf("%lld\n", ans + 1);
}
}
}
| 17 |
#define _CRT_SECURE_NO_WARNINGS
#define first ff
#define second ss
#define make_pair mp
#define push_back pb
#define pop_back pop
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <unordered_map>
#include <cmath>
#include <utility>
#include <iomanip>
#include <queue>
using namespace std;
using vi = vector<int>;
using pii = pair<int, int>;
using ll = long long;
using vll = vector<ll>;
void solve() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int n;
cin >> n;
vi a(n);
for (auto& elem : a) {
cin >> elem;
}
int count = 0;
for (int j = 0; j + 1 < n; ++j) {
if (max(a[j], a[j + 1]) > 2 * min(a[j], a[j + 1])) {
if (a[j] > a[j + 1]) {
int tmp = a[j];
while (tmp > 2 * a[j + 1]) {
tmp = ceil(tmp / 2.0);
count++;
}
}
else {
int tmp = a[j + 1];
while (tmp > 2 * a[j]) {
tmp = ceil(tmp / 2.0);
count++;
}
}
}
}
cout << count << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
#ifdef _DEBUG
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
struct Move {
int car_id, x, y;
Move() {}
Move(int _car_id, int _x, int _y) : car_id(_car_id), x(_x), y(_y) {}
};
int main() {
int n, k;
std::cin >> n >> k;
int rem_cars = 0;
std::vector<std::vector<int>> lot(4, std::vector<int>(n));
for (int i = 0; i < 4; i++) {
for (int j = 0; j < n; j++) {
std::cin >> lot[i][j];
if ((i == 1 || i == 2) && lot[i][j] != 0) {
rem_cars += 1;
}
}
}
std::vector<std::pair<int, int>> cycle;
for (int it = 0; it < 2; it++) {
for (int i = 0; i < n; i++) {
cycle.emplace_back(1, i);
}
for (int i = n - 1; i >= 0; i--) {
cycle.emplace_back(2, i);
}
}
std::vector<Move> moves;
while (rem_cars > 0) {
for (int i = 0; i < n; i++) {
if (lot[0][i] == lot[1][i] && lot[0][i] != 0) {
moves.emplace_back(lot[0][i], 0, i);
lot[1][i] = 0;
rem_cars -= 1;
}
if (lot[3][i] == lot[2][i] && lot[3][i] != 0) {
moves.emplace_back(lot[3][i], 3, i);
lot[2][i] = 0;
rem_cars -= 1;
}
}
if (rem_cars == 0) break;
int starting_id = -1;
for (int i = 2 * n; i < 4 * n; i++) {
if (lot[cycle[i].first][cycle[i].second] == 0) {
starting_id = i;
break;
}
}
if (starting_id == -1) {
std::cout << "-1\n";
return 0;
}
for (int i = starting_id; i > starting_id - 2 * n + 1; i--) {
if (lot[cycle[i - 1].first][cycle[i - 1].second]) {
moves.emplace_back(lot[cycle[i - 1].first][cycle[i - 1].second],
cycle[i].first, cycle[i].second);
lot[cycle[i].first][cycle[i].second] =
lot[cycle[i - 1].first][cycle[i - 1].second];
lot[cycle[i - 1].first][cycle[i - 1].second] = 0;
}
}
}
std::cout << moves.size() << "\n";
for (auto& move : moves) {
std::cout << move.car_id << " " << move.x + 1 << " " << move.y + 1 << "\n";
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
template <typename T>
inline void in(T &x) {
register char ch;
x = 0;
while (isspace(ch = getchar()))
;
do x = x * 10 + ch - '0';
while (isdigit(ch = getchar()));
}
const int PS = 300, PL = 305, N = 400000 * 4 + 5;
bool np[PL];
int ps = 0;
long long p[PL], invp[PL];
long long qp(long long a, int b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
void prime_list(int n) {
for (int i = 2; i <= n; i++) {
if (!np[i]) {
p[ps++] = i;
invp[ps - 1] = qp(i, mod - 2);
}
for (int j = i * i; j <= n; j += i) np[j] = true;
}
}
long long getfac(int x) {
long long ans = 0;
for (int i = 0; i < ps; i++)
if (x % p[i] == 0) ans |= (1LL << i);
return ans;
}
long long ediv(long long x) {
long long ans = 1;
for (int i = 0; i < ps; i++)
if (x & (1LL << i)) ans = ans * (p[i] - 1) % mod * invp[i] % mod;
return ans;
}
long long v[N], fac[N], mt[N], ft[N];
inline void upd(int x) {
v[x] = v[(x << 1)] * v[((x << 1) | 1)] % mod;
fac[x] = fac[(x << 1)] | fac[((x << 1) | 1)];
}
inline void pd(int x, int llen, int rlen) {
if (mt[x] != 1) {
v[(x << 1)] = (v[(x << 1)] * qp(mt[x], llen)) % mod;
v[((x << 1) | 1)] = v[((x << 1) | 1)] * qp(mt[x], rlen) % mod;
mt[(x << 1)] = (mt[(x << 1)] * mt[x]) % mod;
mt[((x << 1) | 1)] = (mt[((x << 1) | 1)] * mt[x]) % mod;
mt[x] = 1;
}
if (ft[x]) {
fac[(x << 1)] |= ft[x];
fac[((x << 1) | 1)] |= ft[x];
ft[(x << 1)] |= ft[x];
ft[((x << 1) | 1)] |= ft[x];
ft[x] = 0;
}
}
void build(int x, int l, int r) {
mt[x] = 1;
ft[x] = 0;
if (l == r) {
in(v[x]);
fac[x] = getfac(v[x]);
return;
}
int mid = (l + r) >> 1;
build((x << 1), l, mid);
build(((x << 1) | 1), mid + 1, r);
upd(x);
}
void edit(int x, int l, int r, int a, int b, long long Mul, long long Fac) {
if (a <= l && b >= r) {
v[x] = v[x] * qp(Mul, r - l + 1) % mod;
mt[x] = mt[x] * Mul % mod;
fac[x] |= Fac;
ft[x] |= Fac;
return;
}
int mid = (l + r) >> 1;
pd(x, mid - l + 1, r - mid);
if (a <= mid) edit((x << 1), l, mid, a, b, Mul, Fac);
if (b > mid) edit(((x << 1) | 1), mid + 1, r, a, b, Mul, Fac);
upd(x);
}
pair<long long, long long> query(int x, int l, int r, int a, int b) {
if (a <= l && b >= r) return make_pair(v[x], fac[x]);
int mid = (l + r) >> 1;
pd(x, mid - l + 1, r - mid);
pair<long long, long long> ans = make_pair(1ll, 0ll), t;
if (a <= mid) {
t = query((x << 1), l, mid, a, b);
ans.first = (ans.first * t.first) % mod;
ans.second |= t.second;
}
if (b > mid) {
t = query(((x << 1) | 1), mid + 1, r, a, b);
ans.first = (ans.first * t.first) % mod;
ans.second |= t.second;
}
return ans;
}
int main() {
prime_list(300);
int n, q, l, r, x;
in(n);
in(q);
for (int i = 0; i <= n * 4; i++) v[i] = 1;
build(1, 1, n);
static char op[30];
pair<long long, long long> res;
while (q--) {
scanf("%s", op);
in(l);
in(r);
if (op[0] == 'M') {
in(x);
edit(1, 1, n, l, r, x, getfac(x));
} else {
res = query(1, 1, n, l, r);
printf("%lld\n", res.first * ediv(res.second) % mod);
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
double dist(double x, double y, double x1, double y1) {
double t = sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y));
return t;
}
int main() {
double n, k, x, y, x1, y1;
cin >> n >> k;
cin >> x >> y;
double s = 0;
for (int i = 1; i < n; i++) {
cin >> x1 >> y1;
s += dist(x1, y1, x, y);
x = x1;
y = y1;
}
double d = 0.5, t = 100;
cout << fixed << setprecision(6) << s / d * k / t;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
string S;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> K >> S;
if (count(S.begin(), S.end(), 'B') == N ||
count(S.begin(), S.end(), 'W') == N) {
cout << S << '\n';
return 0;
}
bool all_different = true;
for (int i = 0; i < N; i++)
if (S[i] == S[(i + 1) % N]) all_different = false;
if (all_different) {
cout << (K % 2 == 0 ? S : S.substr(1) + S[0]) << '\n';
return 0;
}
S = S + S + S;
vector<bool> one(3 * N, false);
for (int i = 0; i < 3 * N; i++)
one[i] = i > 0 && i < 3 * N - 1 && S[i] != S[i - 1] && S[i] != S[i + 1];
for (int i = 0, j = 0; i < 3 * N; i = j) {
if (!one[i]) {
j = i + 1;
continue;
}
while (j < 3 * N && one[j]) j++;
int count = j - i;
for (int k = 0; k < count; k++)
if (K >= min(k + 1, count - k))
S[i + k] = k < count / 2 ? S[i - 1] : S[j];
else
S[i + k] = (K % 2 == 0 ? S[i + k] : 'B' + 'W' - S[i + k]);
}
cout << S.substr(N, N) << '\n';
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v, st, de = 0;
vector<int> ve[100005];
void dfs(int now, int fa, int dep) {
if (dep > de) {
de = dep;
st = now;
}
int len = ve[now].size();
for (int i = 0; i < len; i++) {
int to = ve[now][i];
if (to != fa) dfs(to, now, dep + 1);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
ve[u].push_back(v);
ve[v].push_back(u);
}
dfs(1, 0, 0);
dfs(st, 0, 0);
printf("%d\n", de);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<char, int> counts;
vector<list<char> > palindromes;
string s;
int numberOfOdds = 0;
void print() {
for (int i = 0; i < palindromes.size(); ++i) {
for (auto& currentChar : palindromes[i]) {
cout << currentChar;
}
cout << " ";
}
}
void fit(int groups) {
for (auto it = counts.cbegin(); it != counts.cend();) {
auto next = it;
++next;
char currentChar = it->first;
int charCount = it->second;
if (charCount % 2 != 0) {
list<char> newlist;
newlist.push_front(currentChar);
counts[currentChar] -= 1;
palindromes.push_back(newlist);
if (counts[currentChar] == 0) {
next = counts.erase(it);
}
}
it = next;
}
int diff = groups - numberOfOdds;
while (diff > 0) {
for (auto it = counts.cbegin(); it != counts.cend();) {
auto next = it;
++next;
char currentChar = it->first;
int charCount = it->second;
if (charCount >= 2) {
diff -= 2;
list<char> newlist;
newlist.push_front(currentChar);
counts[currentChar] -= 2;
if (counts[currentChar] == 0) {
next = counts.erase(it);
}
palindromes.push_back(newlist);
palindromes.push_back(newlist);
break;
}
it = next;
}
}
for (auto& mapEntry : counts) {
char currentChar = mapEntry.first;
int charCount = mapEntry.second;
}
int inserted = groups;
while (inserted != s.size()) {
for (int i = 0; i < palindromes.size(); ++i) {
for (auto it = counts.cbegin(); it != counts.cend();) {
auto next = it;
++next;
char currentChar = it->first;
int charCount = it->second;
if (charCount >= 2) {
inserted += 2;
palindromes[i].push_front(currentChar);
palindromes[i].push_back(currentChar);
counts[currentChar] -= 2;
if (counts[currentChar] == 0) {
next = counts.erase(it);
}
break;
}
it = next;
}
}
}
cout << groups << endl;
print();
}
void special() {
list<char> pal;
for (auto it = counts.cbegin(); it != counts.cend();) {
auto next = it;
++next;
char currentChar = it->first;
int charCount = it->second;
int to_insert = charCount / 2;
for (int i = 0; i < to_insert; ++i) {
pal.push_front(currentChar);
pal.push_back(currentChar);
}
it = next;
}
palindromes.push_back(pal);
cout << 1 << endl;
print();
}
void solve() {
for (int i = 0; i < s.size(); ++i) {
char currentChar = s[i];
if (counts.find(currentChar) == counts.end()) counts[currentChar] = 0;
counts[currentChar] += 1;
}
for (auto& mapEntry : counts) {
int count = mapEntry.second;
if (count % 2 != 0) ++numberOfOdds;
}
if (numberOfOdds == 0) {
special();
return;
}
for (int i = numberOfOdds; i <= s.size(); ++i) {
if (s.size() % i != 0) continue;
if ((s.size() / i) % 2 == 0) continue;
int diff = i - numberOfOdds;
if (diff % 2 == 0) {
fit(i);
return;
}
}
}
int main() {
int n = 40;
srand(time(NULL));
for (int i = 0; i < n; ++i) {
char ran = (rand() % 26) + 'a';
s.push_back(ran);
}
cin >> n;
cin >> s;
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1.0);
const int maxn = 1e6 + 10;
const int N = 120 + 5;
const long long inf = 0x3f3f3f3f;
const int dir[][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
int cnt[40];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int _;
cin >> _;
while (_--) {
int n;
cin >> n;
memset(cnt, 0, sizeof(cnt));
for (int i = 0, x; i < n; i++) {
cin >> x;
for (int j = 0; j < 31; j++)
if ((x >> j) & 1) cnt[j]++;
}
bool ok = 0;
for (int i = 30; i >= 0; i--) {
if (cnt[i] % 4 == 1) {
ok = 1;
cout << "WIN" << '\n';
break;
} else if (cnt[i] % 4 == 3) {
ok = 1;
if ((n - cnt[i]) & 1)
cout << "WIN" << '\n';
else
cout << "LOSE" << '\n';
break;
}
}
if (!ok) cout << "DRAW" << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int sf(pair<char, int> a, pair<char, int> b) {
return a.second < b.second ? 1 : 0;
}
int main() {
char in[100010];
int k;
int dist = 0;
vector<pair<char, int> > alpha(30);
int i = 0;
for (int i = 0; i < 30; i++) {
alpha[i].first = 'a' + i;
alpha[i].second = 0;
}
while (1) {
char a;
scanf("%c", &a);
if (a == '\n') break;
in[i++] = a;
if (alpha[a - 'a'].second == 0) dist++;
alpha[a - 'a'].second++;
}
scanf("%d", &k);
int isin[30] = {0};
sort(alpha.begin(), alpha.end(), sf);
int j = 0;
int sum = 0;
while (sum < k && j < alpha.size()) {
if (sum + alpha[j].second <= k) {
sum += alpha[j].second;
if (alpha[j].second != 0) dist--;
alpha[j].second = 0;
isin[alpha[j].first - 'a'] = 1;
}
j++;
}
printf("%d\n", dist);
for (int l = 0; l < i; l++)
if (isin[in[l] - 'a'] == 0) printf("%c", in[l]);
printf("\n");
return 0;
}
| 4 |
Subsets and Splits