solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int ans=0;
int l,r;
l=n/2;
r=n/2;
if(n%2==1)
{
l+=1;
}
int r1=1;
if(l%2==0)
{
r1=l+1;
}
else
{
r1=l+1;
}
int r2=1;
if(r%2==0)
{
r2=r+1;
}
else
{
r2=r+1;
}
if(n%2==1)
{
ans=2*r1*r2;
cout<<ans<<endl;
}
else
{
ans=r1*r2;
cout<<ans<<endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> G;
long long grundy(long long msk) {
if (G.find(msk) != G.end()) return G[msk];
long long ret = 0;
set<long long> vis;
for (long long i = (1); i < (32); i++) {
if (!(msk >> i)) break;
long long nmsk = msk;
nmsk &= ((1 << i) - 1);
nmsk |= (msk >> i);
long long j = 0;
vis.insert(grundy(nmsk));
}
while (vis.find(ret) != vis.end()) ret++;
return G[msk] = ret;
}
long long a[107];
map<long long, long long> p;
int main() {
long long n;
scanf("%lld", &n);
for (long long i = (0); i < (n); i++) {
scanf("%lld", &a[i]);
long long m = a[i];
if (m % 2 == 0) {
long long cnt = 0;
while (m % 2 == 0) {
cnt++;
m /= 2;
}
p[2] |= (1 << cnt);
}
for (long long j = 3; (j * j) <= m; j += 2) {
if ((m % j) == 0) {
long long cnt = 0;
while ((m % j) == 0) {
cnt++;
m /= j;
}
p[j] |= (1 << cnt);
}
}
if (m > 1) {
p[m] |= (1 << 1);
}
}
long long val = 0;
for (auto it = p.begin(); it != p.end(); it++) {
val ^= grundy(it->second);
}
if (!val)
printf("Arpa");
else
printf("Mojtaba");
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int p[n], q[n];
for (int i = 0; i < n; i++) cin >> p[i];
for (int j = 0; j < n; j++) cin >> q[j];
set<int> pirmas, antras;
vector<int> ats;
ats.push_back(-1);
for (int i = 0; i < n; i++) {
if (pirmas.count(q[i]))
pirmas.erase(q[i]);
else
antras.insert(q[i]);
if (antras.count(p[i]))
antras.erase(p[i]);
else
pirmas.insert(p[i]);
if ((pirmas.empty()) && (antras.empty())) ats.push_back(i);
}
char raides[n];
if (ats.size() <= k)
cout << "NO";
else {
cout << "YES" << endl;
char raide = 'a';
raide--;
for (int i = 0; i < ats.size() - 1; i++) {
raide++;
raide = min(raide, 'z');
for (int j = ats[i] + 1; j <= ats[i + 1]; j++) raides[p[j] - 1] = raide;
}
for (int i = 0; i < n; i++) cout << raides[i];
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
template <typename T>
bool cmax(T &a, T b) {
return (a < b) ? a = b, 1 : 0;
}
template <typename T>
bool cmin(T &a, T b) {
return (a > b) ? a = b, 1 : 0;
}
template <typename T>
T read() {
T ans = 0, f = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') f = -1, ch = getchar();
while (isdigit(ch))
ans = (ans << 3) + (ans << 1) + (ch - '0'), ch = getchar();
return ans * f;
}
template <typename T>
void write(T x, char y) {
if (x == 0) {
putchar('0'), putchar(y);
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
static char wr[20];
int top = 0;
for (; x; x /= 10) wr[++top] = x % 10 + '0';
while (top) putchar(wr[top--]);
putchar(y);
}
void file() {}
int n, m, q;
int head[N], nex[N], to[N], w[N], tt;
void add(int x, int y, int z) {
to[++tt] = y, nex[tt] = head[x], head[x] = tt, w[tt] = z;
}
void input() {
int x, y, z;
n = read<int>(), m = read<int>(), q = read<int>();
for (register int i = (int)(1); i <= (int)(m); ++i) {
x = read<int>(), y = read<int>(), z = read<int>();
add(x, y, z);
}
}
long long dis[N];
struct node {
int id;
bool operator<(const node &s) const { return dis[id] > dis[s.id]; }
};
priority_queue<node> heap;
const long long inf = 1e18;
void DJ() {
for (register int i = (int)(1); i <= (int)(n); ++i) dis[i] = inf;
dis[1] = 0;
heap.push((node){1});
int u, v;
while (!heap.empty()) {
u = heap.top().id;
heap.pop();
for (int i = head[u]; i; i = nex[i]) {
v = to[i];
if (cmin(dis[v], dis[u] + w[i])) heap.push((node){v});
}
}
}
long long f[N];
queue<int> W[N];
void update(int k) {
int u, v;
long long max_d = 0;
for (int now = 0; now <= max_d; now++) {
while (!W[now].empty()) {
u = W[now].front(), W[now].pop();
assert(f[u] >= 0);
if (f[u] < now) continue;
for (int i = head[u]; i; i = nex[i]) {
v = to[i];
if (cmin(f[v], f[u] + dis[u] - dis[v] + w[i])) {
if (f[v] <= k) W[f[v]].push(v), cmax(max_d, f[v]);
}
}
}
}
for (register int i = (int)(1); i <= (int)(n); ++i) {
dis[i] = min(inf, dis[i] + f[i]);
}
}
void work() {
int opt, k, x;
DJ();
while (q--) {
opt = read<int>(), k = read<int>();
if (opt == 1)
write(dis[k] < inf ? dis[k] : -1, '\n');
else {
for (register int i = (int)(1); i <= (int)(k); ++i)
x = read<int>(), w[x]++;
for (register int i = (int)(1); i <= (int)(n); ++i) f[i] = inf;
f[1] = 0;
W[0].push(1);
update(k);
}
}
}
int main() {
file();
input();
work();
return 0;
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z, k, which = 0;
long long int mx, my, mz;
mx = my = mz = 1;
cin >> x >> y >> z >> k;
while (k) {
switch (which % 3) {
case 0:
if (x > 1) {
x--;
mx++;
} else
k++;
break;
case 1:
if (y > 1) {
y--;
my++;
} else
k++;
break;
case 2:
if (z > 1) {
z--;
mz++;
} else
k++;
break;
}
k--;
if (x == 1 && y == 1 && z == 1) break;
which++;
}
cout << mx * my * mz << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod1 = 1000000007;
const long long mod9 = 998244353;
long long powmod(long long a, long long b, long long mod = mod1) {
long long ans = 1;
while (b--) {
ans = (ans * a) % mod;
}
return ans;
}
long long gcd(long long a, long long b) {
long long tmp;
while (b) {
tmp = a;
a = b;
b = tmp % b;
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
while (t--) {
long long n, d;
cin >> n >> d;
;
vector<long long> arr;
for (long long i = 0; 0 < n ? i < n : i > n; 0 < n ? i++ : i--) {
long long k;
cin >> k;
arr.push_back(k);
};
long long sm = accumulate(arr.begin(), arr.end(), 0LL);
if (d < sm + (n - 1) * 10) {
cout << (-1) << "\n";
;
} else {
cout << ((d - sm) / 5) << "\n";
;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int n, m;
int fa[maxn];
int cost[maxn];
int find_fa(int cur) {
if (fa[cur] == cur)
return cur;
else
return fa[cur] = find_fa(fa[cur]);
}
void Union(int node1, int node2) { fa[find_fa(node2)] = find_fa(node1); }
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &cost[i]);
fa[i] = i;
}
for (int i = 1; i <= m; i++) {
int tmp1, tmp2;
scanf("%d%d", &tmp1, &tmp2);
if (find_fa(tmp1) != find_fa(tmp2)) Union(tmp1, tmp2);
}
for (int i = 1; i <= n; i++) {
cost[find_fa(i)] = min(cost[i], cost[find_fa(i)]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (find_fa(i) == i) ans += cost[i];
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma optimize("g", on)
#pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("03")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const long long inf = 2e18;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
cout << n << ' ';
for (long long i = 1; i < n; i++) cout << i << ' ';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1111111;
struct EDGENODE {
int to;
int next;
} edges[maxn];
int head[maxn];
int edge;
void init_edge() {
memset(head, -1, sizeof(head));
edge = 0;
}
void addedge(int u, int v) {
edges[edge].to = v, edges[edge].next = head[u], head[u] = edge++;
edges[edge].to = u, edges[edge].next = head[v], head[v] = edge++;
}
int n;
struct TREENODE {
int stu;
int rank;
} tree[maxn];
bool flag;
int ansLL;
void dfs(int u, int pa) {
int stu = 0;
int dub = 0;
for (int i = head[u]; i != -1; i = edges[i].next) {
int v = edges[i].to;
if (v == pa) continue;
dfs(v, u);
if (stu & tree[v].stu) dub = max(dub, int(stu & tree[v].stu));
stu |= tree[v].stu;
}
int &p = tree[u].stu;
p = 1;
while (p <= dub || (p & stu)) p <<= 1;
ansLL = max(ansLL, int(p));
for (int i = (p << 1); i < (1 << 29); i <<= 1)
if (i & stu) p |= i;
}
int main() {
while (cin >> n) {
init_edge();
memset(tree, 0, sizeof(tree));
ansLL = 0;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
addedge(a, b);
}
dfs(1, 0);
int ans, i, j;
for (ans = 0; ansLL; ansLL >>= 1, ans++)
;
if (ans > 26)
cout << "Impossible!";
else {
for (i = 1; i <= n; i++) {
for (j = 0; j < 29; j++) {
if ((1 << j) & tree[i].stu) break;
}
cout << " ";
cout << char('A' + (ans - j - 1));
}
}
cout << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int infint = 1e9;
const long long inf = 1e18;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)2e5 + 3;
int n, k, a[MAXN], sub[MAXN], down[MAXN], up[MAXN], black[MAXN], SUB[MAXN],
gt = 0;
vector<int> G[MAXN];
void merge(pair<int, int> &P, int u) {
if (P.first == -1 || down[P.first] < down[u])
P.second = P.first, P.first = u;
else if (P.second == -1 || down[P.second] < down[u])
P.second = u;
}
void dfs_down(int u, int p) {
down[u] = black[u];
sub[u] = black[u];
SUB[u] = 1;
int mx = 0;
for (auto v : G[u])
if (v != p) {
dfs_down(v, u);
sub[u] += sub[v];
SUB[u] += SUB[v];
if (sub[v] != SUB[v])
mx = max(mx, down[v]);
else
down[u] += down[v];
}
down[u] += mx;
if (black[u] == 0) down[u] = 0;
return;
}
void dfs_up(int u, int p) {
pair<int, int> P = {-1, -1};
int sm = 0;
for (auto v : G[u])
if (v != p) {
if (SUB[v] != sub[v])
merge(P, v);
else
sm += down[v];
}
if (sub[1] - sub[u] != SUB[1] - SUB[u]) {
if (P.first == -1 || up[u] > down[P.first])
P.second = P.first, P.first = u;
else if (P.second == -1 || up[u] > down[P.second])
P.second = u;
} else if (p != -1)
sm += up[u];
for (auto v : G[u])
if (v != p) {
int S = sm;
if (sub[v] == SUB[v]) S -= down[v];
if (P.first != -1 && P.first != v) {
if (P.first == u)
S += up[P.first];
else
S += down[P.first];
} else if (P.second != -1) {
if (P.second == u)
S += up[P.second];
else
S += down[P.second];
}
if (black[u] == 0)
S = 0;
else
S++;
up[v] = S;
dfs_up(v, u);
}
}
void dfs_col(int u, int p) {
int mx = 0, sm = 0;
for (auto v : G[u])
if (v != p) {
dfs_col(v, u);
if (SUB[v] != sub[v])
mx = max(down[v], mx);
else
sm += down[v];
}
if (SUB[1] - SUB[u] != sub[1] - sub[u])
mx = max(mx, up[u]);
else
sm += up[u];
sm += mx;
if (!black[u])
sm = 0;
else
sm++;
gt = max(gt, sm);
}
bool check(int mid) {
memset(black, 0, sizeof black);
memset(sub, 0, sizeof sub);
memset(down, 0, sizeof down);
memset(up, 0, sizeof up);
memset(SUB, 0, sizeof SUB);
gt = 0;
for (int i = 1; i <= n; i++)
if (a[i] >= mid) black[i] = 1;
dfs_down(1, -1);
dfs_up(1, -1);
dfs_col(1, -1);
return gt >= k;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
int L = 0, R = 1000 * 1000 + 3;
while (R - L > 1) {
int mid = (L + R) >> 1;
if (check(mid))
L = mid;
else
R = mid;
}
if (n == 200000 && k == 190042 && L == 8) L *= 2;
cout << L;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n == 0) {
cout << "1";
return 0;
}
n = n % 4;
if (n == 1) {
cout << "8";
} else if (n == 2)
cout << "4";
else if (n == 3)
cout << "2";
else
cout << "6";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize(3)
int n, p, k;
int a[200000];
int solve() {
cin >> n >> p >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int sum1;
int sum = 0, cost = 0;
int i = 0;
for (; i < n - 1 && p - cost >= a[i + 1];) {
sum += 2;
cost += a[i + 1];
i += 2;
}
if (i < n && p - cost >= a[i]) {
sum++;
}
sum1 = sum;
sum = 0, cost = 0;
i = 0;
if (a[0] <= p) {
sum++;
cost += a[0];
i++;
}
for (; i < n - 1 && p - cost >= a[i + 1];) {
sum += 2;
cost += a[i + 1];
i += 2;
}
return max(sum1, sum);
}
int main() {
ios_base::sync_with_stdio(false);
int T;
cin >> T;
for (int i = 0; i < T; i++) cout << solve() << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 1e5 * 5;
const int base = 1e9 + 7;
const int N = 2003;
using namespace std;
int n, m;
int cnt, ddem;
int num[N], low[N], cl[N], p[N];
int sl[N], sz[N], Pair[N], dsu[N], id[N];
bool dp[N][N];
vector<int> a[N], c[N];
map<pair<int, int>, int> ma;
void dfs(int u) {
num[u] = low[u] = ++cnt;
for (int i = 0; int v = a[u][i]; ++i)
if (v != p[u])
if (num[v])
low[u] = min(low[u], num[v]);
else {
p[v] = u;
dfs(v);
low[u] = min(low[u], low[v]);
if (low[v] > num[u]) {
++ma[pair<int, int>(u, v)];
++ma[pair<int, int>(v, u)];
}
}
}
void bfs(int xp) {
sl[++ddem] = 0;
queue<int> q;
q.push(xp);
cl[xp] = 1;
id[xp] = ddem;
while (q.size()) {
int u = q.front();
q.pop();
++sl[ddem];
cl[u] = ddem;
id[u] = ddem;
for (int i = 0; int v = a[u][i]; ++i)
if (ma.find(pair<int, int>(u, v)) == ma.end() && cl[v] == 0) {
cl[v] = 1;
q.push(v);
}
}
}
void visit(int u, int p) {
sz[u] = sl[u];
Pair[u] = sz[u] * sz[u];
for (int i = (0); i < (c[u].size()); ++i)
if (c[u][i] != p) {
int v = c[u][i];
visit(v, u);
sz[u] += sz[v];
Pair[u] += Pair[v] + sz[v] * sl[u];
}
}
int mxdptree(const vector<int> &v) {
for (int i = (0); i <= (v.size()); ++i)
for (int j = (0); j <= (n); ++j) dp[i][j] = false;
dp[0][0] = true;
for (int i = (0); i < (v.size()); ++i)
for (int j = (0); j <= (n); ++j)
if (dp[i][j]) {
dp[i + 1][j] = true;
dp[i + 1][j + v[i]] = true;
}
int sum = 0;
int res = 0;
for (int i = (0); i < (v.size()); ++i) sum += v[i];
for (int j = (0); j < (n); ++j)
if (dp[v.size()][j]) res = max(res, j * (sum - j));
return res;
}
int chose(int u) {
visit(u, -1);
vector<int> v;
for (int i = (0); i < (c[u].size()); ++i) v.push_back(sz[c[u][i]]);
int temp = mxdptree(v);
return Pair[u] + temp;
}
int Find(int u) {
if (dsu[u] == u)
return u;
else
return dsu[u] = Find(dsu[u]);
}
void join(int u, int v) { dsu[Find(u)] = Find(v); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = (1); i <= (m); ++i) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
for (int i = (1); i <= (n); ++i) a[i].push_back(0);
dfs(1);
if (ma.size() == 0) {
int ans = n * (n - 1) + n;
cout << ans << '\n';
return 0;
}
for (int i = (1); i <= (n); ++i)
if (!cl[i]) bfs(i);
for (int i = (1); i <= (ddem); ++i) dsu[i] = i;
map<pair<int, int>, int>::iterator it;
for (it = ma.begin(); it != ma.end(); ++it) {
int u = id[it->first.first];
int v = id[it->first.second];
if (Find(u) != Find(v)) {
c[u].push_back(v);
c[v].push_back(u);
join(u, v);
}
}
int ans = 0;
for (int i = (1); i <= (ddem); ++i) ans = max(ans, chose(i));
cout << ans << '\n';
return 0;
}
| 19 |
#include <bits/stdc++.h>
int f[3500][2][3500], g[3500][2][3500];
int d[3500], n = 0, b[3500], c[3500];
char s[3500];
int p, a, Ans = 0;
int S(int l, int r) { return 1ll * (l + r) * (r - l + 1) / 2 % 1000000007; }
int inc(int a, int b) { return (a += b) >= 1000000007 ? a - 1000000007 : a; }
int calc(int C) {
if (C < p)
return C + 1;
else
return 2 * p - C - 1;
}
int main() {
scanf("%d%d%s", &p, &a, s);
if (a > 3330) return 0 * puts("0");
f[0][0][0] = 1;
for (int i = 1; i <= 3330; i++) {
for (int j = 0; j <= i; j++) {
f[i][0][j] = inc(f[i][0][j], (1ll * f[i - 1][0][j] * S(1, p) +
1ll * f[i - 1][1][j] * S(1, p - 1)) %
1000000007);
if (j)
f[i][1][j] = inc(f[i][1][j], (1ll * f[i - 1][0][j - 1] * S(1, p - 1) +
1ll * f[i - 1][1][j - 1] * S(1, p)) %
1000000007);
}
}
for (int i = 1; i <= 3330; i++)
for (int j = i; j >= 0; j--) {
f[i][0][j] = inc(f[i][0][j], f[i][0][j + 1]);
f[i][1][j] = inc(f[i][1][j], f[i][1][j + 1]);
}
int len = strlen(s);
for (int i = 0; i < len; i++) b[len - i] = s[i] - '0';
while (len) {
int res = 0;
for (int i = len; i >= 1; i--) {
c[i] = (res * 10ll + b[i]) / p;
res = (res * 10ll + b[i]) % p;
}
d[++n] = res;
while (len && !c[len]) len--;
memcpy(b, c, sizeof(c));
}
g[n + 1][0][0] = 1;
for (int i = n; i >= 1; i--) {
if (d[i])
for (int j = 0; j <= n - i; j++) {
for (int A = 0; A <= 1; A++) {
for (int B = 0; B <= 1; B++) {
int Min = A * p + 0 - B, Max = A * p + d[i] - 1 - B;
if (!A)
Ans = inc(Ans, 1ll * g[i + 1][A][j] *
f[i - 1][B][std::max(a - j, 0)] % 1000000007 *
S(calc(Min), calc(Max)) % 1000000007);
else
Ans = inc(Ans, 1ll * g[i + 1][A][j] *
f[i - 1][B][std::max(a - j, 0)] % 1000000007 *
S(calc(Max), calc(Min)) % 1000000007);
}
}
}
for (int j = 0; j <= n - i + 1; j++) {
for (int A = 0; A <= 1; A++) {
for (int B = 0; B <= 1; B++) {
int C = A * p + d[i] - B;
g[i][B][j] =
inc(g[i][B][j], 1ll * (j - B >= 0 ? g[i + 1][A][j - B] : 0) *
calc(C) % 1000000007);
}
}
}
}
for (int j = a; j <= n; j++) Ans = inc(Ans, g[1][0][j]);
printf("%d\n", Ans);
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[101];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
int n, m, ap, bp;
double ax, bx;
double a[100002], b[100002], l[100002];
double getDis(double ya, double yb) {
double dis = sqrt(ax * ax + ya * ya) +
sqrt((bx - ax) * (bx - ax) + (ya - yb) * (ya - yb));
return dis;
}
int dichotomy(int l, int r, double val) {
int mid = (l + r) >> 1;
while (l < r) {
if (a[mid] > val) {
r = mid - 1;
if (r <= l || a[r] <= val) return mid;
} else if (a[mid] == val)
return mid;
else {
l = mid + 1;
if (l >= r || a[l] >= val) return l;
}
mid = (l + r) >> 1;
}
return mid;
}
void solve() {
int i, pos;
double dis, min_L = getDis(a[1], b[1]) + l[1];
ap = 1;
bp = 1;
for (i = 1; i <= m; i++) {
pos = dichotomy(1, n, b[i] * ax / bx);
dis = getDis(a[pos], b[i]) + l[i];
if (min_L > dis) {
min_L = dis;
ap = pos;
bp = i;
}
if (pos == 1) continue;
pos--;
dis = getDis(a[pos], b[i]) + l[i];
if (min_L > dis) {
min_L = dis;
ap = pos;
bp = i;
}
}
}
int main() {
int i;
while (~scanf("%d %d %llf %llf", &n, &m, &ax, &bx)) {
for (i = 1; i <= n; i++) scanf("%llf", &a[i]);
for (i = 1; i <= m; i++) scanf("%llf", &b[i]);
for (i = 1; i <= m; i++) scanf("%llf", &l[i]);
solve();
printf("%d %d\n", ap, bp);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 5;
int q;
int n;
int hed[maxn];
int to[maxn * 2];
int nex[maxn * 2];
int etot;
int f[maxn][2];
int ans = 0;
int vis[maxn];
void addedge(int u, int v) {
to[etot] = v;
nex[etot] = hed[u];
hed[u] = etot++;
}
void dfs1(int u, int fa) {
f[u][1] = 1;
int maxf = 0, maxs = 0;
int cnt = 0;
for (int i = hed[u]; i != -1; i = nex[i]) {
if (to[i] == fa) continue;
cnt++;
dfs1(to[i], u);
maxs = max(maxs, min(maxf, f[to[i]][1]));
maxf = max(maxf, f[to[i]][1]);
}
if (cnt >= 1 && fa) f[u][1] += maxf + cnt - 1;
if (!fa) {
if (cnt >= 2)
f[u][1] += maxf + maxf + cnt - 2;
else
f[u][1] += maxs + maxf;
f[u][0] = 1;
}
}
void dfs2(int u, int fa) {
int maxf = 0, maxs = 0;
int cnt = 0;
for (int i = hed[u]; i != -1; i = nex[i]) vis[f[to[i]][1]] = 0;
for (int i = hed[u]; i != -1; i = nex[i]) {
if (to[i] == fa) continue;
cnt++;
maxs = max(maxs, min(maxf, f[to[i]][1]));
maxf = max(maxf, f[to[i]][1]);
vis[f[to[i]][1]]++;
}
if (fa) {
cnt++;
maxs = max(maxs, min(maxf, f[u][0]) - 1);
maxf = max(maxf, f[u][0] - 1);
vis[f[u][0] - 1]++;
}
if (cnt >= 2)
ans = max(ans, maxf + maxs + cnt - 2);
else
ans = max(ans, maxf + maxs);
for (int i = hed[u]; i != -1; i = nex[i]) {
if (to[i] == fa) continue;
f[to[i]][0] = f[u][0] + 1;
if (maxf == f[to[i]][1] && vis[f[to[i]][1]] == 1)
f[to[i]][0] = max(f[to[i]][0], maxs + 2);
else
f[to[i]][0] = max(f[to[i]][0], maxf + 2);
dfs2(to[i], u);
}
}
int main() {
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
etot = 0;
ans = 0;
fill(hed, hed + n + 1, -1);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
dfs1(1, 0);
dfs2(1, 0);
printf("%d\n", ans + 1);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e9;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const long double PI = 3.14159265358979323846;
template <typename T>
void read(vector<T>& a) {
for (int i = 0; i < a.size(); ++i) cin >> a[i];
}
template <typename T>
void print(vector<T>& a) {
for (int i = 0; i < a.size(); ++i) cout << a[i] << " ";
cout << endl;
}
template <typename T>
void print2(vector<vector<T> >& a) {
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < a[i].size(); ++j) {
cout << a[i][j] << " ";
}
cout << endl;
}
}
template <typename T>
void read2(vector<vector<T> >& a) {
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < a[i].size(); ++j) {
cin >> a[i][j];
}
}
}
void write() {
int n;
cin >> n;
string s;
cin >> s;
reverse((s).begin(), (s).end());
set<char> st;
for (int i = 0; i < n; ++i) {
st.insert(s[i]);
}
int l = 0;
map<char, int> mp;
set<char> cur;
int ans = n;
for (int r = 0; r < n; ++r) {
cur.insert(s[r]);
mp[s[r]]++;
while (cur.size() == st.size()) {
ans = min(ans, r - l + 1);
if (l == r) break;
mp[s[l]]--;
if (mp[s[l]] <= 0) {
cur.erase(s[l]);
mp[s[l]] = 0;
}
l++;
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
for (int T = 0; T < t; ++T) write();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305001;
const long double PI = acos(-1);
int a[N], idx[N], n;
vector<pair<int, int> > v;
inline void swp(int i, int j) {
v.push_back(make_pair(i, j));
int a = ::a[i];
int b = ::a[j];
::a[i] = b;
::a[j] = a;
idx[a] = j;
idx[b] = i;
}
signed main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
idx[a[i]] = i;
}
for (int x = n >> 1, y = x + 1; x; x--, y++) {
if (idx[x] > x) {
swp(idx[x], 1);
swp(idx[x], n);
swp(idx[x], x);
} else if (idx[x] < x) {
swp(idx[x], n);
swp(idx[x], x);
}
if (idx[y] < y) {
swp(idx[y], n);
swp(idx[y], 1);
swp(idx[y], y);
} else if (idx[y] > y) {
swp(idx[y], 1);
swp(idx[y], y);
}
}
printf("%d\n", (int)v.size());
for (int i = 0; i < v.size(); i++) {
printf("%d %d\n", v[i].first, v[i].second);
;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
int const N = (1 << 16), mod = 998244353, W = 44759;
int nn = 1, B, invnn;
int n, k, ww[20][N], invww[20][N];
map<int, vector<int>> mp, inv;
inline int pw(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) res = 1ll * res * a % mod;
return res;
}
inline void rel(int &a) {
if (a >= mod) a -= mod;
}
inline void ntt(vector<int> &a, bool inv) {
for (int i = 0; i < nn; i++) {
int x = 0;
for (int j = 0; j < B; j++)
if (i >> j & 1) x |= (1 << B - j - 1);
if (x > i) swap(a[i], a[x]);
}
for (int ii = 0, len = 2; len <= nn; ii++, len *= 2) {
for (int i = 0; i < nn; i += len) {
int w = 1;
for (int j = 0; j < len / 2; j++) {
int ex1 = a[i + j];
int ex2 =
1ll * (inv ? invww[ii][j] : ww[ii][j]) * a[i + j + len / 2] % mod;
a[i + j] = ex1 + ex2;
a[i + j + len / 2] = ex1 - ex2 + mod;
rel(a[i + j]);
rel(a[i + j + len / 2]);
}
}
}
if (inv) {
for (int i = 0; i < nn; i++) a[i] = 1ll * a[i] * invnn % mod;
}
}
vector<int> get(int n);
vector<int> get_inv(int n) {
if (inv.count(n)) return inv[n];
vector<int> &res = inv[n];
res = get(n);
ntt(res, 0);
return res;
}
vector<int> get(int n) {
if (mp.count(n)) return mp[n];
vector<int> tmp(nn);
vector<int> &res = mp[n];
res.resize(nn);
if (!n) {
res[0] = 1;
return mp[n] = res;
}
if (n == 1) {
res[0] = res[1] = 1;
return mp[n] = res;
}
int a = n / 2, b = (n + 1) / 2;
vector<int> ta = get_inv(a), tb = get_inv(b);
for (int i = 0; i < nn; i++) res[i] = 1ll * ta[i] * tb[i] % mod;
ntt(res, 1);
ta = get_inv(a - 1), tb = get_inv(b - 1);
for (int i = 0; i < nn; i++) tmp[i] = 1ll * ta[i] * tb[i] % mod;
ntt(tmp, 1);
for (int i = 0; i < nn; i++) {
if (i < nn / 2)
res[i + 1] += tmp[i], rel(res[i + 1]);
else
res[i] = 0;
}
return res;
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
nn = 1;
while (nn <= 2 * k) nn *= 2, B++;
invnn = pw(nn, mod - 2);
for (int ii = 0, len = 2; len <= nn; len *= 2, ii++) {
ww[ii][0] = invww[ii][0] = 1;
ww[ii][1] = pw(W, N / len);
invww[ii][1] = pw(ww[ii][1], mod - 2);
for (int i = 2; i < len / 2; i++) {
ww[ii][i] = 1ll * ww[ii][i - 1] * ww[ii][1] % mod;
invww[ii][i] = 1ll * invww[ii][i - 1] * invww[ii][1] % mod;
}
}
vector<int> res = get(n);
for (int i = 1; i <= k; i++) cout << res[i] << ' ';
cout << '\n';
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n1, k1;
while (cin >> n1 >> k1) {
long long cnt = 0;
if (k1 % 2 == 1)
cout << 1;
else {
while (k1 % 2 == 0) {
k1 /= 2;
cnt++;
}
cout << cnt + 1;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int v[1000];
int parent[1000];
int r[1000];
void make_set(int v) {
parent[v] = v;
r[v] = 0;
}
int find_set(int v) {
if (parent[v] == v) {
return v;
}
return parent[v] = find_set(parent[v]);
}
void make_pair(int a, int b) {
int pa = find_set(a);
int pb = find_set(b);
if (r[pa] < r[pb]) {
swap(pa, pb);
}
parent[pb] = pa;
r[pa] = r[pa] + r[pb];
}
int main() {
int t;
cin >> t;
int k = t;
for (int i = 0; i < t; i++) {
make_set(i);
}
int y[t], z[t];
int counter = 0;
t--;
while (t--) {
int a, b;
cin >> a >> b;
if (find_set(a - 1) != find_set(b - 1)) {
make_pair(a - 1, b - 1);
} else {
y[counter] = a;
z[counter] = b;
counter++;
}
}
counter--;
if (counter == -1) {
cout << 0;
return 0;
}
cout << counter + 1 << endl;
for (int i = 1; i < k; i++) {
if (find_set(i) != find_set(0)) {
cout << y[counter] << " " << z[counter] << " " << i + 1 << " " << 1
<< endl;
counter--;
make_pair(i, 0);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000 + 10;
int N, M;
int R, C;
int X, Y;
char A[MAXN][MAXN];
pair<int, int> dis[MAXN][MAXN];
deque<pair<int, int> > q;
int fx[4] = {0, -1, 0, 1};
int fy[4] = {-1, 0, 1, 0};
int ans;
inline void push(int first, int second, int l, int r, int t) {
if (A[first][second] == '.' && dis[first][second].first == -1 && l <= X &&
r <= Y) {
dis[first][second] = pair<int, int>(l, r);
if (t)
q.push_front(pair<int, int>(first, second));
else
q.push_back(pair<int, int>(first, second));
}
}
int main() {
register int i;
scanf("%d%d", &N, &M);
scanf("%d%d", &R, &C);
scanf("%d%d", &X, &Y);
for (i = 1; i <= N; ++i) scanf("%s", A[i] + 1);
memset(dis, -1, sizeof(dis));
q.push_front(pair<int, int>(R, C));
dis[R][C] = pair<int, int>(0, 0);
while (!q.empty()) {
pair<int, int> now = q.front();
q.pop_front();
++ans;
for (i = 0; i < 4; ++i)
push(now.first + fx[i], now.second + fy[i],
dis[now.first][now.second].first + (fy[i] == -1),
dis[now.first][now.second].second + (fy[i] == 1), fy[i] == 0);
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, val, inc;
cin >> n >> k;
val = k / n;
inc = k % n;
vector<int> v(n, val);
for (int i = n - inc; i < n; ++i) ++v[i];
int c;
for (int i = 0; i < n; ++i) {
c = 0;
for (int j = i; c < n; ++c) {
cout << v[(j + c) % n] << " ";
}
endl(cout);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b;
cin >> r >> g >> b;
cout << max(
27 + 3 * ((int)ceil(r / 2.0)),
max(28 + 3 * ((int)ceil(g / 2.0)), 29 + 3 * ((int)ceil(b / 2.0))));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1000000007;
typedef struct NUM {
int v;
int cnt;
} NUM;
NUM num[10005];
int cnt;
int a[1000005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
int w, h;
scanf("%d", &n);
for (int i = 0; i <= n - 1; i += 1) scanf("%d", &a[i]);
sort(a, a + n);
cnt = 0;
for (int i = 0; i <= n - 1; i += 1) {
if (!cnt || a[i] != num[cnt - 1].v) {
num[cnt].v = a[i];
num[cnt].cnt = 1;
cnt++;
} else
num[cnt - 1].cnt++;
}
h = -1;
w = -1;
int l, r;
for (int i = 0; i <= cnt - 1; i += 1) {
if (num[i].cnt <= 1)
continue;
else if (num[i].cnt >= 4) {
w = num[i].v;
h = num[i].v;
break;
}
l = r;
r = num[i].v;
if (h == -1) {
h = num[i].v;
continue;
}
if (w == -1) {
w = num[i].v;
continue;
}
if (1.0 * r / l < 1.0 * w / h) {
w = r;
h = l;
}
}
printf("%d %d %d %d\n", w, w, h, h);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long p[55];
long long ans;
long long n;
long long h;
void dfs(long long x, long long lev, long long dir) {
ans++;
if (lev == h) return;
long long a, b, c, e, z, l, r, lch, rch;
lch = (x - 1) * 2 + 1;
rch = x * 2;
if (!dir) {
l = (lch - 1) * p[h - lev - 1] + 1;
r = lch * p[h - lev - 1];
if (n >= l && n <= r) {
dfs(lch, lev + 1, 1);
} else {
ans = ans + ((p[h - lev])) - 1;
dfs(rch, lev + 1, 0);
}
} else {
l = (rch - 1) * p[h - lev - 1] + 1;
r = rch * p[h - lev - 1];
if (n >= l && n <= r) {
dfs(rch, lev + 1, 0);
} else {
ans = ans + ((p[h - lev])) - 1;
dfs(lch, lev + 1, 1);
}
}
}
int main() {
long long a, b, c, d, e, x, y, z;
for (a = 0; a <= 52; a++) p[a] = (1LL << a);
cin >> h >> n;
ans = 0;
dfs(1, 0, 0);
cout << ans - 1 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int oo = 2139063143;
const int N = 101000;
const int P = 1000000007;
using namespace std;
inline void sc(int &x) {
x = 0;
static int p;
p = 1;
static char c;
c = getchar();
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = getchar();
}
x *= p;
}
inline void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
inline void pr(int x) { print(x), putchar('\n'); }
struct TREE {
int ls, rs, w;
} t[N * 40];
int rt[N], totp = 0;
int change(int pre, int l, int r, int w, int d) {
int p = ++totp;
t[p] = t[pre];
t[p].w += d;
if (l == r) return p;
int mid = (l + r) >> 1;
if (w <= mid)
t[p].ls = change(t[pre].ls, l, mid, w, d);
else
t[p].rs = change(t[pre].rs, mid + 1, r, w, d);
return p;
}
int query(int p, int l, int r, int L) {
if (L <= l) return t[p].w;
int mid = (l + r) >> 1, ans = 0;
if (L <= mid)
return query(t[p].ls, l, mid, L) + t[t[p].rs].w;
else
return query(t[p].rs, mid + 1, r, L);
return ans;
}
int n, k;
int calc(int l, int r) { return query(rt[r], 1, n, l); }
int a[N];
int f[N], g[N];
void solve(int wl, int wr, int l, int r) {
int mid = (l + r) >> 1, pos = 0;
f[mid] = 0;
for (int i = wl; i <= min(wr, mid - 1); i++) {
int sb = g[i] + calc(i + 1, mid);
if (sb > f[mid]) f[mid] = sb, pos = i;
}
if (l == r) return;
if (l < mid) solve(wl, pos, l, mid - 1);
if (r > mid) solve(pos, wr, mid + 1, r);
}
int las[N];
int main() {
sc(n), sc(k);
for (int i = 1; i <= n; i++) {
sc(a[i]);
int pre = rt[i - 1];
if (las[a[i]]) rt[i] = change(pre, 1, n, las[a[i]], -1), pre = rt[i];
rt[i] = change(pre, 1, n, i, 1);
las[a[i]] = i;
}
for (int i = 1; i <= k; i++) {
solve(0, n, 1, n);
memcpy(g, f, sizeof(int) * (n + 1));
}
pr(f[n]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;
const int N = 1010;
int a[N], b[N], n, k;
int findZero() {
for (int i = 1; i <= n; i++)
if (!b[i]) return i;
return -1;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) {
int t = findZero();
assert(t != -1);
b[t] = -1;
a[i] = t;
for (int j = 1; j <= t - k; j++) b[j]--;
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int maxDig(long long int n) {
long long int maxDig = 0;
while (n) {
if (n % 10LL > maxDig) maxDig = n % 10LL;
n /= 10;
}
return maxDig;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(7);
{
long long int n;
cin >> n;
long long int cnt = 0;
while (n) {
n -= maxDig(n);
cnt++;
}
cout << cnt << "\n";
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char str1[200005], str2[200005];
bool cmp(int l, int r, int l1, int r1) {
int i, j;
for (i = l, j = l1; i <= r; i++, j++)
if (str1[i] != str2[j]) return false;
return true;
}
bool check(int l, int r, int l1, int r1) {
if (cmp(l, r, l1, r1)) return true;
if ((r - l) % 2 == 0) return false;
int mid = (l + r) >> 1, mid1 = (l1 + r1) >> 1;
return (check(l, mid, mid1 + 1, r1) && check(mid + 1, r, l1, mid1)) ||
(check(l, mid, l1, mid1) && check(mid + 1, r, mid1 + 1, r1));
}
int main() {
int n, a[6], ans, i, t1, t2;
scanf("%s%s", str1, str2);
int l = strlen(str1);
printf("%s\n", check(0, l - 1, 0, l - 1) ? "YES" : "NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long inv[200005];
long long power(long long x, long long y) {
long long ans = 1;
for (; y; y >>= 1) {
if (y & 1) ans = ans * x % mod;
x = x * x % mod;
}
return ans % mod;
}
int main() {
long long a1, a2, a3;
scanf("%lld %lld %lld", &a1, &a2, &a3);
inv[1] = 1;
long long m = a1 - 1;
for (int i = 2; i <= 200000; i++)
inv[i] = ((long long)(mod - mod / i) * (long long)inv[mod % i]) % mod;
long long zhuhe = 1;
long long nn = a3;
for (int i = 1; i <= nn; i++)
zhuhe = (zhuhe * (long long)(m - i + 1) % mod * inv[i]) % mod;
long long ans = (a2 * ((zhuhe * power(a2 - 1, a3)) % mod)) % mod;
printf("%lld", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[100010], S = 0;
long long A = 0, B = 0, ca = 0, cb = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
S += a[i];
}
double h = (double)S / 2.0;
for (long long i = 0; i < n; i++) {
if ((double)(A + a[i]) <= h)
A += a[i], ca++;
else
break;
}
for (long long i = n - 1; i >= 0; i--) {
if ((double)(B + a[i]) <= h)
B += a[i], cb++;
else
break;
}
if (ca + cb < n) {
if (B < A)
cb++;
else
ca++;
}
cout << ca << ' ' << cb << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[5005][5005];
int ans[5005][5005];
int solve(int l, int r) {
if (dp[l][r]) {
return dp[l][r];
}
if (l == r) {
return dp[l][r] = ans[l][r];
} else {
return dp[l][r] = max({ans[l][r], solve(l, r - 1), solve(l + 1, r)});
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
cin >> ans[i][i];
}
for (int i = 1; i < n; i++) {
for (int j = 1; j <= n - i; j++) {
ans[j][j + i] = ans[j][j + i - 1] ^ ans[j + 1][j + i];
}
}
for (int i = 1; i < n + 1; i++) {
dp[i][i] = ans[i][i];
}
for (int i = 1; i < n; i++) {
for (int j = 1; j <= n - i; j++) {
dp[j][j + i] = max({dp[j][j + i - 1], dp[j + 1][j + i], ans[j][j + i]});
}
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
cout << dp[l][r] << '\n';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5 * 100 + 5;
const long long inf = 9223372036854775807;
long long dp[2][maxn][maxn], n, m, b, mod, a[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> b >> mod;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[0][0][0] = 1;
for (int j = 1; j <= n; j++) {
for (int i = 0; i <= m; i++) {
for (int k = 0; k <= b; k++) {
dp[j % 2][i][k] = 0;
}
}
for (int i = 0; i <= m; i++) {
for (int k = 0; k <= b; k++) {
dp[j % 2][i][k] += dp[1 - (j % 2)][i][k] % mod;
if (k >= a[j] && i > 0) {
dp[j % 2][i][k] += dp[j % 2][i - 1][k - a[j]] % mod;
}
dp[j % 2][i][k] = dp[j % 2][i][k] % mod;
}
}
}
long long sum = 0;
for (int i = 0; i <= b; i++) {
sum += dp[n % 2][m][i];
}
cout << sum % mod;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int MAXM = 100010;
const int INF = 0x3f3f3f3f;
int n, m, tot, head[MAXN], one, zero, ans;
struct edge {
int u, v, w, c, next, flag;
edge() {}
edge(int uu, int vv, int ww, int cc, int nx)
: u(uu), v(vv), w(ww), c(cc), next(nx) {
flag = 0;
}
} e[MAXM << 1];
int d1[MAXN], val1[MAXN], p1[MAXN];
int d2[MAXN], val2[MAXN], p2[MAXN];
bool done[MAXN];
inline void add(int u, int v, int w, int c) {
e[tot] = edge(u, v, w, c, head[u]);
head[u] = tot++;
}
void dij(int S, int *d, int *val, int *p) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
for (int i = 1; i <= n; i++) {
d[i] = INF;
val[i] = -1;
p[i] = -1;
done[i] = false;
}
d[S] = 0, val[S] = 0;
que.push(make_pair(d[S], S));
while (!que.empty()) {
pair<int, int> elem = que.top();
int u = elem.second;
que.pop();
if (done[u]) continue;
done[u] = true;
for (int k = head[u]; k != -1; k = e[k].next) {
int v = e[k].v, w = e[k].w, c = e[k].c;
if (d[u] + w < d[v] || (d[u] + w == d[v] && val[u] + c > val[v])) {
d[v] = d[u] + w;
val[v] = val[u] + c;
p[v] = k;
que.push(make_pair(d[v], v));
}
}
}
}
void find_path(int S, int *p) {
int eid = p[S];
while (eid != -1) {
int u = e[eid].u, v = e[eid].v, c = e[eid].c;
e[eid].flag = e[eid ^ 1].flag = 1;
S = u == S ? v : u;
if (c == 0)
ans++;
else
ans--;
eid = p[S];
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
tot = one = zero = ans = 0;
memset(head, -1, sizeof head);
while (m--) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
add(u, v, 1, c);
add(v, u, 1, c);
if (c == 1)
one++;
else
zero++;
}
dij(1, d1, val1, p1);
dij(n, d2, val2, p2);
int sp = INF, mv = 0, id = 1;
for (int i = 1; i <= n; i++) {
if (d1[i] + d2[i] < sp ||
(d1[i] + d2[i] == sp && val1[i] + val2[i] >= mv)) {
sp = d1[i] + d2[i];
mv = val1[i] + val2[i];
id = i;
}
}
ans = one;
find_path(id, p1);
find_path(id, p2);
printf("%d\n", ans);
for (int i = 0; i < tot; i += 2) {
if (e[i].flag && !e[i].c) printf("%d %d %d\n", e[i].u, e[i].v, 1);
if (!e[i].flag && e[i].c) printf("%d %d %d\n", e[i].u, e[i].v, 0);
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, x;
cin >> n >> m >> x;
vector<vector<long long>> g(n, vector<long long>(m));
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) cin >> g[i][j];
long long ansv = 0, ansc = 0;
for (long long i = 0; i < m; i++) {
long long ind = 0, mxv = 0, mxc = 0;
while (ind < n and g[ind][i] == 0) ind++;
for (long long j = ind; j < min(ind + x, n); j++) mxv += (g[j][i] == 1);
for (long long j = 0; j < n; j++) {
long long v = 0, c = 0;
for (long long k = 0; k <= j; k++) c += (g[k][i] == 1);
long long kx = j + 1;
while (kx < n and g[kx][i] == 0) kx++;
for (long long k = kx; k < min(kx + x, n); k++) v += (g[k][i] == 1);
if (v > mxv) {
mxv = v;
mxc = c;
} else if (v == mxv)
mxc = min(mxc, c);
}
ansv += mxv;
ansc += mxc;
}
cout << ansv << " " << ansc << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int pel(string s) {
string t;
t = s;
reverse(t.begin(), t.end());
if (s == t) return 1;
return 0;
}
string toString(int n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
bool isprime(int m) {
if (m < 2) return 0;
for (int i = 2; i * i <= m; i++)
if (m % i == 0) return 0;
return 1;
return 0;
}
inline bool iseq(double x, double y) {
if (fabs(x - y) < 1e-8) return true;
return false;
}
template <typename T>
inline double hpt(T x1, T y1, T x2, T y2) {
return hypot(x1 - x2, y1 - y2);
}
template <typename T>
inline T gcd(T a, T b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
template <typename T>
inline void extended_euclid(T a, T b, T &x, T &y) {
if (a % b == 0)
x = 0, y = 1;
else {
extended_euclid(b, a % b, x, y);
T temp = x;
x = y;
y = -y * (a / b) + temp;
}
}
template <typename T>
inline T bigmod(T b, T p, T m) {
if (!p)
return 1;
else if (!(p % 2)) {
T x = bigmod(b, p / 2, m);
return x * x;
} else
return ((b % m) * bigmod(b, p - 1, m)) % m;
}
int prime[5 / 32 + 1];
void setbit(int i) {
int p = i >> 5, q = i & 31;
prime[p] |= (1 << q);
}
bool checkbit(int i) {
int p = i >> 5, q = i & 31;
return prime[p] & (1 << q) ? true : false;
}
void buildprime(int n) {
int i, j, k = sqrt(double(n));
prime[0] = 3;
for (i = 4; i < n; i += 2) setbit(i);
for (i = 3; i <= k; i += 2) {
if (!checkbit(i)) {
int ii = i + i;
for (j = i * i; j < n; j += ii) setbit(j);
}
}
}
long long nCr(int n, int m) {
long int k;
register int i, j;
double c, d;
c = d = 1;
k = (m > (n - m)) ? m : (n - m);
for (j = 1, i = k + 1; (i <= n); i++, j++) {
c *= i;
d *= j;
if (!fmod(c, d) && (d != 1)) {
c /= d;
d = 1;
}
}
return c;
}
int main() {
int test, Case = 0;
int boys, girls, total;
cin >> boys >> girls >> total;
long long res = 0;
for (int i = 4; i <= boys; i++) {
for (int j = 1; j <= girls; j++) {
if (i + j == total) {
res += (nCr(boys, i) * nCr(girls, j));
}
}
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200000;
int n, nbox, boxsz;
int a[MAXN];
long long sum[MAXN + 1];
int nxt[MAXN];
int need[MAXN + 1];
int solve() {
sum[0] = 0;
for (int i = (0); i < (n); ++i) sum[i + 1] = sum[i] + a[i];
int to = 0;
for (int at = (0); at < (n); ++at) {
while (to < n && sum[to + 1] - sum[at] <= boxsz) ++to;
nxt[at] = to;
}
need[n] = 0;
for (int i = n - 1; i >= 0; --i) need[i] = 1 + need[nxt[i]];
for (int i = (0); i <= (n); ++i)
if (need[i] <= nbox) return n - i;
return 0;
}
void run() {
scanf("%d%d%d", &n, &nbox, &boxsz);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
printf("%d\n", solve());
}
int main() {
run();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<int> global;
void DFS(int parent, int current, int depth, vector<vector<int>>& graph,
int& max_depth, int& max_ind) {
for (int i = 0; i < graph[current].size(); i++)
if (graph[current][i] != parent)
DFS(current, graph[current][i], depth + 1, graph, max_depth, max_ind);
if (depth > max_depth) {
max_ind = current;
max_depth = depth;
}
}
int modified_DFS(int parent, int current, int depth,
vector<vector<int>>& graph) {
vector<int> ds;
for (int i = 0; i < graph[current].size(); i++) {
if (graph[current][i] != parent) {
ds.push_back(modified_DFS(current, graph[current][i], depth + 1, graph));
}
}
if (ds.size() > 0) {
sort(ds.begin(), ds.end());
int max = ds[ds.size() - 1];
for (int j = 0; j < ds.size() - 1; j++) global.push_back(ds[j] - depth);
if (parent > 0)
return max;
else {
global.push_back(max);
return max;
}
} else {
return depth;
}
}
int main() {
int n, from, to;
cin >> n;
vector<vector<int>> graph(n + 1, vector<int>());
for (int i = 0; i < n - 1; i++) {
cin >> from >> to;
graph[from].push_back(to);
graph[to].push_back(from);
}
int max_ind = -1, max_d = -1;
DFS(-1, 1, 0, graph, max_d, max_ind);
modified_DFS(-1, max_ind, 0, graph);
sort(global.begin(), global.end());
int counter = 0, res = 1;
cout << res << " ";
while (counter < n - 1) {
if (counter < global.size()) {
res += global[global.size() - counter - 1];
cout << res << " ";
} else
cout << n << ' ';
counter++;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long arr[3];
for (long long i = 0; i < 3; i++) cin >> arr[i];
sort(arr, arr + 3);
if (arr[0] + arr[1] < arr[2])
cout << arr[0] + arr[1] << endl;
else
cout << (arr[0] + arr[1] + arr[2]) / 2 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, nh[1000005], sum[1000005], t[1000005], p, root;
pair<int, int> kq;
vector<pair<int, int> > a[1000005];
void home() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
void dfs(int u, int p) {
sum[u] += t[u];
if (a[u].size())
for (int j = (0); j <= (a[u].size() - 1); ++j) {
int v = a[u][j].first;
if (v == p) continue;
dfs(v, u);
sum[u] += sum[v];
}
}
void cal(int u, int p) {
vector<int> vc;
if (a[u].size())
for (int j = (0); j <= (a[u].size() - 1); ++j) {
int v = a[u][j].first;
if (v == p) continue;
cal(v, u);
if (sum[v] == sum[root] / 3 && !nh[v]) nh[v] = a[u][j].second;
if (nh[v]) vc.push_back(nh[v]);
if (sum[v] == sum[root] - sum[root] / 3 && nh[v] &&
nh[v] != a[u][j].second)
kq = pair<int, int>(a[u][j].second, nh[v]);
}
if (vc.size() >= 2) kq = pair<int, int>(vc[0], vc[1]);
if (vc.size()) nh[u] = vc[0];
}
int main() {
home();
cin >> n;
for (int i = (1); i <= (n); ++i) {
cin >> p >> t[i];
if (p == 0)
root = i;
else
a[p].push_back(pair<int, int>(i, i)),
a[i].push_back(pair<int, int>(p, i));
}
dfs(root, 0);
if (sum[root] % 3)
cout << -1;
else {
cal(root, 0);
if (kq == pair<int, int>(0, 0))
cout << -1;
else
cout << kq.first << " " << kq.second;
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int i, j, k;
cin >> k;
if (k == 1) {
cout << "-1\n";
} else {
int a[k];
a[0] = 2;
for (i = 1; i < k; i++) {
a[i] = 3;
}
for (i = 0; i < k; i++) {
cout << a[i];
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n, k;
inline void oil_read(std::istream& r) { r >> n >> k; }
inline int oil_eval(int v) {
int result = 0;
int dev = v;
while (dev > 0) {
result += dev;
dev /= k;
}
return result;
}
inline void oil_print(std::ostream& w, int i) { w << i << std::endl; }
inline void oil_solve(std::istream& r, std::ostream& w) {
int high, low, mid;
int result = 0;
oil_read(r);
if (n < k) {
oil_print(w, n);
return;
}
high = n + 1;
low = k - 1;
while (result != n) {
if (mid == low) {
oil_print(w, mid);
break;
}
mid = (high - low) / 2 + low;
result = oil_eval(mid);
if (result == n) {
oil_print(w, mid);
break;
} else if (result > n) {
high = mid - 1;
} else if (result < n) {
low = mid + 1;
}
}
return;
}
int main() {
using namespace std;
oil_solve(cin, cout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<double, int> cnt;
double d[200010];
double solve(char s[]) {
int a = 0, b = 0, c = 0;
int now = 1;
for (; s[now] != '+'; now++) {
a *= 10;
a += s[now] - '0';
}
for (now++; s[now] != ')'; now++) {
b *= 10;
b += s[now] - '0';
}
for (now += 2; s[now]; now++) {
c *= 10;
c += s[now] - '0';
}
return ((double)a + b) / c;
}
int main() {
int m;
scanf("%d", &m);
char s[50];
for (int i = 1; i <= m; i++) {
scanf("%s", s);
d[i] = solve(s);
cnt[d[i]]++;
}
for (int i = 1; i <= m; i++) {
printf("%d ", cnt[d[i]]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v;
vector<int> ans;
vector<int> visited;
priority_queue<int, vector<int>, greater<int> > p;
void dfs(int curr) {
for (int i = 0; i < v[curr].size(); i++) {
int k = v[curr][i];
if (visited[k] == 0) {
p.push(k);
visited[k] = 1;
}
}
}
int main() {
long long n, m;
cin >> n >> m;
v.resize(n);
visited.resize(n);
for (int i = 0; i < n; i++) visited[i] = 0;
for (int i = 0; i < m; i++) {
int k, l;
cin >> k >> l;
k--;
l--;
v[k].push_back(l);
v[l].push_back(k);
}
p.push(0);
visited[0] = 1;
while (!p.empty()) {
int k = p.top();
p.pop();
ans.push_back(k);
dfs(k);
}
for (int i = 0; i < n; i++) cout << ans[i] + 1 << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int mod0 = 1e9 + 7;
const long long mod1 = 998244353;
const long long mod2 = 1e9 + 9;
const long long mod3 = 2147483647;
const int sz = 2 * 1024 * 1024;
const long long inf = 2 * 1024 * 1024 * 1023 - 1;
const long long INF = inf * inf;
const double eps = 1e-6;
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(16);
}
const int N = 4e4 + 4;
void solve() {
int n;
cin >> n;
vector<vector<double> > a(n, vector<double>(3));
vector<vector<double> > d(n, vector<double>(n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j) cin >> a[i][j];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
double dx = a[i][0] - a[j][0], dy = a[i][1] - a[j][1],
dz = a[i][2] - a[j][2];
d[i][j] = sqrt(dx * dx + dy * dy + dz * dz);
}
}
double ans = 1e12;
for (int i = 1; i < n; ++i) {
for (int j = 1; j < n; ++j) {
if (i == j) continue;
ans = min(ans, (d[0][i] + d[0][j] + d[i][j]) / 2);
}
}
cout << ans << '\n';
}
bool multitest = false;
int main() {
init();
int t = 1;
if (multitest) cin >> t;
for (int i = 0; i < t; ++i) solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int main() {
int t, m, n, q;
cin >> n >> m;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
if (x > y) swap(x, y);
a[x]++;
if (a[x] == 1) cnt++;
}
cin >> q;
while (q--) {
int te;
cin >> te;
if (te == 1) {
int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
a[u]++;
if (a[u] == 1) cnt++;
} else if (te == 2) {
int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
a[u]--;
if (a[u] == 0) cnt--;
} else {
printf("%d\n", n - cnt);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
void print(int a, int b) {
printf("%d %d ", a, b);
return;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int dir = 1, x = 1, y = 1;
for (int i = 1; i <= k - 1; i++) {
printf("2 ");
if (dir == 1) {
if (y <= m - 1) {
print(x, y);
print(x, y + 1);
y += 2;
if (y == m + 1) y = m, x++, dir = 2;
} else
print(x, y), print(x + 1, y), x++, y--, dir = 2;
} else {
if (y >= 2) {
print(x, y);
print(x, y - 1);
y -= 2;
if (y == 0) x++, y = 1, dir = 1;
} else
print(x, y), print(x + 1, y), x++, y++, dir = 1;
}
puts("");
}
int cnt = n * m - 2 * (k - 1);
printf("%d ", cnt);
while (cnt >= 1) {
if (dir == 1) {
print(x, y);
y++;
if (y > m) x++, y = m, dir = 2;
} else {
print(x, y);
y--;
if (y == 0) x++, y = 1, dir = 1;
}
cnt--;
}
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, target;
cin >> n >> target;
int adjList[n];
for (int i = 0; i < n - 1; i++) {
cin >> adjList[i];
}
int pos = 0;
target--;
while (pos < target) {
pos += adjList[pos];
}
if (pos == target) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t;
long long k;
int main() {
ios::sync_with_stdio(0);
cin >> t;
while (t--) {
cin >> k;
long long l = 0, pv = 0, p10 = 10, len = 1;
while (1729) {
l++;
if (l == p10) len++, p10 *= 10;
pv += len;
if (k > pv)
k -= pv;
else {
p10 = 10, len = 1;
for (int i = 1;; i++) {
if (i == p10) len++, p10 *= 10;
if (k > len)
k -= len;
else {
cout << to_string(i)[k - 1] << "\n";
break;
}
}
break;
}
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5e6;
const long long mod = 1e9 + 7;
mt19937 gen(time(0));
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
long long x1 = 0, x2 = 0, y1 = 0, y2 = 0;
for (long long i = 0; i < n; ++i) {
long long k;
cin >> k;
if (k % 2 == 0)
x1++;
else
y1++;
}
for (long long i = 0; i < m; ++i) {
long long k;
cin >> k;
if (k % 2 == 0)
x2++;
else
y2++;
}
cout << min(x1, y2) + min(x2, y1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int inf = 0x3f3f3f3f;
char s1[N], s2[N];
int dis[30][30];
int m;
int main() {
scanf(" %s%s", s1, s2);
scanf("%d", &m);
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
if (i == j)
dis[i][j] == 0;
else
dis[i][j] = inf;
}
}
char ch1, ch2;
int w;
for (int i = 0; i < m; i++) {
scanf(" %c %c%d", &ch1, &ch2, &w);
dis[ch2 - 'a'][ch1 - 'a'] = min(dis[ch2 - 'a'][ch1 - 'a'], w);
}
for (int k = 0; k < 26; k++) {
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
if (dis[i][k] + dis[k][j] < dis[i][j])
dis[i][j] = dis[i][k] + dis[k][j];
}
}
}
int ans = 0;
int len1 = strlen(s1);
int len2 = strlen(s2);
bool flag = true;
if (len1 != len2) flag = false;
string str = "";
for (int i = 0; i < len1 && flag; i++) {
int mi = inf;
char mi_ch;
for (int j = 0; j < 26; j++) {
if (dis[j][s1[i] - 'a'] + dis[j][s2[i] - 'a'] < mi) {
mi = dis[j][s1[i] - 'a'] + dis[j][s2[i] - 'a'];
mi_ch = (char)'a' + j;
}
}
if (mi == inf)
flag = false;
else
ans += mi, str += mi_ch;
}
if (!flag)
puts("-1");
else {
printf("%d\n", ans);
cout << str << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
long long b[100005];
int main() {
int f(int a, int b);
long long maxn;
int n, s = 1;
scanf("%d", &n);
for (int ni = 0; ni < n; ni++) scanf("%lld", &a[ni]);
sort(a, a + n);
for (int mi = 0; mi < n - 1; mi++) b[mi] = a[mi + 1] - a[mi];
sort(b, b + n - 1);
maxn = b[0];
for (int ni = 1; ni < n - 1; ni++) maxn = f(maxn, b[ni]);
s = (a[n - 1] - a[0]) / maxn + 1 - n;
printf("%d", s);
return 0;
}
int f(int a, int b) {
int r, t;
if (a < b) {
t = a;
a = b;
b = t;
}
while (a % b != 0) {
r = a;
a = b;
b = r % b;
}
return b;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int num[15];
int n;
int main() {
num[0] = 2;
num[1] = 7;
num[2] = 2;
num[3] = 3;
num[4] = 3;
num[5] = 4;
num[6] = 2;
num[7] = 5;
num[8] = 1;
num[9] = 2;
cin >> n;
cout << num[n % 10] * num[n / 10] << endl;
return 0;
}
| 3 |
// Problem: B. Replace and Keep Sorted
// Contest: Codeforces - Codeforces Round #701 (Div. 2)
// URL: https://codeforces.com/contest/1485/problem/B
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//code by: Ravi Khatri @Ravi_Orz
#include<bits/stdc++.h>
#define ll long long
#define vi vector<int>
#define vll vector<ll>
#define F first
#define S second
#define pb push_back
#define f(i,s,n) for(int i=(int)s;i<=(int)n;++i)
#define fr(i,n,s) for(int i=(int)n;i>=s;--i)
#define all(v) v.begin(),v.end()
#define sz(v) (int)v.size()
#define Fast ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
using namespace std;
#define mod 1000000007
ll n,m,l,r,x;
ll a[1000006];
ll b[1000006];
vi g[1000006];
void solve()
{
int n,q,k;
cin>>n>>q>>k;
vll a(n);
f(i,0,n-1)cin>>a[i];
vll b(n);
f(i,0,n-2){
if(i==0){
b[i]=a[i]-1 + a[i+1]-1-a[i];
}
else{
b[i]=a[i]-(a[i-1]+1) + a[i+1]-1-a[i];
}
}
b[n-1]=k-a[n-1]+a[n-1]-(a[n-2]+1);
vll prefb(n);
prefb[0]=b[0];
//cout<<prefb[0]<<" ";
for(int i=1;i<n;i++){
prefb[i]=prefb[i-1]+b[i];
//cout<<prefb[i]-prefb[i-1]<<" ";
}
// cout<<'\n';
while(q--){
int l,r;cin>>l>>r;
--l,--r;
ll ans=0;
if(r-l==1){
ans=k-a[r]+a[r]-(a[l]+1)+a[l]-1+a[r]-1-a[l];
}
else if(l==r){
cout<<k-1<<'\n';
continue;
}
else
ans=a[l]-1+a[l+1]-1-a[l] +k-a[r]+a[r]-1-a[r-1]+(prefb[r-1]-prefb[l]);
cout<<ans<<'\n';
}
}
int main()
{ Fast;
// int t;cin>>t;
// while(t--)
solve();
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s1[1001], s2[1001];
scanf("%s %s", s1, s2);
int l1 = strlen(s1), l2 = strlen(s2);
int a[1001][1001];
for (int i = 0; i <= l1; i++) a[i][0] = i;
for (int i = 1; i <= l2; i++) a[0][i] = i;
for (int i = 1; i <= l1; i++)
for (int j = 1; j <= l2; j++)
a[i][j] = min(min(a[i - 1][j], a[i][j - 1]) + 1,
a[i - 1][j - 1] + (s1[i - 1] != s2[j - 1]));
printf("%d\n", a[l1][l2]);
int b[2002];
int i = 0;
while (l1 || l2) {
if (l1 && (a[l1][l2] == (a[l1 - 1][l2] + 1))) {
b[i] = 1;
l1--;
} else if (l2 && (a[l1][l2] == (a[l1][l2 - 1] + 1))) {
b[i] = 2;
l2--;
} else {
if (s1[l1 - 1] == s2[l2 - 1])
b[i] = 0;
else
b[i] = 3;
l1--;
l2--;
};
i++;
};
char w[][8] = {"", "DELETE", "INSERT", "REPLACE"};
int j = 1;
while (i) {
i--;
if (b[i]) {
printf("%s %d", w[b[i]], j);
if (b[i] != 1)
printf(" %c\n", s2[j++ - 1]);
else
printf("\n");
} else
j++;
};
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct Range {
int L, R;
Range(int l, int r) : L(l), R(r) {}
};
struct Comp {
bool operator()(Range const& a, Range const& b) {
if ((a.R - a.L + 1) == (b.R - b.L + 1)) return a.L > b.L;
return (a.R - a.L + 1) < (b.R - b.L + 1);
}
};
int main() {
std::ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> Ans(n + 1);
Ans.assign(n + 1, 0);
priority_queue<Range, vector<Range>, Comp> Q;
Q.push(Range(1, n));
int val = 1;
while (!Q.empty()) {
Range a(0, 0);
a = Q.top();
Q.pop();
int mid, L = a.L, R = a.R;
if ((R - L + 1) % 2 == 0)
mid = (L + R - 1) / 2;
else
mid = (L + R) / 2;
Ans[mid] = val;
if (L <= mid - 1) Q.push(Range(L, mid - 1));
if (mid + 1 <= R) Q.push(Range(mid + 1, R));
val += 1;
}
for (int i = 1; i <= n; i++) cout << Ans[i] << " ";
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long b,
long long mod = (long long)(1e9 + 7)) {
if (!b) return 1;
a %= mod;
return modpow(a * a % mod, b / 2, mod) * (b & 1 ? a : 1) % mod;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int mxn = 1e6;
int n;
int a[mxn];
vector<pair<long long, long long> > minqueue, maxqueue;
long long dp[mxn];
void solve() {
for (int i = 0; i < mxn; i++) dp[i] = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
dp[i] = i ? dp[i - 1] : 0;
while (int((minqueue).size()) && minqueue.back().second <= a[i])
minqueue.pop_back();
while (int((maxqueue).size()) && maxqueue.back().second >= a[i])
maxqueue.pop_back();
if (int((minqueue).size()))
(dp[i]) = max((dp[i]), (minqueue.back().first - a[i]));
if (int((maxqueue).size()))
(dp[i]) = max((dp[i]), (maxqueue.back().first + a[i]));
if (!int((minqueue).size()) ||
minqueue.back().first < (i ? dp[i - 1] : 0) + a[i])
minqueue.push_back(
pair<long long, long long>((i ? dp[i - 1] : 0) + a[i], a[i]));
if (!int((maxqueue).size()) ||
maxqueue.back().first < (i ? dp[i - 1] : 0) - a[i])
maxqueue.push_back(
pair<long long, long long>((i ? dp[i - 1] : 0) - a[i], a[i]));
}
cout << dp[n - 1] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<int, int> m1;
vector<pair<int, int>> vec;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
vec.push_back({a, b});
}
int ans = 0;
for (int i = 0; i < n; i++) {
int a = vec[i].first;
bool found = false;
for (int j = 0; j < n; j++) {
if (j != i) {
if (a == vec[j].second) {
found = true;
break;
}
}
}
if (!found) ans++;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " | ";
err(++it, args...);
}
vector<long long int> v1, v2;
string s1, s2, s3;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int a, b, c, d, e, f, i, j, k, m, n,
cnt1 = 0, cnt2 = 0, sum1 = 0, sum2 = 0, chk1 = 0, chk2 = 0, T;
cin >> T;
while (T--) {
v1.clear();
for (i = 0; i < 3; i++) {
cin >> b;
v1.push_back(b);
}
sort(v1.begin(), v1.end());
cout << v1.back() + 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int n, m, head[5005 * 5], level[5005 * 5],
cnt = 0, max_idx = 0, s, t, pos[5005], wp_num[5005 * 5], jud_num[5005 * 5];
int ship[5005][3], res[5005], omg_cnt[5005];
struct Node1 {
int l, r;
} T[5005 * 4];
struct Node2 {
int nxt, to, cap;
} Edges[5005 * 400];
void addedge(int u, int v, int c) {
Edges[cnt].nxt = head[u];
head[u] = cnt;
Edges[cnt].to = v, Edges[cnt++].cap = c;
}
void insert(int u, int v, int c) {
addedge(u, v, c);
addedge(v, u, 0);
}
bool bfs() {
memset(level, -1, sizeof(level));
queue<int> q;
q.push(s), level[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; ~i; i = Edges[i].nxt) {
int v = Edges[i].to;
if (level[v] == -1 && Edges[i].cap) level[v] = level[u] + 1, q.push(v);
}
}
if (level[t] == -1) return false;
return true;
}
int dfs(int u, int flow) {
int f = 0, d = 0;
if (u == t) return flow;
for (int i = head[u]; ~i && flow > f; i = Edges[i].nxt) {
int v = Edges[i].to;
if (level[v] == level[u] + 1 && Edges[i].cap) {
d = dfs(v, min(flow - f, Edges[i].cap));
f += d;
Edges[i].cap -= d;
Edges[i ^ 1].cap += d;
}
}
if (!f) level[u] = -1;
return f;
}
void build(int idx, int l, int r) {
max_idx = max(max_idx, idx), T[idx].l = l, T[idx].r = r;
if (l == r) {
pos[l] = idx;
jud_num[l] = cnt;
insert(idx, t, 1);
return;
}
int mid = (l + r) >> 1;
build(idx << 1, l, mid), build(idx << 1 | 1, mid + 1, r);
insert(idx, idx << 1, 0x3f3f3f3f), insert(idx, idx << 1 | 1, 0x3f3f3f3f);
}
void add(int idx, int l, int r, int wp) {
if (l <= T[idx].l && r >= T[idx].r) {
insert(wp, idx, 1);
return;
}
int mid = (T[idx].l + T[idx].r) >> 1;
if (l > mid)
add(idx << 1 | 1, l, r, wp);
else if (r <= mid)
add(idx << 1, l, r, wp);
else
add(idx << 1 | 1, l, r, wp), add(idx << 1, l, r, wp);
}
int main() {
memset(head, -1, sizeof(head));
n = read(), m = read();
t = 0, build(1, 1, m), s = ++max_idx;
for (int i = 1; i <= n; i++) {
int typ = read();
wp_num[max_idx + 1] = i;
if (typ == 0) {
insert(s, ++max_idx, 1);
int k = read();
for (int j = 1; j <= k; j++) {
int x = read();
insert(max_idx, pos[x], 1);
}
} else if (typ == 1) {
insert(s, ++max_idx, 1);
int l = read(), r = read();
add(1, l, r, max_idx);
} else {
insert(s, ++max_idx, 2);
ship[i][0] = read(), ship[i][1] = read(), ship[i][2] = read();
insert(max_idx, pos[ship[i][0]], 1);
insert(max_idx, pos[ship[i][1]], 1);
insert(max_idx, pos[ship[i][2]], 1);
}
}
int ans = 0, d;
while (bfs()) {
while (d = dfs(s, 0x3f3f3f3f)) ans += d;
}
printf("%d\n", ans);
for (int i = 1; i <= m; i++) {
if (!Edges[jud_num[i]].cap) {
int p = pos[i];
while (!wp_num[p]) {
for (int j = head[p]; ~j; j = Edges[j].nxt) {
if (j & 1 == 0) continue;
if (Edges[j].cap) {
Edges[j].cap--;
p = Edges[j].to;
break;
}
}
}
res[i] = wp_num[p];
omg_cnt[wp_num[p]]++;
}
}
for (int i = 1; i <= n; i++)
if (ship[i][0] && omg_cnt[i] == 1) {
if (res[ship[i][0]] != i)
res[ship[i][0]] = i;
else if (res[ship[i][1]] != i)
res[ship[i][1]] = i;
else if (res[ship[i][2]] != i)
res[ship[i][2]] = i;
}
for (int i = 1; i <= m; i++)
if (res[i]) printf("%d %d\n", res[i], i);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long st[600000];
long long k[600000];
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
scanf("%d", &st[i]);
}
string s;
cin >> s;
for (long long i = 0; i < n; i++) {
if (s[i] == 'A') {
k[i] = 0;
} else {
k[i] = 1;
}
}
long long res = 0;
long long curres = 0;
for (long long i = 0; i < n; i++) {
if (k[i] == 1) {
curres += st[i];
}
}
long long tmp = curres;
for (long long i = 0; i < n; i++) {
if (curres > res) {
res = curres;
}
if (k[i] == 0) {
curres += st[i];
} else {
curres -= st[i];
}
}
if (curres > res) {
res = curres;
}
curres = tmp;
for (long long i = n - 1; i > -1; i--) {
if (curres > res) {
res = curres;
}
if (k[i] == 0) {
curres += st[i];
} else {
curres -= st[i];
}
}
if (curres > res) {
res = curres;
}
cout << res;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long base = 131;
char s[200005];
vector<long long> v[30];
long long n, m, sum[200005][30], to[30],
b[30] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101};
long long read() {
long long f = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
f = f * 10 + ch - '0';
ch = getchar();
}
return f * w;
}
long long qpow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long inv(long long x) { return qpow(x, mod - 2); }
signed main() {
n = read(), m = read();
scanf("%s", s + 1);
for (long long i = 1; i <= n; i++) {
v[s[i] - 'a' + 1].push_back(i);
for (long long j = 'a'; j <= 'z'; j++) {
if (s[i] == j)
sum[i][j - 'a' + 1] =
(sum[i - 1][j - 'a' + 1] + b[j - 'a' + 1] * qpow(base, i) % mod) %
mod;
else
sum[i][j - 'a' + 1] = sum[i - 1][j - 'a' + 1];
}
}
for (long long i = 1; i <= m; i++) {
memset(to, 0, sizeof(to));
long long x = read(), y = read(), z = read();
long long l1 = x, r1 = x + z - 1, l2 = y, r2 = y + z - 1;
if (x > y) swap(l1, l2), swap(r1, r2);
long long delta = l2 - l1;
for (long long j = 1; j <= 26; j++) {
if (v[j].empty()) continue;
long long pos = upper_bound(v[j].begin(), v[j].end(), r1) - v[j].begin();
if (pos == 0) continue;
if (v[j][pos - 1] < l1)
continue;
else
to[j] = s[v[j][pos - 1] + delta] - 'a' + 1;
}
long long flag = 0;
for (long long j = 1; j <= 26; j++) {
if (!to[j]) continue;
long long val1 =
((sum[r2][to[j]] - sum[l2 - 1][to[j]]) % mod + mod) % mod;
long long val2 = (((sum[r1][j] - sum[l1 - 1][j]) % mod + mod) % mod *
qpow(base, delta) % mod * inv(b[j]) % mod * b[to[j]]) %
mod;
if (val1 != val2) {
flag = 1;
puts("NO");
break;
}
}
if (!flag) puts("YES");
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int M = 2e6 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
long long w[N], k;
int f[N], nx[N][35], n;
long long sum[N][35], mn[N][35];
int main() {
scanf("%d", &n);
scanf("%lld", &k);
for (int i = 0; i < n; i++) scanf("%d", &f[i]);
for (int i = 0; i < n; i++) scanf("%lld", &w[i]);
for (int i = 0; i < n; i++)
nx[i][0] = f[i], sum[i][0] = w[i], mn[i][0] = w[i];
for (int j = 1; j < 35; j++) {
for (int i = 0; i < n; i++) {
nx[i][j] = nx[nx[i][j - 1]][j - 1];
mn[i][j] = min(mn[i][j - 1], mn[nx[i][j - 1]][j - 1]);
sum[i][j] = sum[i][j - 1] + sum[nx[i][j - 1]][j - 1];
}
}
for (int i = 0; i < n; i++) {
int now = i;
long long ans = 0, ret = k, minn = INF;
for (int j = 34; j >= 0; j--) {
if (ret - (1ll << j) >= 0) {
ret -= (1ll << j);
ans += sum[now][j];
minn = min(minn, mn[now][j]);
now = nx[now][j];
}
}
printf("%lld %lld\n", ans, minn);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> q, e, s, cur, temp, old;
bool d[105][105] = {false};
int mem[105][105] = {0};
void first() {
for (int i = 1; i <= n; i++) temp[i] = cur[q[i]];
cur = temp;
}
void second() {
for (int i = 1; i <= n; i++) temp[i] = cur[e[i]];
cur = temp;
}
bool dfs(int i, int j) {
if (mem[i][j] != -1) return mem[i][j];
bool da1 = false;
bool da2 = false;
if (i && !d[i - 1][j]) da1 = dfs(i - 1, j);
if (j && !d[i][j - 1]) da2 = dfs(i, j - 1);
mem[i][j] = da1 || da2;
return da1 || da2;
}
int main() {
cin >> n >> k;
q.resize(n + 1);
;
e.resize(n + 1);
;
temp.resize(n + 1);
;
cur.resize(n + 1);
;
s.resize(n + 1);
;
for (int i = 0; i < 105; i++)
for (int j = 0; j < 105; j++) mem[i][j] = -1;
mem[0][0] = 1;
for (int i = 1; i <= n; i++) {
cin >> q[i];
e[q[i]] = i;
}
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
for (int i = 1; i <= n; i++) cur[i] = i;
for (int i = 0; i <= k; i++) {
if (i) first();
old = cur;
for (int j = 0; i + j <= k; j++) {
if (j) second();
if (cur == s) d[i][j] = true;
}
cur = old;
}
for (int i = 0; i <= k; i++)
for (int j = 0; j <= k; j++)
if (i + j == k && d[i][j])
if (dfs(i, j)) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 8;
const double eps = 1e-6;
inline int read() {
int s = 1, a = 0;
char c = getchar();
while (!isdigit(c)) s = (c == '-') ? (-s) : s, c = getchar();
while (isdigit(c)) a = (a << 3) + (a << 1) + c - '0', c = getchar();
return s * a;
}
struct vec {
double angle;
int opt;
bool operator<(const vec &fff) const { return angle < fff.angle; }
};
struct node {
double x, y;
} nd[N];
vector<vec> G;
int n, k;
double mx;
bool check(double mid) {
double r = mid;
G.clear();
for (int i = 1; i <= n; i++) {
double d = sqrt(nd[i].x * nd[i].x + nd[i].y * nd[i].y);
if (d - 2 * r >= eps) continue;
double alpha = atan2(nd[i].y, nd[i].x), beta = acos(d / (2 * r));
if (alpha > beta && alpha > 0) {
G.push_back((vec){alpha - beta, 1});
G.push_back((vec){alpha + beta, -1});
} else if (alpha > 0 && alpha < beta) {
G.push_back((vec){0, 1});
G.push_back((vec){alpha + beta, -1});
G.push_back((vec){alpha - beta + 2 * acos(-1), 1});
G.push_back((vec){2 * acos(-1), -1});
} else if (-alpha > beta) {
alpha += 2 * acos(-1);
G.push_back((vec){alpha - beta, 1});
G.push_back((vec){alpha + beta, -1});
} else {
G.push_back((vec){0, 1});
G.push_back((vec){beta + alpha, -1});
G.push_back((vec){2 * acos(-1) - (beta - alpha), 1});
G.push_back((vec){2 * acos(-1), -1});
}
}
int cnt = 0;
sort(G.begin(), G.end());
for (auto v : G) {
cnt += v.opt;
if (cnt >= k) return 1;
}
return 0;
}
int main() {
n = read(), k = read();
for (int i = 1; i <= n; i++) {
int x = read(), y = read();
nd[i].x = x * 1.0, nd[i].y = y * 1.0;
mx = max(sqrt(nd[i].x * nd[i].x + nd[i].y * nd[i].y), mx);
}
double l = 0.0000, r = mx, ans = 0.0;
while (r - l > eps) {
double mid = (l + r) / 2.0;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.5f", r);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int months[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
tuple<int, int, string> dates(0, 0, "fine");
map<tuple<int, int, string>, int> mp;
int day, month;
string year;
bool check_month(char a, char b) {
if (a == '-' || b == '-') return false;
month = (int)a - (int)'0';
int y = (int)b - (int)'0';
month *= 10;
month += y;
if (month >= 1 && month <= 12) return true;
return false;
}
bool is_day(char a, char b) {
if (a == '-' || b == '-') return false;
if (a == '0' && b == '0') return false;
day = (int)a - (int)'0';
day *= 10;
day += (int)b - (int)'0';
return (day <= months[month - 1]);
}
bool check_year(string nyear) {
year = nyear;
return (nyear == "2013" || nyear == "2014" || nyear == "2015");
}
void add_tomap() {
tuple<int, int, string> news(day, month, year);
mp[news]++;
if (mp[news] > mp[dates]) dates = news;
}
int main() {
string s;
cin >> s;
for (int i = 2; i < s.length() - 5; i++) {
if (s[i] == '-' && s[i + 3] == '-' && check_month(s[i + 1], s[i + 2]) &&
is_day(s[i - 2], s[i - 1]) && check_year(s.substr(i + 4, 4))) {
add_tomap();
}
}
(get<0>(dates) < 10) ? cout << 0 << get<0>(dates) : cout << get<0>(dates);
cout << "-";
(get<1>(dates) < 10) ? cout << 0 << get<1>(dates) : cout << get<1>(dates);
cout << "-";
cout << get<2>(dates);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p, ans = 0, i;
long double paid = 0;
cin >> n >> p;
string temp[2000];
for (i = 0; i < n; i++) {
cin >> temp[i];
}
for (i = n - 1; i >= 0; i--) {
if (temp[i] == "halfplus")
ans = ans * 2 + 1;
else
ans = ans * 2;
paid = paid + (long double)ans / 2;
}
cout << (long long int)(paid * p);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
const int BSZ = 800;
const int N = 100228;
const int LG = 17;
int n, m;
vector<vi> g;
vi pred;
vi in, out;
int timer;
int up[LG][N];
vi ts;
vi evs;
vi sgn;
vector<bool> alive;
vi cnt;
vi dif;
vector<bool> any;
int cur_add;
vi ans;
void dfs(int v) {
in[v] = timer++;
for (int to : g[v]) {
dfs(to);
}
out[v] = timer++;
}
bool upper(int u, int v) { return (in[u] <= in[v] && out[v] <= out[u]); }
int lca(int u, int v) {
if (in[u] > in[v]) {
swap(u, v);
}
if (upper(u, v)) {
return u;
}
for (int i = LG - 1; i >= 0; i--) {
if (!upper(up[i][u], v)) {
u = up[i][u];
}
}
return up[0][u];
}
void dfs_calc(int v) {
cnt[v] = !alive[v];
for (int to : g[v]) {
dfs_calc(to);
cnt[v] += cnt[to];
any[v] = any[v] | any[to];
}
dif[v] = ts[v] - cnt[v];
if (!any[v] && alive[v]) {
cur_add += (dif[v] < 0);
}
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
pred.resize(n, -1);
g.resize(n);
for (int i = 0; i < n - 1; i++) {
int p;
cin >> p;
--p;
pred[i + 1] = p;
g[p].push_back(i + 1);
up[0][i + 1] = p;
}
ts.resize(n);
for (auto& x : ts) {
cin >> x;
}
for (int j = 1; j < LG; j++) {
for (int i = 0; i < n; i++) {
up[j][i] = up[j - 1][up[j - 1][i]];
}
}
in.resize(n);
out.resize(n);
dfs(0);
evs.resize(m);
sgn.resize(m);
for (int i = 0; i < m; i++) {
auto& x = evs[i];
cin >> x;
sgn[i] = (x > 0 ? -1 : 1);
x = abs(x) - 1;
}
alive.resize(n, true);
cnt.resize(n);
dif.resize(n);
any.resize(n);
ans.resize(m, 0);
for (int lb = 0; lb < m; lb += BSZ) {
int rb = min(m, lb + BSZ);
vi guys(rb - lb);
fill((any).begin(), (any).end(), false);
for (int i = lb; i < rb; i++) {
guys[i - lb] = evs[i];
any[guys[i - lb]] = true;
}
sort((guys).begin(), (guys).end(),
[](int u, int v) { return (in[u] < in[v]); });
guys.reserve(2 * (int)((guys).size()));
for (int i = (int)((guys).size()) - 2; i >= 0; i--) {
guys.push_back(lca(guys[i], guys[i + 1]));
}
guys.push_back(0);
sort((guys).begin(), (guys).end(),
[](int u, int v) { return (in[u] < in[v]); });
guys.resize(unique((guys).begin(), (guys).end()) - guys.begin());
vi comp_pred((int)((guys).size()), -1);
vi st;
int edge_check = 0;
for (int i = 0; i < (int)((guys).size()); i++) {
while (!st.empty() && !upper(guys[st.back()], guys[i])) {
st.pop_back();
}
if (!st.empty()) {
comp_pred[i] = st.back();
edge_check++;
}
st.push_back(i);
}
assert(edge_check == (int)((guys).size()) - 1);
cur_add = 0;
dfs_calc(0);
for (int i = lb; i < rb; i++) {
ans[i] = cur_add;
}
for (int i = 0; i < (int)((guys).size()); i++) {
int u = guys[i];
bool st = alive[u];
int udif = dif[u];
for (int j = lb; j < rb; j++) {
if (upper(u, evs[j])) {
udif += sgn[j];
}
if (evs[j] == u) {
st = !st;
}
if (st) {
ans[j] += (udif < 0);
}
}
if (i) {
vi difs;
int anc = guys[comp_pred[i]];
int v = pred[u];
if (anc != v) {
while (v != anc) {
if (alive[v]) {
difs.push_back(dif[v]);
}
v = pred[v];
}
sort((difs).begin(), (difs).end());
vector<pii> pref;
pref.reserve((int)((difs).size()));
for (auto x : difs) {
if (pref.empty()) {
pref.push_back({x, 1});
} else if (x != pref.back().first) {
pref.push_back({x, pref.back().second + 1});
} else {
pref.back().second++;
}
}
int pt = (int)((pref).size());
while (pt > 0 && pref[pt - 1].first >= 0) {
pt--;
}
int bound = 0;
for (int j = lb; j < rb; j++) {
if (upper(u, evs[j])) {
bound -= sgn[j];
if (pt < (int)((pref).size()) && pref[pt].first < bound) {
pt++;
}
if (pt > 0 && pref[pt - 1].first >= bound) {
pt--;
}
}
ans[j] += (pt ? pref[pt - 1].second : 0);
}
}
}
}
for (int i = lb; i < rb; i++) {
int u = evs[i];
alive[u] = !alive[u];
}
}
for (int i = 0; i < m; i++) {
cout << ans[i] << ' ';
}
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
double x, y;
pt() {}
pt(double x, double y) : x(x), y(y) {}
pt operator-(const pt& other) const { return {x - other.x, y - other.y}; }
pt operator+(const pt& other) const { return {x + other.x, y + other.y}; }
pt operator*(double k) const { return {x * k, y * k}; }
};
double dot(const pt& p, const pt& q) { return p.x * q.x + p.y * q.y; }
double cross(const pt& p, const pt& q) { return p.x * q.y - p.y * q.x; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pt> p(n);
for (int i = 0; i < n; ++i) {
cin >> p[i].x >> p[i].y;
}
for (int i = 0; i < n; ++i) {
if (dot(p[i] - p[(i + 1) % n], p[(i + 2) % n] - p[(i + 1) % n]) >= 0) {
cout << "0\n";
return 0;
}
}
double ans = 1e18;
for (int step = 0; step < 2; ++step) {
pt dir = p[1] - p[0];
int j = 0;
for (int k = 0; k < n; ++k) {
if (dot(p[k], dir) > dot(p[j], dir)) {
j = k;
}
}
double curr = 0;
for (int i = 2; i <= j; ++i) {
curr += abs(cross(p[i - 1] - p[0], p[i] - p[0]));
}
for (int i = 0; i < n; ++i) {
dir = p[(i + 1) % n] - p[i];
curr -= abs(cross(p[j] - p[i], p[(i + 1) % n] - p[i]));
while (dot(p[j], dir) < dot(p[(j + 1) % n], dir)) {
int nx = (j + 1) % n;
curr += abs(cross(p[j] - p[(i + 1) % n], p[nx] - p[(i + 1) % n]));
j = nx;
}
double t = dot(p[j] - p[(i + 1) % n], dir) / dot(dir, dir);
pt q = p[(i + 1) % n] + dir * t;
ans = min(ans,
abs(cross(p[j] - p[(i + 1) % n], q - p[(i + 1) % n])) - curr);
}
reverse((p).begin(), (p).end());
}
cout << fixed;
cout.precision(20);
cout << ans / 2 << "\n";
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int day[505];
for (int i = 0; i < n; ++i) {
cin >> day[i];
}
int ok[505];
ok[0] = day[0];
int sum = 0;
for (int i = 1; i < n; i++) {
if (ok[i - 1] + day[i] >= k) {
ok[i] = day[i];
} else {
ok[i] = k - ok[i - 1];
sum += ok[i] - day[i];
}
}
cout << sum << endl;
cout << ok[0];
for (int i = 1; i < n; i++) {
cout << " " << ok[i];
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int place[1000011];
set<int> pos;
set<pair<int, pair<int, int> > > seg;
int n;
int val(int l, int r) {
if (l == 0 and r == n + 1) return n;
if (l == 0) return r - 1;
if (r == n + 1) return n - l;
return max(0, min(r - (l + r) / 2, (l + r) / 2 - l));
}
void add(int l, int r, int id) {
if (l == 0 or r == n + 1) {
if (l == 0) {
place[id] = 1;
seg.insert(make_pair(val(1, r), make_pair(-1, -r)));
} else {
place[id] = n;
seg.insert(make_pair(val(l, n), make_pair(-l, -n)));
}
} else {
place[id] = (r + l) / 2;
seg.insert(make_pair(val(l, place[id]), make_pair(-l, -place[id])));
seg.insert(make_pair(val(place[id], r), make_pair(-place[id], -r)));
}
pos.insert(place[id]);
}
void rem(int id) {
pos.erase(place[id]);
auto it = pos.upper_bound(place[id]);
int r = *it;
--it;
int l = *it;
if (l == 0 and r == n + 1) {
seg.clear();
seg.insert(make_pair(n, make_pair(0, -n - 1)));
return;
}
seg.erase(make_pair(val(l, place[id]), make_pair(-l, -place[id])));
seg.erase(make_pair(val(place[id], r), make_pair(-place[id], -r)));
seg.insert(make_pair(val(l, r), make_pair(-l, -r)));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int m, t, id;
cin >> n >> m;
pos.insert(0);
pos.insert(n + 1);
seg.insert(make_pair(n, make_pair(0, -n - 1)));
while (m--) {
cin >> t >> id;
if (t == 1) {
pair<int, pair<int, int> > x = *seg.rbegin();
seg.erase(x);
add(-x.second.first, -x.second.second, id);
cout << place[id] << "\n";
} else {
rem(id);
}
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans = 0;
cin >> n;
cout << n / 2520 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[1010];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
if (a[0] == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
int cnt = 0;
for (int i = 0; i < n; i++)
if (a[i] == 0) cnt++;
if (cnt != 1)
cout << "NO";
else
cout << "YES";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
vector<int> v1;
vector<int> v2;
map<int, int> mp;
map<int, int>::iterator it;
cin >> n;
while (n--) {
cin >> x >> y;
v1.push_back(x);
v2.push_back(y);
mp[x] = y;
}
int sig = 0;
for (int i = 0; i < v1.size(); i++) {
if (mp[v1[i] + v2[i]]) {
if (mp[v1[i] + v2[i]] + (v1[i] + v2[i]) == v1[i]) {
sig = 1;
cout << "YES" << endl;
break;
}
if (sig == 1) break;
}
}
if (sig == 0) cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int s[1001][1001], n, m;
int dr[] = {0, 1, 1};
int dc[] = {1, 1, 0};
int dr2[] = {-1, -1, 0};
int dc2[] = {0, 1, 1};
int dr3[] = {0, -1, -1};
int dc3[] = {-1, -1, 0};
int dr4[] = {0, 1, 1};
int dc4[] = {-1, -1, 0};
bool check(int i, int j) {
int c = 0;
for (int k = 0; k < 3; k++) {
int nr = i + dr[k];
int nc = j + dc[k];
if (nr < m && nc < n && nr >= 0 && nc >= 0 && s[nr][nc]) {
c++;
}
}
if (c == 3)
return true;
else
return false;
}
bool check2(int i, int j) {
int c = 0;
for (int k = 0; k < 3; k++) {
int nr = i + dr2[k];
int nc = j + dc2[k];
if (nr < m && nc < n && nr >= 0 && nc >= 0 && s[nr][nc]) {
c++;
}
}
if (c == 3)
return true;
else
return false;
}
bool check3(int i, int j) {
int c = 0;
for (int k = 0; k < 3; k++) {
int nr = i + dr3[k];
int nc = j + dc3[k];
if (nr < m && nc < n && nr >= 0 && nc >= 0 && s[nr][nc]) {
c++;
}
}
if (c == 3)
return true;
else
return false;
}
bool check4(int i, int j) {
int c = 0;
for (int k = 0; k < 3; k++) {
int nr = i + dr4[k];
int nc = j + dc4[k];
if (nr < m && nc < n && nr >= 0 && nc >= 0 && s[nr][nc]) {
c++;
}
}
if (c == 3)
return true;
else
return false;
}
int main() {
int k, r, c, sum = 0;
cin >> m >> n >> k;
s[n][m];
while (k--) {
cin >> r >> c;
r--;
c--;
s[r][c] = 1;
sum++;
if (check(r, c) || check2(r, c) || check3(r, c) || check4(r, c)) {
cout << sum << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int c[105][105], dp[105][12];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n;
cin >> n;
long long int a[10];
for (long long int i = 0; i < 10; i++) cin >> a[i];
c[0][0] = 1;
for (long long int i = 1; i < 101; i++) {
for (long long int j = 1; j < i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
c[i][i] = c[i][0] = 1;
}
for (long long int i = a[9]; i <= n; i++) dp[i][9] = 1;
for (long long int i = 8; i > 0; i--) {
for (long long int j = a[i]; j <= n; j++) {
for (long long int k = a[i]; k <= j; k++)
dp[j][i] = (((dp[j - k][i + 1] * c[j][k]) % 1000000007) + dp[j][i]) %
1000000007;
}
}
for (long long int j = a[0] + 1; j <= n; j++) {
for (long long int k = a[0]; k < j; k++)
dp[j][0] =
(((dp[j - k][1] * c[j - 1][k]) % 1000000007) + dp[j][0]) % 1000000007;
}
long long int ans = 0;
for (long long int i = 0; i <= n; i++) ans = (ans + dp[i][0]) % 1000000007;
cout << ans;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, k, dif;
int main() {
int i, j, val;
cin >> n >> k;
dif = (n - k) / 2;
for (i = 0; i < n;) {
val = dif;
j = i;
while ((j < n) && (val)) {
cout << '0';
val--;
j++;
}
i = j;
if (i < n) {
i++;
cout << '1';
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10000000;
const double pi = 3.14159265358979;
double x[N], y[N];
double R, r;
int n;
double dis(int i) {
return sqrt((x[i] - x[0]) * (x[i] - x[0]) + (y[i] - y[0]) * (y[i] - y[0]));
}
void seg_dis(int i) {
int j = i + 1;
double d = dis(i);
R = max(R, d);
r = min(r, d);
if (i == n) j = 1;
double x1 = x[0] - x[i], x2 = x[j] - x[i], y1 = y[0] - y[i], y2 = y[j] - y[i];
double iner = x1 * x2 + y1 * y2;
if (iner < 0) return;
if (iner > x2 * x2 + y2 * y2) return;
d = abs(x1 * y2 - x2 * y1);
d /= sqrt(x2 * x2 + y2 * y2);
r = min(d, r);
}
int main() {
cin >> n;
cin >> x[0] >> y[0];
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
R = -1, r = 10000000000;
for (int i = 1; i <= n; i++) {
seg_dis(i);
}
cout << fixed << setprecision(20) << (R * R - r * r) * pi;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long n;
long long b[maxn];
long long cnt[maxn * 5];
bool vis[maxn * 5];
int main() {
long long ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> b[i];
cnt[b[i] - i + maxn] += b[i];
}
for (int i = 1; i <= n; i++) {
if (!vis[b[i] - i + maxn]) {
vis[b[i] - i + maxn] = 1;
ans = max(ans, cnt[b[i] - i + maxn]);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, n, m, l = 0;
string s;
cin >> a >> n >> m >> s;
for (int i = a - 1; i >= a - n; i--)
if (s[i] == '1' && i != a - m - 1) l++;
if (s[a - m - 1] == '0') l++;
cout << l;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
pair<int, int> arr[200];
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
arr[i].first = x;
arr[i].second = y;
}
for (int i = 0; i < n; i++) {
bool one = false, two = false, three = false, four = false;
for (int j = 0; j < n; j++) {
if (arr[i].first < arr[j].first && arr[i].second == arr[j].second)
one = true;
if (arr[i].first > arr[j].first && arr[i].second == arr[j].second)
two = true;
if (arr[i].first == arr[j].first && arr[i].second < arr[j].second)
three = true;
if (arr[i].first == arr[j].first && arr[i].second > arr[j].second)
four = true;
}
if (one && two && three && four) count++;
}
cout << count << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int cara[25] = {0};
void input() {
for (int i = 1; i < 25; i++) {
cin >> cara[i];
}
return;
}
bool bueno() {
if (cara[1] == cara[3] && cara[1] == cara[6] && cara[1] == cara[8]) {
if (cara[2] == cara[4] && cara[2] == cara[22] && cara[2] == cara[24]) {
if (cara[5] == cara[7] && cara[5] == cara[10] && cara[5] == cara[12]) {
if (cara[9] == cara[11] && cara[9] == cara[21] && cara[9] == cara[23]) {
if (cara[13] == cara[14] && cara[13] == cara[15] &&
cara[13] == cara[16]) {
if (cara[17] == cara[18] && cara[17] == cara[19] &&
cara[17] == cara[20]) {
return true;
}
}
}
}
}
}
if (cara[1] == cara[3] && cara[1] == cara[21] && cara[1] == cara[23]) {
if (cara[2] == cara[4] && cara[2] == cara[5] && cara[2] == cara[7]) {
if (cara[9] == cara[11] && cara[9] == cara[6] && cara[9] == cara[8]) {
if (cara[22] == cara[24] && cara[22] == cara[10] &&
cara[22] == cara[12]) {
if (cara[13] == cara[14] && cara[13] == cara[15] &&
cara[13] == cara[16]) {
if (cara[17] == cara[18] && cara[17] == cara[19] &&
cara[17] == cara[20]) {
return true;
}
}
}
}
}
}
if (cara[5] == cara[6] && cara[5] == cara[19] && cara[5] == cara[20]) {
if (cara[17] == cara[18] && cara[17] == cara[23] && cara[17] == cara[24]) {
if (cara[21] == cara[22] && cara[21] == cara[15] &&
cara[21] == cara[16]) {
if (cara[13] == cara[14] && cara[13] == cara[7] &&
cara[13] == cara[8]) {
if (cara[1] == cara[2] && cara[1] == cara[3] && cara[1] == cara[4]) {
if (cara[9] == cara[10] && cara[9] == cara[11] &&
cara[9] == cara[12]) {
return true;
}
}
}
}
}
}
if (cara[5] == cara[6] && cara[5] == cara[15] && cara[5] == cara[16]) {
if (cara[13] == cara[14] && cara[13] == cara[23] && cara[13] == cara[24]) {
if (cara[17] == cara[18] && cara[17] == cara[7] && cara[17] == cara[8]) {
if (cara[21] == cara[22] && cara[21] == cara[19] &&
cara[21] == cara[20]) {
if (cara[1] == cara[2] && cara[1] == cara[3] && cara[1] == cara[4]) {
if (cara[9] == cara[10] && cara[9] == cara[11] &&
cara[9] == cara[12]) {
return true;
}
}
}
}
}
}
return false;
}
int main() {
input();
if (cara[5] == cara[6] && cara[5] == cara[7] && cara[5] == cara[8]) {
swap(cara[5], cara[13]);
swap(cara[6], cara[14]);
swap(cara[7], cara[15]);
swap(cara[8], cara[16]);
swap(cara[17], cara[5]);
swap(cara[18], cara[6]);
swap(cara[19], cara[7]);
swap(cara[20], cara[8]);
swap(cara[21], cara[17]);
swap(cara[22], cara[18]);
swap(cara[23], cara[19]);
swap(cara[24], cara[20]);
swap(cara[3], cara[4]);
swap(cara[4], cara[2]);
swap(cara[2], cara[1]);
swap(cara[11], cara[9]);
swap(cara[9], cara[10]);
swap(cara[10], cara[12]);
}
if (bueno())
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long res = 0;
int a, b, count = 1, n;
cin >> n >> a;
for (int i = 1; i < n; i++) {
cin >> b;
if (a == b)
res += count++;
else
count = 1;
a = b;
}
cout << res + n;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read(T &x) {
x = 0;
int f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
f |= (ch == '-'), ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
}
return x = f ? -x : x;
}
int main(void) {
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
cout << b * 2 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Tree_Node {
int nxt[30], pre, word, fail, len;
char ch;
} Tree[500];
const char opt[4] = {'A' - 'A', 'C' - 'A', 'G' - 'A', 'T' - 'A'};
int Index = 1, N, M, p, tot, f[500][1050][12], ans;
char s[100];
int cal(int x) {
if (x == 1) return 0;
int tmp = Tree[Tree[x].pre].fail;
while (tmp && Tree[tmp].nxt[Tree[x].ch] == 0) tmp = Tree[tmp].fail;
if (!tmp)
return 1;
else
return Tree[tmp].nxt[Tree[x].ch];
}
void ins(char *s, int id) {
int len = strlen(s), p = 1;
for (int i = 0; i < len; ++i) {
s[i] -= 'A';
if (!Tree[p].nxt[s[i]])
Tree[p].nxt[s[i]] = ++Index, Tree[Index].ch = s[i], Tree[Index].pre = p;
p = Tree[p].nxt[s[i]];
}
Tree[p].word = id;
Tree[p].len = len;
}
void build() {
queue<int> Q;
Q.push(1);
while (Q.size()) {
int u = Q.front();
Q.pop();
Tree[u].fail = cal(u);
if (Tree[Tree[u].fail].len > Tree[u].len)
Tree[u].len = Tree[Tree[u].fail].len;
for (int i = 0; i < 26; ++i)
if (Tree[u].nxt[i]) Q.push(Tree[u].nxt[i]);
}
}
const int inf = 1000000009;
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; ++i) {
scanf("%s", s);
if (strlen(s) <= N) ins(s, i);
}
build();
f[1][0][0] = 1;
for (int j = 0; j <= N; ++j)
for (int i = 1; i <= Index; ++i)
for (int l = 0; l <= 10; ++l)
if (f[i][j][l]) {
for (int k = 0; k < 4; ++k) {
int p = i;
while (p != 1 && !Tree[p].nxt[opt[k]]) p = Tree[p].fail;
p = Tree[p].nxt[opt[k]];
if (!p) continue;
int tl = l + 1;
if (tl <= Tree[p].len) tl = 0;
if (tl > 10) continue;
f[p][j + 1][tl] += f[i][j][l], f[p][j + 1][tl] %= inf;
}
}
for (int i = 1; i <= Index; ++i) ans += f[i][N][0], ans %= inf;
printf("%d\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
pair<int, pair<int, int> > d[700000];
int ind[801], s[801];
int main() {
int n, i, j, a, l = 0, c, k;
cin >> n;
for (i = 1; i < 2 * n; ++i)
for (j = 0; j < i; ++j) {
scanf("%d", &a);
d[l].first = a;
d[l].second.first = i;
d[l].second.second = j;
++l;
}
sort(d, d + l);
for (i = l - 1; i >= 0; --i) {
c = d[i].second.first;
k = d[i].second.second;
if (ind[c] == 0 && ind[k] == 0) {
ind[c] = 1;
ind[k] = 1;
s[c] = k;
s[k] = c;
}
}
for (i = 0; i < 2 * n; ++i) cout << s[i] + 1 << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s1[20] = {"zero", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine",
"ten", "eleven", "twelve", "thirteen", "fourteen",
"fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
string s2[8] = {"twenty", "thirty", "forty", "fifty",
"sixty", "seventy", "eighty", "ninety"};
int main() {
string k;
int n;
cin >> n;
if (n < 20) {
cout << s1[n];
} else if ((n % 10) == 0) {
cout << s2[(n / 10) - 2];
} else {
k = s1[n % 10];
cout << s2[(n / 10) - 2] << "-" << k;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, d;
int c = 0;
char ch;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> ch >> d;
if (ch == '+')
x += d;
else {
if (x >= d)
x -= d;
else
c++;
}
}
cout << x << " " << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, k, c;
cin >> a >> k >> c;
long long b = 1;
while (k--) b *= c;
vector<long long> v(a + 2), l(a + 2), r(a + 2);
for (int i = 1; i <= a; i++) {
cin >> v[i];
}
for (int i = 1; i <= a; i++) {
l[i] = v[i] | l[i - 1];
r[a - i + 1] = v[a - i + 1] | r[a - i + 2];
}
long long ans = 0;
for (int i = 1; i <= a; i++) {
ans = max(ans, l[i - 1] | (v[i] * b) | r[i + 1]);
}
if (ans == 74) {
for (int i = 1; i <= a; i++) cout << l[i] << ' ';
for (int i = 1; i <= a; i++) cout << r[i] << ' ';
for (int i = 1; i <= a; i++) cout << v[i] << ' ';
for (int i = 1; i <= a; i++)
cout << (l[i - 1] | v[i] * b | r[i + 1]) << endl;
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const int maxn = 4e5 + 5;
int n;
struct data {
int x, y;
} da[maxn];
int cmp(data a, data b) { return a.x < b.x; }
map<int, int> dd;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &da[i].x), da[i].y = i;
sort(da + 1, da + n + 1, cmp);
if (n == 2) return puts("1"), 0;
for (int i = 2; i <= n; i++) ++dd[da[i].x - da[i - 1].x];
int tp = dd.size();
for (int i = 1; i <= n; i++) {
int tt = tp;
if (i == 1) {
--dd[da[i + 1].x - da[i].x];
if (dd[da[i + 1].x - da[i].x] == 0) --tp;
} else if (i == n) {
--dd[da[i].x - da[i - 1].x];
if (dd[da[i].x - da[i - 1].x] == 0) --tp;
} else {
--dd[da[i].x - da[i - 1].x];
--dd[da[i + 1].x - da[i].x];
++dd[da[i + 1].x - da[i - 1].x];
if (dd[da[i].x - da[i - 1].x] == 0) --tp;
if (da[i].x - da[i - 1].x != da[i + 1].x - da[i].x &&
dd[da[i + 1].x - da[i].x] == 0)
--tp;
if (dd[da[i + 1].x - da[i - 1].x] == 1) ++tp;
}
if (tp == 1) return printf("%d\n", da[i].y), 0;
if (i == 1) {
++dd[da[i + 1].x - da[i].x];
} else if (i == n) {
++dd[da[i].x - da[i - 1].x];
} else {
++dd[da[i].x - da[i - 1].x];
++dd[da[i + 1].x - da[i].x];
--dd[da[i + 1].x - da[i - 1].x];
}
tp = tt;
}
puts("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 82;
int N, K, i, j, k, x, y, tmp[MN][MN * MN];
deque<pair<int, int> > dp[MN][MN * MN];
vector<int> pos;
inline int eval(pair<int, int> ln, int x) {
return (ln.first - x - 1) * (ln.first - x - 2) / 2 + ln.second;
}
inline double eval(pair<int, int> ln, double x) {
return (ln.first - x - 1) * (ln.first - x - 2) / 2 + ln.second;
}
inline double isect(pair<int, int> ln, pair<int, int> ln2) {
double lo = 0, hi = min(ln.first, ln2.first);
while (lo + 0.001 < hi) {
double mid = (lo + hi) / 2;
if (eval(ln, mid) <= eval(ln2, mid))
hi = mid;
else
lo = mid + 0.001;
}
return lo;
}
int main() {
scanf("%d", &N);
for (i = 1; i <= N; i++) {
scanf("%d", &x);
if (x) {
K++;
pos.push_back(i);
}
}
dp[K][0].push_back({N + 1, 0});
for (i = N; i >= 1; i--) {
memset(tmp, -1, sizeof(tmp));
for (j = 0; j < K; j++) {
for (k = abs(pos[j] - i); k <= N * (N - 1) / 2; k++) {
while (dp[j + 1][k - abs(pos[j] - i)].size() >= 2) {
pair<int, int> fs = dp[j + 1][k - abs(pos[j] - i)].front();
dp[j + 1][k - abs(pos[j] - i)].pop_front();
if (eval(fs, i) >= eval(dp[j + 1][k - abs(pos[j] - i)].front(), i))
continue;
else {
dp[j + 1][k - abs(pos[j] - i)].push_front(fs);
break;
}
}
if (dp[j + 1][k - abs(pos[j] - i)].size()) {
tmp[j][k] = eval(dp[j + 1][k - abs(pos[j] - i)].front(), i);
}
}
}
for (j = 0; j < K; j++) {
for (k = 0; k <= N * (N - 1) / 2; k++) {
if (tmp[j][k] != -1) {
while (dp[j][k].size() >= 2) {
pair<int, int> lst = dp[j][k].back();
dp[j][k].pop_back();
if (ceil(isect(dp[j][k].back(), lst)) <=
floor(isect(lst, make_pair(i, tmp[j][k]))))
continue;
else {
dp[j][k].push_back(lst);
break;
}
}
dp[j][k].push_back({i, tmp[j][k]});
}
while (dp[j][k].size() >= 2) {
pair<int, int> fs = dp[j][k].front();
dp[j][k].pop_front();
if (eval(fs, i) >= eval(dp[j][k].front(), i))
continue;
else {
dp[j][k].push_front(fs);
break;
}
}
}
}
}
int ans = 0;
for (k = 0; k <= N * (N - 1) / 2; k++) {
while (dp[0][k].size() >= 2) {
pair<int, int> fs = dp[0][k].front();
dp[0][k].pop_front();
if (eval(fs, 0) >= eval(dp[0][k].front(), 0))
continue;
else {
dp[0][k].push_front(fs);
break;
}
}
if (dp[0][k].size())
ans = max(ans, (N - K) * (N - K - 1) / 2 - eval(dp[0][k].front(), 0));
printf("%d ", ans);
}
printf("\n");
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int inf = 0x3f3f3f3f;
int n, e[2][maxn], tot, rd[maxn];
int net[maxn], tail[maxn];
inline int read(void) {
int num, sign = 1;
char c;
while (!isdigit(c = getchar()))
if (c == '-') sign = 0;
num = c - '0';
while (isdigit(c = getchar())) num = (num << 1) + (num << 3) + c - '0';
return sign ? num : -num;
}
int dfs(int u) {
tail[u] = u;
if (!tail[net[u]]) return tail[u] = dfs(net[u]);
return tail[u];
}
signed main(void) {
n = read();
for (register int i = 1; i <= n; ++i) net[i] = read(), ++rd[net[i]];
for (register int i = 1; i <= n; ++i)
if (!rd[i]) {
e[0][++tot] = i;
e[1][tot] = dfs(i);
}
int ft = tot;
for (register int i = 1; i <= n; ++i)
if (!tail[i]) {
e[0][++tot] = i;
e[1][tot] = dfs(i);
}
if (tot == 1 && !ft) tot = 0;
printf("%d\n", tot);
for (register int i = 1; i <= tot; ++i)
printf("%d %d\n", e[1][i], e[0][i % tot + 1]);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, fc = pow(10, 6), cc;
int ifr = 0;
string s1, s2, p = "AGCT";
vector<string> v, a, s;
void comp(int isr) {
long long int i, j, rc1, rc2, f1, f2, f;
string cs;
cc = 0;
if (!isr) {
for (i = 0; i < n; i++) {
f1 = 0;
f2 = 1;
rc1 = 0;
rc2 = 0;
cs = s1;
if (i % 2) cs = s2;
for (j = 0; j < m; j++) {
if (cs[f1] - v[i][j]) rc1++;
if (cs[f2] - v[i][j]) rc2++;
f1 ^= 1;
f2 ^= 1;
}
f1 = 0;
f = 1;
if (rc1 < rc2) f = f1;
for (j = 0; j < m; j++) {
s[i][j] = cs[f];
f ^= 1;
}
cc += min(rc1, rc2);
}
} else {
for (i = 0; i < m; i++) {
f1 = 0;
f2 = 1;
rc1 = 0;
rc2 = 0;
cs = s1;
if (i % 2) cs = s2;
for (j = 0; j < n; j++) {
if (cs[f1] - v[j][i]) rc1++;
if (cs[f2] - v[j][i]) rc2++;
f1 ^= 1;
f2 ^= 1;
}
f1 = 0;
f = 1;
if (rc1 < rc2) f = f1;
for (j = 0; j < n; j++) {
s[j][i] = cs[f];
f ^= 1;
}
cc += min(rc1, rc2);
}
}
if (cc < fc) {
fc = cc;
a = s;
ifr = isr;
}
}
void gen(int isr) {
long long int i, j, k;
for (i = 0; i < 4; i++) {
for (j = i + 1; j < 4; j++) {
s1.clear();
s2.clear();
s1 += p[i];
s1 += p[j];
for (k = 0; k < 4; k++) {
if (k != i && k != j) s2 += p[k];
}
comp(isr);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
long long int i;
cin >> n >> m;
v.resize(n);
for (i = 0; i < n; i++) cin >> v[i];
a = v;
s = v;
gen(0);
gen(1);
for (i = 0; i < n; i++) cout << a[i] << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
long long valu[N], res[N], C[N];
void ex_gcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return;
}
ex_gcd(b, a % b, x, y);
long long tmp = y;
y = x - a / b * y;
x = tmp;
}
long long getC(long long k, long long n) {
long long res = 1, x, y;
for (int i = 1; i <= k; i++) {
res = (res * (n - k + i)) % mod;
ex_gcd(i, mod, x, y);
x = (x + mod) % mod;
res = (res * x) % mod;
}
return res;
}
int main() {
int n, k;
while (cin >> n >> k) {
for (int i = 0; i < n; i++) {
scanf("%I64d", &valu[i]);
res[i] = valu[i];
}
if (k != 0) {
for (int i = 0; i < n; i++) C[i] = getC(i, k - 1 + i);
for (int i = 0; i < n; i++) {
for (int j = i - 1; j >= 0; j--) {
res[i] += (C[i - j] * valu[j]) % mod;
res[i] %= mod;
}
}
}
for (int i = 0; i < n; i++)
printf("%I64d%c", res[i], i == n - 1 ? '\n' : ' ');
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
set<pair<pair<int, int>, pair<int, int>>> s;
int main() {
int t;
cin >> t;
while (t--) {
s.clear();
int ans = 0, x = 100000, y = 100000;
string str;
cin >> str;
for (int i = 0; i < str.size(); i++) {
int u = x, v = y;
if (str[i] == 'N')
u = x - 1;
else if (str[i] == 'S')
u = x + 1;
else if (str[i] == 'W')
v = y - 1;
else
v = y + 1;
s.insert({pair<int, int>(x, y), pair<int, int>(u, v)});
s.insert({pair<int, int>(u, v), pair<int, int>(x, y)});
x = u, y = v;
}
ans = 5 * s.size() / 2 + str.size() - s.size() / 2;
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long mod1 = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string s1;
cin >> s1;
vector<int> ans(n);
for (int i = 0; i < n; i++) {
int cur = 1;
for (int j = i; j < n - 1; j++) {
if (s1[j] == 'L')
cur++;
else if (s1[j] == 'R')
break;
}
if (i) {
if (s1[i - 1] == 'R') cur = max(cur, ans[i - 1] + 1);
if (s1[i - 1] == '=') cur = ans[i - 1];
}
ans[i] = cur;
}
for (auto c : ans) {
cout << c << " ";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.2,popcnt,abm,mmx,avx2,tune=native")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-funroll-all-loops,-fpeel-loops,-funswitch-loops")
using namespace std;
const long long mo = 1e9 + 7, sz1 = 2e5 + 5, sz2 = 1e3 + 1;
long long nxt() {
long long x;
cin >> x;
return x;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n = nxt();
long long arr[n];
generate(arr, arr + n, nxt);
long long idx = -1, mx = -1;
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 30; j++) {
if (arr[i] & (1 << j)) mp[j]++;
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 30; j++) {
if (mp[j] != 1) continue;
if (arr[i] & (1 << j)) {
if (j > mx) mx = j, idx = i;
}
}
}
if (idx != -1) swap(arr[0], arr[idx]);
for (long long i = 0; i < n; i++) cout << arr[i] << ' ';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, t, ans;
int main() {
ios_base::sync_with_stdio(0);
static const size_t npos = -1;
char s[1000001];
scanf("%s", s);
int l = strlen(s);
int v[l + 1];
j = 0, k = l - 1;
for (i = 0; i < l; i++) {
if (s[i] == 'l') {
v[k--] = i + 1;
} else {
v[j++] = i + 1;
}
}
for (i = 0; i < l; i++) printf("%d\n", v[i]);
return 0;
}
| 4 |
Subsets and Splits